// Structured reward constraints and heuristic effect coverage. #import "creature_common_metrics.typ": ( average, common-creatures, counts, extent, hse-profiles, reward-entries, standard-deviation, ) #import "craft_metrics.typ": clause-elements, clause-mechanics #let numeric-marker(text, key) = { let found = text.match(regex("@" + key + ":short\\s+(-?\\d+)")) if found == none { none } else { int(found.captures.first()) } } #let effect-clauses(text) = ( text .split(";") .map(part => ( part .split(".") .map(clause => clause.trim()) .filter(clause => clause != "") )) .flatten() ) #let reward-effect-families(text) = { let lowered = lower(text) let families = effect-clauses(text) .map(clause => ( clause-mechanics(clause).map(item => item.category) )) .flatten() if "résist" in lowered or "resist" in lowered { families.push("Résistances") } if "esquive" in lowered or "parade" in lowered { families.push("Défense") } if "torque" in lowered { families.push("Caractéristiques") } if "recette" in lowered { families.push("Modification de recette") } if "rage" in lowered { families.push("Altérations") } if families.len() == 0 { families.push("Autre") } families.dedup() } #let reward-effect-records-for(reward) = { let records = () for clause in effect-clauses(reward.effect) { let families = reward-effect-families(clause) for family in families { records.push(( reward: reward.name, creature: reward.creature, difficulty: reward.difficulty, family: family, clause: clause, )) } } records } #let analyzed-rewards = reward-entries.map(reward => { let creature = common-creatures.find(item => item.id == reward.creature-id) let constraints = ( tier: numeric-marker(reward.cost, "ar_tier"), cost: numeric-marker(reward.cost, "ar_cst"), level: numeric-marker(reward.cost, "ar_lvl"), endurance: numeric-marker(reward.cost, "ar_end"), ) let elements = effect-clauses(reward.effect) .map(clause => ( clause-elements(clause).map(element => ( key: element.key, label: element.label, role: if "résist" in lower(clause) or "resist" in lower(clause) { "Résistance" } else if "dégât" in lower(clause) or "dégat" in lower(clause) or "degat" in lower(clause) { "Dégâts" } else { "Autre" }, raw: clause, )) )) .flatten() ( id: reward.creature-id, reward-id: reward-entries.position(item => item == reward), creature: reward.creature, difficulty: creature.profile-hse, region: reward.region, name: reward.name, category: reward.category, family: reward.family, cost-raw: reward.cost, effect: reward.effect, constraints: constraints, effects: reward-effect-families(reward.effect), elements: elements, ) }) #let constraint-fields = ( (key: "tier", label: "Tier"), (key: "cost", label: "Coût"), (key: "level", label: "Niveau"), (key: "endurance", label: "Finition"), ) #let reward-constraint-value(reward, key) = reward.constraints.at(key) #let reward-constraint-summaries = constraint-fields.map(field => { let observations = analyzed-rewards .map(reward => ( reward: reward, value: reward-constraint-value(reward, field.key), )) .filter(item => item.value != none) let values = observations.map(item => item.value) let limits = extent(values) let mean = average(values) let deviation = standard-deviation(values) let enriched = observations.map(item => ( item + ( z: if deviation == none or deviation == 0 { 0 } else { (item.value - mean) / deviation }, ) )) ( key: field.key, label: field.label, average: mean, deviation: deviation, min: limits.min, max: limits.max, low: enriched.filter(item => item.z <= -1.5).sorted(key: item => item.z), high: enriched.filter(item => item.z >= 1.5).sorted(key: item => -item.z), ) }) #let reward-constraints-by-difficulty = hse-profiles.map(difficulty => { let rewards = analyzed-rewards.filter(item => item.difficulty == difficulty) ( difficulty: difficulty, count: rewards.len(), tier: average(rewards.map(item => item.constraints.tier)), cost: average(rewards.map(item => item.constraints.cost)), level: average(rewards.map(item => item.constraints.level)), endurance: average(rewards.map(item => item.constraints.endurance)), ) }) #let effect-family-order = ( "Résistances", "Caractéristiques", "Actions", "Défense", "Altérations", "Marques", "Modification de recette", "PV", "Fatigue", "Autre", ) #let reward-effect-family-counts = ( effect-family-order .map(family => ( label: family, count: analyzed-rewards.filter(reward => family in reward.effects).len(), )) .filter(item => item.count > 0) .sorted(key: item => -item.count) ) #let reward-effect-count(family, difficulty: none) = ( analyzed-rewards .filter(reward => ( family in reward.effects and (difficulty == none or reward.difficulty == difficulty) )) .len() ) #let reward-element-mentions = ( analyzed-rewards .map(reward => reward.elements.map(element => ( reward: reward, difficulty: reward.difficulty, ..element, ))) .flatten() ) #let reward-element-counts = counts(reward-element-mentions.map(item => { item.label })) #let reward-resistance-elements = counts( reward-element-mentions .filter(item => ( item.role == "Résistance" )) .map(item => item.label), ) #let rewards-with-resistance = analyzed-rewards.filter(item => ( "Résistances" in item.effects )) #let rewards-with-elements = analyzed-rewards.filter(item => ( item.elements.len() > 0 )) #let rewards-with-actions = analyzed-rewards.filter(item => ( "Actions" in item.effects )) #let unclassified-rewards = analyzed-rewards.filter(item => ( item.effects == ("Autre",) )) // One record per classified clause and family. This keeps the actual effect // visible and naturally scales when new rewards or categories are introduced. #let reward-effect-records = ( analyzed-rewards.map(reward-effect-records-for).flatten() ) #let reward-effect-record-count(family) = ( reward-effect-records .filter(item => ( item.family == family )) .len() ) // Blood yield is a separate, universally available reward axis on creatures. #let yield-fields = ( (key: "blood-base", label: "Base"), (key: "blood-battle", label: "Combat"), (key: "blood-carve", label: "Dépeçage"), ) #let creature-yields = common-creatures.map(creature => ( creature: creature.name, difficulty: creature.profile-hse, base: creature.blood-base, battle: creature.blood-battle, carve: creature.blood-carve, )) #let yield-value(item, key) = if key == "blood-base" { item.base } else if ( key == "blood-battle" ) { item.battle } else { item.carve } #let yield-summary(field, entries: creature-yields) = { let values = entries.map(item => yield-value(item, field.key)) let limits = extent(values) ( key: field.key, label: field.label, average: average(values), min: limits.min, max: limits.max, deviation: standard-deviation(values), ) } #let yield-summaries = yield-fields.map(yield-summary) #let yields-by-difficulty = hse-profiles.map(difficulty => { let entries = creature-yields.filter(item => item.difficulty == difficulty) ( difficulty: difficulty, count: entries.len(), base: average(entries.map(item => item.base)), battle: average(entries.map(item => item.battle)), carve: average(entries.map(item => item.carve)), ) }) #let identical-yield-profiles = creature-yields.filter(item => ( item.base == item.battle and item.battle == item.carve )) #let equal-battle-carve = creature-yields.filter(item => ( item.battle == item.carve )) #let yield-profile-counts = counts(creature-yields.map(item => ( str(item.base) + " / " + str(item.battle) + " / " + str(item.carve) ))) #let dominant-yield-profile = ( yield-profile-counts.sorted(key: item => -item.count).first() )