From 3b67a92077aafca0dd2bb2bddf1a74aa058e3de7 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Sat, 22 Aug 2026 20:21:40 +0200 Subject: [PATCH] Master reporting --- balance_report_master.typ | 2 + data/config/balance_report_master.yaml | 1 + setup/analysis/creature_reward_metrics.typ | 206 +++++++++++++++++ setup/analysis/creature_reward_report.typ | 257 +++++++++++++++++++++ setup/models/creature.typ | 47 ++-- 5 files changed, 490 insertions(+), 23 deletions(-) create mode 100644 setup/analysis/creature_reward_metrics.typ create mode 100644 setup/analysis/creature_reward_report.typ diff --git a/balance_report_master.typ b/balance_report_master.typ index 1affc0b..be8d946 100644 --- a/balance_report_master.typ +++ b/balance_report_master.typ @@ -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() } diff --git a/data/config/balance_report_master.yaml b/data/config/balance_report_master.yaml index 3e7917e..dae0f43 100644 --- a/data/config/balance_report_master.yaml +++ b/data/config/balance_report_master.yaml @@ -4,5 +4,6 @@ chapters: - creatures.common.profile - creatures.common.rewards + - creatures.rewards.analysis - creatures.common.regions - creatures.durability diff --git a/setup/analysis/creature_reward_metrics.typ b/setup/analysis/creature_reward_metrics.typ new file mode 100644 index 0000000..ea2c198 --- /dev/null +++ b/setup/analysis/creature_reward_metrics.typ @@ -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() diff --git a/setup/analysis/creature_reward_report.typ b/setup/analysis/creature_reward_report.typ new file mode 100644 index 0000000..18944b2 --- /dev/null +++ b/setup/analysis/creature_reward_report.typ @@ -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, + ) +} diff --git a/setup/models/creature.typ b/setup/models/creature.typ index d17a189..cf107ba 100644 --- a/setup/models/creature.typ +++ b/setup/models/creature.typ @@ -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