// 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() } }), ))