ravenous_typst/setup/analysis/craft_metrics.typ

654 lines
19 KiB
Plaintext

// Heuristic elemental metrics extracted from the craft TSV portfolio.
#import "../build_config.typ": craft-tiers, tier-is-enabled
#let craft-sources = (
(
craft: "Alchimie",
label: "Réagents",
source: "/data/src/craft/alchemy_reagents.tsv",
name: "Réagents",
tier: "@ar_tier",
effects: ("Effet (Principal)",),
),
(
craft: "Alchimie",
label: "Solvants",
source: "/data/src/craft/alchemy_solvants.tsv",
name: "Solvants",
tier: "@ar_tier",
effects: ("Effet",),
),
(
craft: "Alchimie",
label: "Transmutations",
source: "/data/src/craft/alchemy_transmutations.tsv",
name: "Transmutation",
tier: "@ar_tier",
effects: ("Effet",),
),
(
craft: "Brasserie",
label: "Ferments",
source: "/data/src/craft/brewry_ferments.tsv",
name: "Ferment",
tier: "@ar_tier",
effects: (),
),
(
craft: "Brasserie",
label: "Finitions",
source: "/data/src/craft/brewry_finishing.tsv",
name: "Ferment",
tier: "@ar_tier",
effects: ("Effet",),
),
(
craft: "Brasserie",
label: "Effets principaux",
source: "/data/src/craft/brewry_main_effects.tsv",
name: "Nom",
tier: "@ar_tier",
effects: ("Effet",),
),
(
craft: "Brasserie",
label: "Méthodes",
source: "/data/src/craft/brewry_methods.tsv",
name: "Méthode",
tier: none,
effects: (),
),
(
craft: "Brasserie",
label: "Effets secondaires",
source: "/data/src/craft/brewry_secondary_effects.tsv",
name: "Nom",
tier: "@ar_tier",
effects: ("Effet",),
),
(
craft: "Forge",
label: "Finitions",
source: "/data/src/craft/forge_finishing.tsv",
delimiter: "\t",
name: "Nom de la finition",
tier: "@ar_tier:short",
effects: ("Effet",),
),
(
craft: "Forge",
label: "Matériaux",
source: "/data/src/craft/forge_materials.tsv",
delimiter: "\t",
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.tsv",
name: "Ingrédient",
tier: "@ar_tier",
effects: ("Effet",),
),
(
craft: "Restauration",
label: "Assaisonnements",
source: "/data/src/craft/restoration_seasoning.tsv",
name: "Nom",
tier: "@ar_tier",
effects: ("Effet",),
),
(
craft: "Restauration",
label: "Accompagnements",
source: "/data/src/craft/restoration_sides.tsv",
name: "Accompagnement",
tier: "@ar_tier",
effects: ("Effet",),
),
(
craft: "Pièges",
label: "Pièges",
source: "/data/src/craft/traps.tsv",
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 "@el_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
or "#change(\"damage\"" in lowered
or "#change(\"physical_damage\"" in lowered
or "#change(\"elemental_damage\"" in lowered
) {
"Dégâts"
} else { "Autre" }
}
#let configured-craft-rows(definition) = csv(
definition.source,
delimiter: definition.at(
"delimiter",
default: if definition.source.ends-with(".tsv") { "\t" } else { "," },
),
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 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
}
// Exhaustive macro inventory. Unlike the semantic heuristics below, this
// deliberately retains every @rl_* and @ca_* reference, including unknown
// future macros, plus the elemental-access macro used as a mechanic.
#let rule-reference-labels = (
el_acces: "Accès élémentaire",
rl_am: "Antimatériel",
rl_arbreak: "Brise-armure",
rl_arracher: "Arracher",
rl_fatigue: "Fatigue",
rl_jauge_toxine: "Jauge de toxine",
rl_parmure: "Perce-armure",
rl_protection: "Protection",
rl_rmax: "R.Max",
rl_satiete: "Satiété",
rl_seuil_transcendance: "Seuil de transcendance",
ca_torque: "Torque",
ca_secondaire: "Caractéristiques secondaires",
)
#let analyze-rule-references(definition) = {
let records = ()
for row in configured-craft-rows(definition) {
let tier = if definition.tier == none { none } else {
let found = row.at(definition.tier, default: "").match(regex("-?\\d+"))
if found == none { none } else { int(found.text) }
}
let constraints = (
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 (field, value) in row {
let raw = str(value)
let searchable = lower(field + " " + raw)
for reference in searchable.matches(regex("@(rl|ca|el)_([a-z_]+)")) {
let family = reference.captures.at(0)
let key = reference.captures.at(1)
let macro = family + "_" + key
if family != "el" or key == "acces" {
records.push((
craft: definition.craft,
dataset: definition.label,
item: row.at(definition.name, default: "—"),
tier: tier,
family: family,
key: key,
macro: macro,
label: rule-reference-labels.at(macro, default: "@" + macro),
field: field,
raw: raw,
..constraints,
))
}
}
let structured-references = (
rmax: (family: "rl", key: "rmax"),
armor_break: (family: "rl", key: "arbreak"),
armor_pierce: (family: "rl", key: "parmure"),
protection: (family: "rl", key: "protection"),
torque: (family: "ca", key: "torque"),
)
for change in searchable.matches(regex("#change\\(\"([a-z_]+)\"")) {
let kind = change.captures.first()
if kind in structured-references {
let reference = structured-references.at(kind)
let macro = reference.family + "_" + reference.key
records.push((
craft: definition.craft,
dataset: definition.label,
item: row.at(definition.name, default: "—"),
tier: tier,
family: reference.family,
key: reference.key,
macro: macro,
label: rule-reference-labels.at(macro, default: "@" + macro),
field: field,
raw: raw,
..constraints,
))
}
}
}
}
records
}
#let all-craft-rule-references = (
craft-sources.map(analyze-rule-references).flatten()
)
#let rule-reference-counts = {
let macros = all-craft-rule-references.map(item => item.macro).dedup()
macros
.map(macro => {
let records = all-craft-rule-references.filter(item => (
item.macro == macro
))
let tiers = records
.map(item => item.tier)
.filter(value => value != none)
.sorted()
(
macro: macro,
label: records.first().label,
family: records.first().family,
count: records.len(),
crafts: records.map(item => item.craft).dedup().sorted(),
first-tier: if tiers.len() == 0 { none } else { tiers.first() },
last-tier: if tiers.len() == 0 { none } else { tiers.last() },
)
})
.sorted(key: item => -item.count)
}
#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",
"R.Max",
"Torque",
"Accès élémentaire",
"Altérations",
"Marques",
"Réserve active",
)
#let mark-types = ("poison", "saignement", "regeneration", "corrosif")
#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)\\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 promoted-rule-mechanics = (
(
(macro: "rl_rmax", category: "R.Max"),
(macro: "ca_torque", category: "Torque"),
(macro: "el_acces", category: "Accès élémentaire"),
)
.map(definition => all-craft-rule-references
.filter(reference => (
reference.macro == definition.macro
))
.map(reference => (
craft: reference.craft,
dataset: reference.dataset,
item: reference.item,
category: definition.category,
subtype: none,
raw: reference.raw,
tier: reference.tier,
cost: reference.cost,
level: reference.level,
toxicity: reference.toxicity,
endurance: reference.endurance,
)))
.flatten()
)
#let all-craft-mechanics = (
craft-sources.map(analyze-craft-mechanics).flatten() + promoted-rule-mechanics
)
#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"),
)
}