Master reporting

This commit is contained in:
Dandaedre 2026-08-22 20:21:40 +02:00
parent 30c7869a01
commit 3b67a92077
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
5 changed files with 490 additions and 23 deletions

View File

@ -6,6 +6,7 @@
render-common-reward-report,
)
#import "/setup/analysis/creature_durability_report.typ": render-durability-report
#import "/setup/analysis/creature_reward_report.typ": render-creature-reward-analysis
#let report-config = yaml("/data/config/balance_report_master.yaml")
#let enabled-chapters = report-config.chapters
@ -61,5 +62,6 @@
#if chapter-enabled("creatures.common.profile") { render-common-profile-report() }
#if chapter-enabled("creatures.common.rewards") { render-common-reward-report() }
#if chapter-enabled("creatures.rewards.analysis") { render-creature-reward-analysis() }
#if chapter-enabled("creatures.common.regions") { render-common-region-report() }
#if chapter-enabled("creatures.durability") { render-durability-report() }

View File

@ -4,5 +4,6 @@
chapters:
- creatures.common.profile
- creatures.common.rewards
- creatures.rewards.analysis
- creatures.common.regions
- creatures.durability

View File

@ -0,0 +1,206 @@
// 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()

View File

@ -0,0 +1,257 @@
// Master report for creature reward constraints and effect coverage.
#import "@preview/primaviz:0.6.0": grouped-bar-chart, horizontal-bar-chart
#import "creature_reward_metrics.typ": *
#import "creature_common_report.typ": compact-profile, dash
#import "report_style.typ": chart-theme, metric-card, report-theme, rounded
#import "../theme/tables.typ" as tables
#let reward-pill(item, high: true) = box(
inset: (x: 4pt, y: 1.5pt), radius: 4pt,
fill: (if high { report-theme.chart-2 } else { report-theme.chart-1 }).transparentize(72%),
stroke: 0.4pt + (if high { report-theme.chart-2 } else { report-theme.chart-1 }),
text(size: 6.3pt)[#item.reward.name · #item.value],
)
#let reward-outliers(items, high: true) = if items.len() == 0 { [—] } else {
items.map(item => reward-pill(item, high: high)).join(h(3pt))
}
#let share(part, total) = if total == 0 { "0%" } else {
str(calc.round(part / total * 100)) + "%"
}
#let render-creature-reward-analysis() = {
pagebreak()
heading(level: 2)[Récompenses — Contraintes et effets]
grid(
columns: (1fr,) * 4, column-gutter: 8pt,
metric-card("Récompenses", analyzed-rewards.len()),
metric-card("Avec résistance", rewards-with-resistance.len(), note: [#share(rewards-with-resistance.len(), analyzed-rewards.len()) du portefeuille]),
metric-card("Avec élément", rewards-with-elements.len()),
metric-card("Avec actions", rewards-with-actions.len()),
)
[L’analyse reprend les axes de l’artisanat : contraintes d’accès, familles
mécaniques, éléments et rôle des mentions. Une récompense peut appartenir à
plusieurs familles; les totaux d’effets ne sont donc pas mutuellement
exclusifs. Les écarts sont descriptifs sur seulement 11 entrées. Les
graphiques agrègent des axes stables et les inventaires détaillés utilisent
des tables paginantes, afin de rester lisibles lorsque le catalogue
s’agrandira.]
heading(level: 3)[Contraintes moyennes par difficulté]
grouped-bar-chart(
(
labels: reward-constraints-by-difficulty.map(item => compact-profile(item.difficulty)),
series: constraint-fields.map(field => (
name: field.label,
values: reward-constraints-by-difficulty.map(item => item.at(field.key)),
)),
),
width: 100%, height: 190pt, y-label: [Valeur moyenne], theme: chart-theme,
)
let difficulty-rows = reward-constraints-by-difficulty.map(item => (
compact-profile(item.difficulty), str(item.count),
dash(item.tier), dash(item.cost), dash(item.level), dash(item.endurance),
))
tables.set-table-style(
table(
columns: (1fr, 0.5fr, 0.75fr, 0.75fr, 0.75fr, 0.75fr),
align: (left,) + (right,) * 5,
table.header([Difficulté], [N], [Tier], [Coût], [Niveau], [Finition]),
..difficulty-rows.flatten(),
),
table-theme: "steingrund", text-size: 7.2pt,
)
heading(level: 3)[Distribution et valeurs atypiques]
let constraint-rows = reward-constraint-summaries.map(item => (
item.label, dash(item.average), str(item.min) + "–" + str(item.max),
dash(item.deviation, digits: 2),
reward-outliers(item.low, high: false), reward-outliers(item.high),
))
tables.set-table-style(
table(
columns: (0.75fr, 0.6fr, 0.6fr, 0.65fr, 1.7fr, 1.7fr),
align: (left, right, right, right, left, left),
table.header([Contrainte], [Moyenne], [Étendue], [Écart-type], [Atypiques basses], [Atypiques hautes]),
..constraint-rows.flatten(),
),
table-theme: "steingrund", text-size: 6.8pt,
)
heading(level: 3)[Inventaire des contraintes]
let inventory-rows = analyzed-rewards.map(item => (
item.creature, item.name, compact-profile(item.difficulty), item.family,
dash(item.constraints.tier), dash(item.constraints.cost),
dash(item.constraints.level), dash(item.constraints.endurance),
))
tables.set-table-style(
table(
columns: (1.05fr, 1.4fr, 0.7fr, 0.8fr) + (0.48fr,) * 4,
align: (left, left, left, left) + (right,) * 4,
table.header([Créature], [Récompense], [Difficulté], [Famille], [Tier], [Coût], [Niv.], [Fin.]),
..inventory-rows.flatten(),
),
table-theme: "steingrund", text-size: 6.4pt,
)
pagebreak(weak: true)
heading(level: 3)[Ce qui est donné aux joueurs]
grid(
columns: (1fr, 1fr), column-gutter: 12pt,
horizontal-bar-chart(
(labels: reward-effect-family-counts.map(item => item.label), values: reward-effect-family-counts.map(item => item.count)),
width: 100%, height: calc.max(175pt, reward-effect-family-counts.len() * 20pt),
title: [Familles mécaniques], show-values: true, theme: chart-theme,
),
horizontal-bar-chart(
(labels: reward-element-counts.map(item => item.label), values: reward-element-counts.map(item => item.count)),
width: 100%, height: calc.max(145pt, reward-element-counts.len() * 24pt),
title: [Mentions élémentaires], show-values: true, theme: chart-theme,
),
)
heading(level: 3)[Familles d’effets par difficulté]
let family-matrix = ()
for family in reward-effect-family-counts.map(item => item.label) {
family-matrix.push(family)
for difficulty in hse-profiles {
family-matrix.push(str(reward-effect-count(family, difficulty: difficulty)))
}
family-matrix.push(str(reward-effect-count(family)))
}
tables.set-table-style(
table(
columns: (1.45fr,) + (0.7fr,) * hse-profiles.len() + (0.6fr,),
align: (left,) + (center,) * (hse-profiles.len() + 1),
table.header([Effet], ..hse-profiles.map(compact-profile), [Total]),
..family-matrix,
),
table-theme: "steingrund", text-size: 7pt,
)
heading(level: 3)[Effets extraits par catégorie]
[Chaque ligne conserve la clause qui a déclenché la catégorie. Un même effet
peut donc apparaître dans plusieurs catégories lorsqu’il combine plusieurs
mécaniques.]
let categorized-effect-rows = reward-effect-records.sorted(key: item => (
item.family + item.creature + item.reward
)).map(item => (
item.family, item.creature, item.reward,
compact-profile(item.difficulty), item.clause,
))
tables.set-table-style(
table(
columns: (0.9fr, 0.9fr, 1.15fr, 0.65fr, 2.7fr),
table.header([Catégorie], [Créature], [Récompense], [Difficulté], [Effet extrait]),
..categorized-effect-rows.flatten(),
),
table-theme: "steingrund", text-size: 6.25pt,
)
heading(level: 3)[Résistances et concentration élémentaire]
[#rewards-with-resistance.len() récompenses sur #analyzed-rewards.len()
accordent une résistance (#share(rewards-with-resistance.len(), analyzed-rewards.len())).
Les mentions élémentaires détectées sont comptées ci-dessous; « Physique gén. »
reste distinct des dix éléments afin de ne pas masquer sa portée plus large.]
if reward-resistance-elements.len() == 0 {
[Aucune résistance élémentaire détectée.]
} else {
let resistance-rows = reward-resistance-elements.map(item => (
item.label, str(item.count), share(item.count, reward-element-mentions.len()),
))
tables.set-table-style(
table(
columns: (1.5fr, 0.7fr, 0.9fr), align: (left, right, right),
table.header([Élément ou groupe], [Mentions], [Part des mentions]),
..resistance-rows.flatten(),
),
table-theme: "steingrund", text-size: 7.2pt,
)
}
heading(level: 3)[Audit complet des effets]
let effect-rows = analyzed-rewards.map(item => (
item.creature, item.name, compact-profile(item.difficulty),
item.effects.join(" · "),
if item.elements.len() == 0 { [—] } else { item.elements.map(element => element.label).dedup().join(", ") },
item.effect,
))
tables.set-table-style(
table(
columns: (0.9fr, 1.15fr, 0.65fr, 1.25fr, 0.85fr, 2.35fr),
table.header([Créature], [Récompense], [Difficulté], [Familles], [Éléments], [Effet source]),
..effect-rows.flatten(),
),
table-theme: "steingrund", text-size: 6.1pt,
)
heading(level: 3)[Rendements Base, Combat et Dépeçage]
[Ces valeurs viennent du profil global de chaque créature. Elles sont
analysées séparément des objets précédents : elles décrivent la quantité
disponible selon la source de prélèvement, sans supposer de conversion en
puissance ou en valeur marchande.]
grid(
columns: (1fr,) * 3, column-gutter: 8pt,
metric-card("Profil dominant", dominant-yield-profile.label, note: [#dominant-yield-profile.count créatures]),
metric-card("Combat = dépeçage", equal-battle-carve.len(), note: [sur #creature-yields.len() créatures]),
metric-card("Profils distincts", yield-profile-counts.len()),
)
grouped-bar-chart(
(
labels: yields-by-difficulty.map(item => compact-profile(item.difficulty)),
series: (
(name: "Base", values: yields-by-difficulty.map(item => item.base)),
(name: "Combat", values: yields-by-difficulty.map(item => item.battle)),
(name: "Dépeçage", values: yields-by-difficulty.map(item => item.carve)),
),
),
width: 100%, height: 185pt, y-label: [Rendement moyen], theme: chart-theme,
)
let yield-summary-rows = yield-summaries.map(item => (
item.label, dash(item.average), str(item.min) + "–" + str(item.max),
dash(item.deviation, digits: 2),
))
tables.set-table-style(
table(
columns: (1fr,) * 4, align: (left, right, right, right),
table.header([Source], [Moyenne], [Étendue], [Écart-type]),
..yield-summary-rows.flatten(),
),
table-theme: "steingrund", text-size: 7.2pt,
)
heading(level: 3)[Rendement moyen par difficulté]
let yield-difficulty-rows = yields-by-difficulty.map(item => (
compact-profile(item.difficulty), str(item.count), dash(item.base),
dash(item.battle), dash(item.carve),
))
tables.set-table-style(
table(
columns: (1.2fr, 0.55fr, 0.8fr, 0.8fr, 0.8fr),
align: (left, right, right, right, right),
table.header([Difficulté], [N], [Base], [Combat], [Dépeçage]),
..yield-difficulty-rows.flatten(),
),
table-theme: "steingrund", text-size: 7.2pt,
)
heading(level: 3)[Inventaire des rendements]
let yield-rows = creature-yields.map(item => (
item.creature, compact-profile(item.difficulty), str(item.base),
str(item.battle), str(item.carve),
if item.base == item.battle and item.battle == item.carve { [Identiques] } else { [Différenciés] },
))
tables.set-table-style(
table(
columns: (1.4fr, 0.9fr, 0.65fr, 0.65fr, 0.75fr, 0.9fr),
align: (left, left, right, right, right, left),
table.header([Créature], [Difficulté], [Base], [Combat], [Dépeçage], [Profil]),
..yield-rows.flatten(),
),
table-theme: "steingrund", text-size: 6.8pt,
)
}

View File

@ -65,31 +65,32 @@
#let rich-text(value) = {
if type(value) == str {
let entries = (:)
for entry in glossary { entries.insert(entry.key, entry) }
let db-gls-short(key) = {
let entry = entries.at(key, default: none)
if entry == none {
"@" + key + ":short"
} else {
gls(key, display: entry.short)
}
}
let short-references-to-calls(source) = {
let found = source.match(regex("@([A-Za-z][A-Za-z0-9_]*):short"))
if found == none { return source }
let key = found.captures.first()
(
source.slice(0, found.start)
+ "#db-gls-short(\""
+ key
+ "\")"
+ short-references-to-calls(source.slice(found.end))
)
}
// for entry in glossary { entries.insert(entry.key, entry) }
// let db-gls-short(key) = {
// let entry = entries.at(key, default: none)
// if entry == none {
// "@" + key + ":short"
// } else {
// gls(key, display: entry.short)
// }
// }
// let short-references-to-calls(source) = {
// let found = source.match(regex("@([A-Za-z][A-Za-z0-9_]*):short"))
// if found == none { return source }
// let key = found.captures.first()
// (
// source.slice(0, found.start)
// + "#db-gls-short(\""
// + key
// + "\")"
// + short-references-to-calls(source.slice(found.end))
// )
// }
eval(
short-references-to-calls(value),
value,
// short-references-to-calls(value),
mode: "markup",
scope: macros.bigscope + (db-gls-short: db-gls-short),
scope: macros.bigscope, // + (db-gls-short: db-gls-short),
)
} else {
value