Balancing report
Build Successful The Ravenous rulebook was built successfully.
Ravenous/ravenous_typst/pipeline/head This commit looks good Details

This commit is contained in:
Dandaedre 2026-08-20 17:37:23 +02:00
parent 4d57b28e2e
commit 8a9722235f
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
5 changed files with 516 additions and 0 deletions

68
balance_report.typ Normal file
View File

@ -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()

View File

@ -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.

4
setup/analysis/_info.md Normal file
View File

@ -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.

View File

@ -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)
}
}

View File

@ -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 }