ravenous_typst/setup/analysis/origin_metrics.typ

352 lines
9.5 KiB
Plaintext

// Structured and heuristic metrics extracted from origin YAML files.
#let origin-families = (
(section: "Abyssal", slug: "abyssal"),
(section: "Baloth", slug: "baloth"),
(section: "Béhémoth", slug: "behemoth"),
(section: "Célestial", slug: "celestial"),
(section: "Djieien", slug: "djieien"),
(section: "Dragon", slug: "dragon"),
(section: "Fenrir", slug: "fenrir"),
(section: "Guivre", slug: "guivre"),
(section: "Kraken", slug: "kraken"),
(section: "Léviathan", slug: "leviathan"),
(section: "Röc", slug: "roc"),
(section: "Tréant", slug: "treant"),
(section: "Yénuï", slug: "yenui"),
)
#let origin-sources = (
origin-families
.map(family => range(1, 3).map(index => (
family: family.section,
source: "/data/src/origines/" + family.slug + "_" + str(index) + ".yaml",
)))
.flatten()
)
#let resistance-labels = (
abyssal: "Abyssal",
celestial: "Céleste",
fire: "Feu",
lightning: "Foudre",
pierce: "Perçant",
slash: "Tranchant",
water: "Eau",
wind: "Vent",
)
#let resistance-type(clause) = {
let lowered = lower(clause)
let element = lowered.match(regex("@el_([a-z_]+)"))
let alteration = lowered.match(regex("@al_([a-z_]+)"))
if element != none {
let key = element.captures.first()
resistance-labels.at(key, default: key)
} else if alteration != none {
"Seuil inexistence"
} else if "transcendantale" in lowered {
"Transcendantale"
} else if "élémentaire" in lowered {
"Élémentaire"
} else if "physique" in lowered {
"Physique"
} else if "fatigue" in lowered {
"Fatigue"
} else if "mentale" in lowered {
"Mentale"
} else if "horreur" in lowered {
"Horreur"
} else if "perçant" in lowered {
"Perçant"
} else {
"Non classée"
}
}
#let resistance-value(clause) = {
let resist = clause.match(regex("#resist\((-?\d+)\)"))
let difficulty = clause.match(regex("#ddlvl\s*\(?(-?\d+)\)?"))
let signed = clause.match(regex("(?:^|\s)\+(-?\d+)"))
if resist != none {
int(resist.captures.first())
} else if difficulty != none {
int(difficulty.captures.first())
} else if signed != none {
int(signed.captures.first())
} else {
none
}
}
#let resistance-grants(description, profile, family, stage) = {
let grants = ()
for clause in description.split(",") {
let lowered = lower(clause)
if "résist" in lowered or "resist" in lowered {
grants.push((
profile: profile,
family: family,
stage: stage,
type: resistance-type(clause),
value: resistance-value(clause),
raw: clause.trim(),
))
}
}
grants
}
#let captured-number(clause, patterns) = {
for pattern in patterns {
let found = lower(clause).match(regex(pattern))
if found != none { return int(found.captures.first()) }
}
none
}
// Extract only explicit numeric grants from comma-separated passive clauses.
// Ordering matters: specialized gauges and resistance clauses are rejected
// before broad words such as `jauge` or `fatigue` are considered.
#let passive-bonus-grants(description, profile, family, stage) = {
let grants = ()
for clause in description.split(",") {
let lowered = lower(clause.trim())
let category = none
let subtype = none
let value = none
if "@jauge" in lowered and "@rl_jauge" not in lowered {
value = captured-number(lowered, ("([+-]?\\d+)\\s*@jauge",))
category = "Jauge"
} else if "initiative" in lowered {
value = captured-number(lowered, ("initiative\\s*([+-]?\\d+)",))
category = "Initiative"
} else if (
lowered.match(regex("(?:^|\\s)pv\\s*[+-]?\\d+|[+-]?\\d+\\s*pv(?:\\s|$)"))
!= none
) {
value = captured-number(lowered, (
"pv\\s*([+-]?\\d+)",
"([+-]?\\d+)\\s*pv",
))
category = "PV"
} else if "fatigue" in lowered and "résistance" not in lowered {
value = captured-number(lowered, (
"(?:points? de )?fatigue\\s*([+-]?\\d+)",
"([+-]?\\d+)\\s*points? de fatigue",
))
category = "Fatigue"
} else if "action" in lowered {
value = captured-number(lowered, (
"actions?(?: de)? mouvement\\s*([+-]?\\d+)",
"([+-]?\\d+)\\s*actions?",
))
category = "Actions"
subtype = if "mouvement" in lowered { "Mouvement" } else { "Générale" }
} else if "vitesse" in lowered or "mouvement" in lowered {
value = captured-number(lowered, (
"(?:vitesse|mouvement)(?: aérienne| aquatique)?\\s*([+-]?\\d+)",
"([+-]?\\d+)\\s*(?:vitesse|mouvement)",
))
category = "Mobilité"
subtype = if "aérienne" in lowered {
"Aérienne"
} else if "aquatique" in lowered {
"Aquatique"
} else if "mouvement" in lowered {
"Mouvement"
} else {
"Vitesse"
}
}
if category != none and value != none {
grants.push((
profile: profile,
family: family,
stage: stage,
category: category,
subtype: subtype,
value: value,
raw: clause.trim(),
))
}
}
grants
}
#let analyze-origin(source-data) = {
let data = yaml(source-data.source)
let at-seven = ()
let at-five = ()
for (stat, value) in data.stats.max {
if value == 7 { at-seven.push(stat) }
if value == 5 { at-five.push(stat) }
}
let active = 0
let passive = 0
let by-stage = range(1, 4).map(stage => (stage: stage, active: 0, passive: 0))
let resistances = ()
let passive-bonuses = ()
for stage in data.stades {
for ability in stage.abilities {
let index = stage.number - 1
if ability.type == "named" {
active += 1
by-stage.at(index).active += 1
} else if ability.type == "passive" {
passive += 1
by-stage.at(index).passive += 1
let description = ability.at("description", default: "")
resistances += resistance-grants(
description,
data.name,
source-data.family,
stage.number,
)
passive-bonuses += passive-bonus-grants(
description,
data.name,
source-data.family,
stage.number,
)
}
}
}
let initiative-by-stage = range(1, 4).map(stage => {
let grants = passive-bonuses.filter(grant => (
grant.category == "Initiative" and grant.stage == stage
))
if grants.len() == 0 { 0 } else { grants.map(grant => grant.value).sum() }
})
(
family: source-data.family,
name: data.name,
source: source-data.source,
stats-seven: at-seven,
stats-five: at-five,
active: active,
passive: passive,
by-stage: by-stage,
resistances: resistances,
passive-bonuses: passive-bonuses,
initiative-by-stage: initiative-by-stage,
initiative-total: initiative-by-stage.sum(),
)
}
#let all-origin-metrics = origin-sources.map(analyze-origin)
#let count-values(items) = {
let counts = (:)
for item in items {
counts.insert(item, counts.at(item, default: 0) + 1)
}
counts
}
#let characteristic-counts(
origins: all-origin-metrics,
value: 7,
) = count-values(
origins
.map(origin => if value == 7 { origin.stats-seven } else {
origin.stats-five
})
.flatten(),
)
#let ability-totals(origins: all-origin-metrics) = (
active: origins.map(origin => origin.active).sum(),
passive: origins.map(origin => origin.passive).sum(),
)
#let abilities-by-stage(origins: all-origin-metrics) = range(3).map(index => (
stage: index + 1,
active: origins.map(origin => origin.by-stage.at(index).active).sum(),
passive: origins.map(origin => origin.by-stage.at(index).passive).sum(),
))
#let abilities-by-family(origins: all-origin-metrics) = origin-families.map(
family => {
let members = origins.filter(origin => origin.family == family.section)
(
family: family.section,
active: members.map(origin => origin.active).sum(),
passive: members.map(origin => origin.passive).sum(),
)
},
)
#let all-resistance-grants(origins: all-origin-metrics) = (
origins
.map(
origin => origin.resistances,
)
.flatten()
)
#let resistance-counts(origins: all-origin-metrics) = count-values(
all-resistance-grants(origins: origins).map(grant => grant.type),
)
#let all-passive-bonuses(origins: all-origin-metrics) = (
origins
.map(
origin => origin.passive-bonuses,
)
.flatten()
)
#let bonus-categories = (
"Jauge",
"Initiative",
"Mobilité",
"Fatigue",
"PV",
"Actions",
)
#let bonus-summary(grants) = bonus-categories.map(category => {
let selected = grants.filter(grant => grant.category == category)
(
category: category,
occurrences: selected.len(),
total: if selected.len() == 0 { 0 } else {
selected.map(grant => grant.value).sum()
},
average: if selected.len() == 0 { none } else {
selected.map(grant => grant.value).sum() / selected.len()
},
)
})
#let bonuses-by-stage(grants) = range(1, 4).map(stage => (
stage: stage,
values: bonus-categories.map(category => {
let selected = grants.filter(
grant => grant.stage == stage and grant.category == category,
)
if selected.len() == 0 { 0 } else {
selected.map(grant => grant.value).sum()
}
}),
))
#let bonuses-by-family(grants) = origin-families.map(family => (
family: family.section,
values: bonus-categories.map(category => {
let selected = grants.filter(
grant => grant.family == family.section and grant.category == category,
)
if selected.len() == 0 { 0 } else {
selected.map(grant => grant.value).sum()
}
}),
))