352 lines
9.5 KiB
Plaintext
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()
|
|
}
|
|
}),
|
|
))
|