381 lines
16 KiB
Plaintext
381 lines
16 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 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, so new rule effects cannot silently disappear from reports.
|
|
#let rule-reference-labels = (
|
|
rl_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)_([a-z_]+)")) {
|
|
let family = reference.captures.at(0)
|
|
let key = reference.captures.at(1)
|
|
let macro = family + "_" + key
|
|
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,
|
|
))
|
|
}
|
|
}
|
|
}
|
|
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: "rl_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"),
|
|
)
|
|
}
|