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