diff --git a/balance_report.typ b/balance_report.typ new file mode 100644 index 0000000..705cf31 --- /dev/null +++ b/balance_report.typ @@ -0,0 +1,68 @@ +// Standalone balance-analysis PDF target. +#import "/setup/theme/themes.typ" as themes +#import "/setup/analysis/class_cost_report.typ": render-class-cost-report + +#let report-theme = themes.make-theme(theme-name: "steingrund") +#let report-theme-var = themes.make-theme-variable(theme-name: "steingrund") + +#let configure-report(document) = { + set page( + paper: "a4", + margin: (x: 1.8cm, y: 1.7cm), + numbering: "1", + ) + set text( + font: report-theme-var("font"), + size: 9.5pt, + lang: "fr", + fill: report-theme.ink, + ) + set par(justify: true, leading: 0.65em, spacing: 0.75em) + set heading(numbering: "1.") + + show heading.where(level: 1): it => block(above: 1.4em, below: 0.8em)[ + #text(size: 20pt, weight: "bold", fill: report-theme.heading)[#it.body] + ] + show heading.where(level: 2): it => block(above: 1em, below: 0.5em)[ + #text(size: 13pt, weight: "bold", fill: report-theme.heading-accent)[#it.body] + ] + show strong: set text(fill: report-theme.emphasis) + show link: set text(fill: report-theme.link) + + document +} + +#show: configure-report + +#set document( + title: "Ravenous — Rapport d’équilibrage", + author: "Dandaedre", +) + +#page(numbering: none)[ + #align(center + horizon)[ + #text(size: 34pt, weight: "bold", fill: report-theme.heading)[ + RAPPORT D’ÉQUILIBRAGE + ] + + #v(0.8em) + + #text(size: 14pt, tracking: 0.08em, fill: report-theme.heading-accent)[ + ÉCOLES DE COMBAT + ] + + #v(1.8em) + + #text(size: 10pt, fill: report-theme.muted-ink)[ + Analyse des coûts en Sang et en Jauge + ] + ] +] + +#pagebreak() + +#outline(title: "Sommaire") + +#pagebreak() + +#render-class-cost-report() diff --git a/setup/_info.md b/setup/_info.md index a0a3123..d146def 100644 --- a/setup/_info.md +++ b/setup/_info.md @@ -3,6 +3,8 @@ This directory contains the Typst modules shared by the rulebook. - `setup.typ` is the stable complete facade and document entry point. - `prelude.typ` is the curated chapter-authoring surface and can be imported with `#import "/setup/prelude.typ": *`. +- `analysis/` contains reusable metric extraction and report presentation for + standalone targets such as `/balance_report.typ`. - `core/` contains project-wide macros and rule constants. - `generation/` turns external data into Typst content. - `models/` contains document and domain-specific presentation models. diff --git a/setup/analysis/_info.md b/setup/analysis/_info.md new file mode 100644 index 0000000..35c6815 --- /dev/null +++ b/setup/analysis/_info.md @@ -0,0 +1,4 @@ +Analysis modules are split into reusable metric extraction and report-specific +presentation. Keep TSV parsing out of report entry points so future balance +sections can reuse the same normalized datasets. + diff --git a/setup/analysis/class_cost_report.typ b/setup/analysis/class_cost_report.typ new file mode 100644 index 0000000..9e865ac --- /dev/null +++ b/setup/analysis/class_cost_report.typ @@ -0,0 +1,301 @@ +// Presentation layer for school cost analysis. +#import "@preview/primaviz:0.6.0": bar-chart, grouped-bar-chart, horizontal-bar-chart +#import "class_costs.typ": * +#import "../theme/themes.typ": make-theme +#import "../theme/tables.typ" as tables + +#let report-theme = make-theme(theme-name: "steingrund") + +#let class-chart-labels = ( + artilleur: "Art.", + einerjar: "Ein.", + franc-tireur: "F.-tir.", + guerrier-mage: "G. mage", + heavy-weapon-specialist: "A. lourdes", + lancier: "Lanc.", + mage-bestial: "M. best.", + maitre-lames: "M.-lames", + protecteur: "Prot.", + sangremage: "Sang.", +) + +#let chart-theme = ( + palette: ( + report-theme.blood, + report-theme.dark-gold, + report-theme.heading-accent, + ), + text-color: report-theme.ink, + text-color-light: report-theme.muted-ink, + axis-stroke: 0.65pt + report-theme.dark-gold, + grid-stroke: 0.5pt + report-theme.dark-gold.transparentize(55%), + marker-stroke: 0.5pt + report-theme.parchment-light, + background: none, + border: none, + show-grid: true, + legend-position: "bottom", + base-size: 7pt, + base-gap: 5pt, +) + +#let rounded(value, digits: 2) = if value == none { + [—] +} else { + str(calc.round(value, digits: digits)) +} + +#let metric-card(label, value, note: none) = block( + width: 100%, + fill: report-theme.parchment, + stroke: 0.6pt + report-theme.border, + inset: 9pt, + radius: 2pt, +)[ + #text(size: 7pt, tracking: 0.08em, weight: "bold", fill: report-theme.heading-subtle)[ + #upper(label) + ] + + #text(size: 18pt, weight: "bold", fill: report-theme.heading)[#value] + + #if note != none { + text(size: 7.5pt, fill: report-theme.muted-ink)[#note] + } +] + +#let cost-series(metrics) = ( + ( + name: "Sang", + values: metrics.map(metric => metric.blood-total), + ), + ( + name: "Jauge", + values: metrics.map(metric => metric.gauge-total), + ), +) + +#let cost-chart(labels, metrics, title: none, height: 175pt) = grouped-bar-chart( + ( + labels: labels, + series: cost-series(metrics), + ), + width: 100%, + height: height, + title: title, + y-label: [Coût cumulé], + theme: chart-theme, +) + +#let class-cost-table(class-data) = { + let rows = class-data.tiers.map(tier => ( + str(tier.tier), + str(tier.techniques), + rounded(tier.blood-total), + rounded(average(tier.blood-total, tier.blood-count)), + rounded(tier.gauge-total), + rounded(average(tier.gauge-total, tier.gauge-count)), + )) + let total = class-data.total + rows.push(( + [*Total*], + strong(str(total.techniques)), + strong(rounded(total.blood-total)), + strong(rounded(average(total.blood-total, total.blood-count))), + strong(rounded(total.gauge-total)), + strong(rounded(average(total.gauge-total, total.gauge-count))), + )) + + tables.set-table-style( + table( + columns: (0.55fr, 0.8fr, 0.85fr, 0.9fr, 0.85fr, 0.9fr), + align: (center, center, right, right, right, right), + table.header( + [Tier], [Techniques], [Sang total], [Sang moy.], [Jauge total], [Jauge moy.], + ), + ..rows.flatten(), + ), + table-theme: "steingrund", + text-size: 8pt, + ) +} + +#let tier-matrix(classes, metric) = { + let headers = range(1, 8).map(tier => [T#tier]) + let rows = () + for (name, class-data) in classes { + rows.push(class-data.display) + for tier in class-data.tiers { + rows.push(rounded(tier.at(metric))) + } + } + + tables.set-table-style( + table( + columns: (1.5fr,) + (0.62fr,) * 7, + align: (left,) + (right,) * 7, + table.header([Classe], ..headers), + ..rows, + ), + table-theme: "steingrund", + text-size: 8pt, + ) +} + +#let tier-comparison(classes, tier-number) = { + let names = classes.keys() + let tier-index = tier-number - 1 + let labels = names.map(name => class-chart-labels.at(name)) + let metrics = classes.values().map(class-data => class-data.tiers.at(tier-index)) + + heading(level: 2)[Tier #tier-number] + + grid( + columns: (1fr, 1fr), + column-gutter: 12pt, + bar-chart( + ( + labels: labels, + values: metrics.map(metric => metric.blood-total), + ), + width: 100%, + height: 180pt, + title: [Coût en Sang], + y-label: [Total], + theme: chart-theme, + ), + bar-chart( + ( + labels: labels, + values: metrics.map(metric => metric.gauge-total), + ), + width: 100%, + height: 180pt, + title: [Coût en Jauge], + y-label: [Total], + theme: chart-theme, + ), + ) +} + +#let cross-class-tier-report(classes: all-class-costs) = { + pagebreak() + heading(level: 1)[Comparaison croisée par tier] + + [Chaque graphique compare les dix classes côte à côte pour un tier donné. + Sang et Jauge utilisent des échelles séparées afin de préserver la lisibilité.] + + heading(level: 2)[Matrice des coûts en Sang] + tier-matrix(classes, "blood-total") + + heading(level: 2)[Matrice des coûts en Jauge] + tier-matrix(classes, "gauge-total") + + for tier in range(1, 8) { + pagebreak(weak: true) + tier-comparison(classes, tier) + } +} + +#let portfolio-overview(classes: all-class-costs) = { + let ordered = classes.values() + let total = portfolio-total(classes: classes) + let tiers = portfolio-tiers(classes: classes) + + heading(level: 1)[Vue d’ensemble] + + grid( + columns: (1fr, 1fr, 1fr, 1fr), + column-gutter: 8pt, + metric-card("Classes", classes.len()), + metric-card("Techniques", total.techniques), + metric-card( + "Sang cumulé", + rounded(total.blood-total), + note: [#total.blood-count coûts renseignés], + ), + metric-card( + "Jauge cumulée", + rounded(total.gauge-total), + note: [#total.gauge-count coûts renseignés], + ), + ) + + heading(level: 2)[Coûts totaux par classe] + + cost-chart( + ordered.map(class-data => class-data.display), + ordered.map(class-data => class-data.total), + height: 205pt, + ) + + heading(level: 2)[Coûts cumulés par tier] + + cost-chart( + tiers.map(tier => "T" + str(tier.tier)), + tiers, + height: 180pt, + ) + + heading(level: 2)[Volume de techniques par classe] + + horizontal-bar-chart( + ( + labels: ordered.map(class-data => class-data.display), + values: ordered.map(class-data => class-data.total.techniques), + ), + width: 100%, + height: 190pt, + x-label: [Nombre de techniques], + theme: chart-theme, + ) +} + +#let class-cost-section(class-data) = { + pagebreak(weak: true) + heading(level: 1)[#class-data.display] + + let total = class-data.total + grid( + columns: (1fr, 1fr, 1fr, 1fr), + column-gutter: 8pt, + metric-card("Techniques", total.techniques), + metric-card( + "Sang moyen", + rounded(average(total.blood-total, total.blood-count)), + note: [sur #total.blood-count coûts], + ), + metric-card( + "Jauge moyenne", + rounded(average(total.gauge-total, total.gauge-count)), + note: [sur #total.gauge-count coûts], + ), + metric-card( + "Coût combiné", + rounded(total.blood-total + total.gauge-total), + note: [somme brute], + ), + ) + + heading(level: 2)[Répartition par tier] + + cost-chart( + class-data.tiers.map(tier => "T" + str(tier.tier)), + class-data.tiers, + height: 165pt, + ) + + heading(level: 2)[Tableau d’audit] + + class-cost-table(class-data) + + text(size: 7.5pt, fill: report-theme.muted-ink)[ + Source : #class-data.source. Les moyennes excluent les cellules de coût vides. + ] +} + +#let render-class-cost-report(classes: all-class-costs) = { + portfolio-overview(classes: classes) + cross-class-tier-report(classes: classes) + for (_, class-data) in classes { + class-cost-section(class-data) + } +} diff --git a/setup/analysis/class_costs.typ b/setup/analysis/class_costs.typ new file mode 100644 index 0000000..0ab698f --- /dev/null +++ b/setup/analysis/class_costs.typ @@ -0,0 +1,141 @@ +// Pure data analysis for school technique costs. +#import "../generation/radar_graphs.typ": school-sources + +#let class-display-names = ( + artilleur: "Artilleur", + einerjar: "Einerjar", + franc-tireur: "Franc-tireur", + guerrier-mage: "Guerrier mage", + heavy-weapon-specialist: "Armes lourdes", + lancier: "Lancier", + mage-bestial: "Mage bestial", + maitre-lames: "Maître-lames", + protecteur: "Protecteur", + sangremage: "Sangremage", +) + +#let empty-tier(tier) = ( + tier: tier, + techniques: 0, + blood-total: 0.0, + blood-count: 0, + gauge-total: 0.0, + gauge-count: 0, +) + +#let numeric-cost(value) = { + let value = value.trim() + if value.match(regex("^-?(?:\d+(?:\.\d+)?|\.\d+)$")) != none { + float(value) + } else { + none + } +} + +#let add-tier-metric(metric, blood, gauge) = { + let result = metric + result.techniques += 1 + if blood != none { + result.blood-total += blood + result.blood-count += 1 + } + if gauge != none { + result.gauge-total += gauge + result.gauge-count += 1 + } + result +} + +#let summarize-tiers(tiers) = { + let total = empty-tier("Total") + for tier in tiers { + total.techniques += tier.techniques + total.blood-total += tier.blood-total + total.blood-count += tier.blood-count + total.gauge-total += tier.gauge-total + total.gauge-count += tier.gauge-count + } + total +} + +// Analyze one school TSV. Columns are resolved from each repeated header, so +// the extra metadata column in heavy_weapon_specialist.tsv is harmless. +#let analyze-class-costs(name, source) = { + let rows = csv(source, delimiter: "\t") + let tiers = range(1, 8).map(empty-tier) + let current-tier = none + let blood-column = none + let gauge-column = none + + for row in rows { + if row.len() == 0 { continue } + let first = row.first().trim() + + if first.starts-with("Tier") { + let digits = first.replace(regex("\D"), "") + if digits != "" { current-tier = int(digits) } + continue + } + + if first == "Technique" { + blood-column = row.position(cell => cell.trim() == "Sang") + gauge-column = row.position(cell => cell.trim() == "Jauge") + if blood-column == none or gauge-column == none { + panic("Missing Sang or Jauge column in `" + str(source) + "`") + } + continue + } + + if first == "" or current-tier == none { continue } + if current-tier < 1 or current-tier > tiers.len() { + panic("Unsupported tier " + str(current-tier) + " in `" + str(source) + "`") + } + + let blood = if blood-column < row.len() { + numeric-cost(row.at(blood-column)) + } else { none } + let gauge = if gauge-column < row.len() { + numeric-cost(row.at(gauge-column)) + } else { none } + let index = current-tier - 1 + tiers.at(index) = add-tier-metric(tiers.at(index), blood, gauge) + } + + ( + name: name, + display: class-display-names.at(name), + source: source, + tiers: tiers, + total: summarize-tiers(tiers), + ) +} + +#let all-class-costs = { + let result = (:) + for (name, source) in school-sources { + result.insert(name, analyze-class-costs(name, source)) + } + result +} + +#let portfolio-tiers(classes: all-class-costs) = { + range(7).map(index => { + let aggregate = empty-tier(index + 1) + for (_, class-data) in classes { + let tier = class-data.tiers.at(index) + aggregate.techniques += tier.techniques + aggregate.blood-total += tier.blood-total + aggregate.blood-count += tier.blood-count + aggregate.gauge-total += tier.gauge-total + aggregate.gauge-count += tier.gauge-count + } + aggregate + }) +} + +#let portfolio-total(classes: all-class-costs) = summarize-tiers( + portfolio-tiers(classes: classes), +) + +#let average(total, count) = if count == 0 { none } else { total / count } +