ravenous_typst/setup/analysis/creature_reward_metrics.typ

276 lines
8.1 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()
)