648 lines
19 KiB
Plaintext
648 lines
19 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 "@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,
|
|
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"),
|
|
)
|
|
}
|