207 lines
7.7 KiB
Plaintext
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()
|