ravenous_typst/setup/analysis/creature_reward_metrics.typ

207 lines
7.7 KiB
Plaintext

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