ravenous_typst/setup/analysis/craft_metrics.typ

283 lines
13 KiB
Plaintext

// Heuristic elemental metrics extracted from the craft CSV portfolio.
#import "../build_config.typ": craft-tiers, tier-is-enabled
#let craft-sources = (
(craft: "Alchimie", label: "Réagents", source: "/data/src/craft/alchemy_reagents.csv", name: "Réagents", tier: "@ar_tier", effects: ("Effet (Principal)",)),
(craft: "Alchimie", label: "Solvants", source: "/data/src/craft/alchemy_solvants.csv", name: "Solvants", tier: "@ar_tier", effects: ("Effet",)),
(craft: "Alchimie", label: "Transmutations", source: "/data/src/craft/alchemy_transmutations.csv", name: "Transmutation", tier: "@ar_tier", effects: ("Effet",)),
(craft: "Brasserie", label: "Ferments", source: "/data/src/craft/brewry_ferments.csv", name: "Ferment", tier: "@ar_tier", effects: ()),
(craft: "Brasserie", label: "Finitions", source: "/data/src/craft/brewry_finishing.csv", name: "Ferment", tier: "@ar_tier", effects: ("Effet",)),
(craft: "Brasserie", label: "Effets principaux", source: "/data/src/craft/brewry_main_effects.csv", name: "Nom", tier: "@ar_tier", effects: ("Effet",)),
(craft: "Brasserie", label: "Méthodes", source: "/data/src/craft/brewry_methods.csv", name: "Méthode", tier: none, effects: ()),
(craft: "Brasserie", label: "Effets secondaires", source: "/data/src/craft/brewry_secondary_effects.csv", name: "Nom", tier: "@ar_tier", effects: ("Effet",)),
(craft: "Forge", label: "Finitions", source: "/data/src/craft/forge_finishing.csv", name: "Nom de la finition", tier: "@ar_tier:short", effects: ("Effet",)),
(craft: "Forge", label: "Matériaux", source: "/data/src/craft/forge_materials.csv", name: "Matériau", tier: "@ar_tier:short", effects: ("Effets sur les Armes", "Effet sur les Armures et Boucliers")),
(craft: "Restauration", label: "Ingrédients", source: "/data/src/craft/restoration_main.csv", name: "Ingrédient", tier: "@ar_tier", effects: ("Effet",)),
(craft: "Restauration", label: "Assaisonnements", source: "/data/src/craft/restoration_seasoning.csv", name: "Nom", tier: "@ar_tier", effects: ("Effet",)),
(craft: "Restauration", label: "Accompagnements", source: "/data/src/craft/restoration_sides.csv", name: "Accompagnement", tier: "@ar_tier", effects: ("Effet",)),
(craft: "Pièges", label: "Pièges", source: "/data/src/craft/traps.csv", name: "Type", tier: "@ar_tier:short", effects: ("Effet",)),
)
#let craft-order = ("Alchimie", "Brasserie", "Forge", "Restauration", "Pièges")
#let context-order = ("Dégâts", "Résistance", "Accès", "Autre")
#let element-definitions = (
(key: "fire", label: "Feu"), (key: "ice", label: "Glace"),
(key: "lightning", label: "Foudre"), (key: "water", label: "Eau"),
(key: "wind", label: "Vent"), (key: "earth", label: "Terre"),
(key: "wood", label: "Bois"), (key: "magma", label: "Magma"),
(key: "celestial", label: "Céleste"), (key: "abyssal", label: "Abyssal"),
(key: "slash", label: "Tranchant"), (key: "pierce", label: "Perçant"),
(key: "blunt", label: "Contondant"), (key: "physique", label: "Physique gén."),
(key: "elementaire", label: "Élémentaire gén."), (key: "neutral", label: "Neutre"),
(key: "pure", label: "Pur"),
)
#let effect-context(text) = {
let lowered = lower(text)
if "@rl_acces" in lowered or "accès à l'élément" in lowered { "Accès" }
else if "résist" in lowered or "resist" in lowered { "Résistance" }
else if "dégât" in lowered or "dégat" in lowered or "degat" in lowered { "Dégâts" }
else { "Autre" }
}
#let configured-craft-rows(definition) = csv(
definition.source,
row-type: dictionary,
).filter(row => {
if definition.tier == none { true } else {
let raw = row.at(definition.tier, default: "")
let found = raw.match(regex("-?\d+"))
found == none or tier-is-enabled(int(found.text))
}
})
#let clause-elements(clause) = {
let lowered = lower(clause)
let found = element-definitions.filter(element => "@el_" + element.key in lowered)
if found.len() == 0 and "physique" in lowered {
found.push(element-definitions.find(element => element.key == "physique"))
}
if found.len() == 0 and "élémentaire" in lowered {
found.push(element-definitions.find(element => element.key == "elementaire"))
}
found
}
#let analyze-craft-source(definition) = {
let rows = configured-craft-rows(definition)
let mentions = ()
for row in rows {
for effect-key in definition.effects {
let effect = row.at(effect-key, default: "")
for semicolon-clause in effect.split(";") {
for clause in semicolon-clause.split(".") {
let cleaned = clause.trim()
for element in clause-elements(cleaned) {
mentions.push((
craft: definition.craft, dataset: definition.label,
item: row.at(definition.name, default: "—"),
tier: if definition.tier == none { none } else { row.at(definition.tier, default: none) },
element: element.label, key: element.key,
role: effect-context(cleaned), raw: cleaned,
))
}
}
}
}
}
(definition: definition, entries: rows.len(), mentions: mentions)
}
#let all-craft-data = craft-sources.map(analyze-craft-source)
#let all-craft-mentions = all-craft-data.map(data => data.mentions).flatten()
#let craft-entry-count(craft: none) = all-craft-data.filter(data => craft == none or data.definition.craft == craft).map(data => data.entries).sum()
#let selected-mentions(craft: none, role: none, element: none, tier: none) = all-craft-mentions.filter(mention => (
(craft == none or mention.craft == craft) and (role == none or mention.role == role) and
(element == none or mention.element == element) and (tier == none or mention.tier == str(tier))
))
#let element-counts(role: none) = element-definitions.map(element => (
label: element.label, count: selected-mentions(role: role, element: element.label).len(),
)).filter(item => item.count > 0)
#let tier-counts(role: none) = craft-tiers.map(tier => (tier: tier, count: selected-mentions(role: role, tier: tier).len()))
#let ranked-elements(role) = element-counts(role: role).sorted(key: item => -item.count)
#let coverage-gap(from-role, against-role) = element-counts(role: from-role).filter(item => (
selected-mentions(role: against-role, element: item.label).len() == 0
)).map(item => item.label)
#let ranked-crafts(role) = craft-order.map(craft => (
label: craft,
count: selected-mentions(craft: craft, role: role).len(),
)).sorted(key: item => -item.count)
#let ranked-tiers(role) = tier-counts(role: role).sorted(key: item => -item.count)
#let ranked-craft-breadth = craft-order.map(craft => (
label: craft,
count: element-definitions.filter(element => (
selected-mentions(craft: craft, element: element.label).len() > 0
)).len(),
)).sorted(key: item => -item.count)
#let versatile-elements = element-definitions.map(element => {
let damage = selected-mentions(role: "Dégâts", element: element.label).len()
let resistance = selected-mentions(role: "Résistance", element: element.label).len()
(
label: element.label,
damage: damage,
resistance: resistance,
overlap: calc.min(damage, resistance),
total: damage + resistance,
)
}).filter(item => item.overlap > 0).sorted(
key: item => -(item.overlap * 1000 + item.total),
)
// Secondary heuristic axis: effect families and their balancing constraints.
#let mechanic-order = (
"Actions", "Fatigue", "Caractéristiques", "PV",
"Altérations", "Marques", "Réserve active",
)
#let mark-types = ("poison", "saignement", "regeneration", "corrosif")
#let field-number(row, keys) = {
for key in keys {
let raw = row.at(key, default: none)
if raw != none {
let found = raw.match(regex("-?\\d+"))
if found != none { return int(found.text) }
}
}
none
}
#let clause-mechanics(clause) = {
let lowered = lower(clause)
let categories = ()
let alterations = lowered.matches(regex("@al_([a-z_]+)"))
let is-marks = "marque" in lowered and alterations.len() > 0
if "action" in lowered { categories.push((category: "Actions", subtype: none)) }
if "fatigue" in lowered { categories.push((category: "Fatigue", subtype: none)) }
if "dés de la réserve active" in lowered or "dés de la reserve active" in lowered {
categories.push((category: "Réserve active", subtype: none))
}
if "pv" in lowered or "point de vie" in lowered or "points de vie" in lowered {
categories.push((category: "PV", subtype: none))
}
let stat-gain = lowered.match(regex(
"(?:@ca_)?(?:force|agilité|agilite|chance|intelligence|perception|psyché|psyche|charisme|volonté|volonte|torque)\\s*[+-]\\s*\\d+",
))
if stat-gain != none {
categories.push((category: "Caractéristiques", subtype: none))
}
for alteration in alterations {
let subtype = alteration.captures.first()
if is-marks and subtype in mark-types {
categories.push((category: "Marques", subtype: subtype))
} else {
categories.push((category: "Altérations", subtype: subtype))
}
}
categories
}
#let analyze-craft-mechanics(definition) = {
let rows = configured-craft-rows(definition)
let records = ()
for row in rows {
let constraints = (
tier: field-number(row, ("@ar_tier", "@ar_tier:short")),
cost: field-number(row, ("@ar_cst", "@ar_cst:short", "Coût")),
level: field-number(row, ("@ar_lvl", "@ar_lvl:short")),
toxicity: field-number(row, ("@ar_tox", "Toxicité")),
endurance: field-number(row, ("@ar_end", "@ar_end:short")),
)
for effect-key in definition.effects {
let effect = row.at(effect-key, default: "")
for semicolon-clause in effect.split(";") {
for clause in semicolon-clause.split(".") {
let cleaned = clause.trim()
for mechanic in clause-mechanics(cleaned) {
records.push((
craft: definition.craft,
dataset: definition.label,
item: row.at(definition.name, default: "—"),
category: mechanic.category,
subtype: mechanic.subtype,
raw: cleaned,
..constraints,
))
}
}
}
}
}
records
}
#let all-craft-mechanics = craft-sources.map(analyze-craft-mechanics).flatten()
#let selected-mechanics(category: none, subtype: none, tier: none) = all-craft-mechanics.filter(item => (
(category == none or item.category == category) and
(subtype == none or item.subtype == subtype) and
(tier == none or item.tier == tier)
))
#let mechanic-counts = mechanic-order.map(category => (
label: category, count: selected-mechanics(category: category).len(),
)).sorted(key: item => -item.count)
#let mechanic-tier-counts(category) = craft-tiers.map(tier => (
tier: tier, count: selected-mechanics(category: category, tier: tier).len(),
))
#let average-present(records, key) = {
let values = records.map(record => record.at(key)).filter(value => value != none)
if values.len() == 0 { none } else { calc.round(values.sum() / values.len(), digits: 1) }
}
#let range-present(records, key) = {
let values = records.map(record => record.at(key)).filter(value => value != none).sorted()
if values.len() == 0 { none } else { (min: values.first(), max: values.last(), count: values.len()) }
}
#let mechanic-profile(category) = {
let records = selected-mechanics(category: category)
let tiers = mechanic-tier-counts(category)
let present = tiers.filter(item => item.count > 0)
let peak = present.sorted(key: item => -item.count).first()
let changes = craft-tiers.slice(1).map(tier => (
tier: tier,
increase: tiers.at(tier).count - tiers.at(tier - 1).count,
)).sorted(key: item => -item.increase)
(
category: category,
count: records.len(),
first-tier: present.first().tier,
peak-tier: peak.tier,
peak-count: peak.count,
breakpoint-tier: changes.first().tier,
breakpoint-increase: changes.first().increase,
cost: average-present(records, "cost"),
level: average-present(records, "level"),
toxicity: average-present(records, "toxicity"),
endurance: average-present(records, "endurance"),
)
}
#let mechanic-profiles = mechanic-order.map(mechanic-profile)
#let subtype-counts(category) = {
let counts = (:)
for record in selected-mechanics(category: category) {
if record.subtype != none {
counts.insert(record.subtype, counts.at(record.subtype, default: 0) + 1)
}
}
counts.pairs().map(pair => (label: pair.first(), count: pair.last())).sorted(key: item => -item.count)
}
#let subtype-profile(category, subtype) = {
let records = selected-mechanics(category: category, subtype: subtype)
let tiers = craft-tiers.map(tier => (
tier: tier, count: records.filter(item => item.tier == tier).len(),
))
let present = tiers.filter(item => item.count > 0)
let peak = present.sorted(key: item => -item.count).first()
(
subtype: subtype, count: records.len(), first-tier: present.first().tier,
peak-tier: peak.tier, cost: average-present(records, "cost"),
level: average-present(records, "level"), toxicity: average-present(records, "toxicity"),
)
}