diff --git a/balance_report.typ b/balance_report.typ index 39008a4..fdf4a45 100644 --- a/balance_report.typ +++ b/balance_report.typ @@ -3,10 +3,20 @@ #import "/setup/analysis/class_cost_report.typ": render-class-cost-report #import "/setup/analysis/origin_report.typ": render-origin-report #import "/setup/analysis/craft_report.typ": render-craft-report +#import "/setup/analysis/report_config.typ": chapter-family-enabled #let report-theme = themes.make-theme(theme-name: "steingrund") #let report-theme-var = themes.make-theme-variable(theme-name: "steingrund") +#let report-numbering(..numbers) = { + let patterns = ("1", "1", "1", "I", "a") + numbers.pos().enumerate().map(pair => { + let index = pair.at(0) + let number = pair.at(1) + numbering(patterns.at(index, default: "1"), number) + }).join([.]) + [.] +} + #let configure-report(document) = { set page( paper: "a4", @@ -20,7 +30,7 @@ fill: report-theme.ink, ) set par(justify: true, leading: 0.65em, spacing: 0.75em) - set heading(numbering: "1.1.a.") + set heading(numbering: report-numbering) let heading-label(it) = if it.numbering == none { [] } else { counter(heading).display(it.numbering) @@ -74,8 +84,8 @@ #pagebreak() -#render-class-cost-report() +#if chapter-family-enabled("classes") { render-class-cost-report() } -#render-origin-report() +#if chapter-family-enabled("origins") { render-origin-report() } -#render-craft-report() +#if chapter-family-enabled("craft") { render-craft-report() } diff --git a/data/config/balance_report.yaml b/data/config/balance_report.yaml new file mode 100644 index 0000000..abe1eea --- /dev/null +++ b/data/config/balance_report.yaml @@ -0,0 +1,62 @@ +# Central configuration for the standalone balancing report. +# Ranges use inclusive `min` and `max` values. + +build: + max_tier_exclusive: 5 + +weapons: + natural_precision: 7 + die_sides: 10 + action_budget: 2 + + damage_scenarios: + - key: low + label: Faible + dice: 5 + - key: mid + label: Moyen + dice: 8 + - key: full + label: Total + dice: 14 + + sensitivity: + base_precision: + min: 2 + max: 8 + dice: + min: 3 + max: 14 + comparison_dice: [5, 8, 14] + breakpoint_method: normalized_knee + + armor: + protection: + min: 5 + max: 15 + protection_between_attacks: static + breakpoint_method: largest_marginal_drop + summary_protections: [5, 10, 15] + utilization_protection: 10 + utilization_dice: 8 + +# Ordered list of report sections. Remove or comment an entry to hide it. +chapters: + - classes.overview + - classes.tiers + - classes.alterations + - classes.details + - origins.summary + - origins.characteristics + - origins.abilities + - origins.resistances + - origins.gauge + - origins.passives + - craft.summary + - craft.elements + - craft.mechanics + - craft.weapons.core + - craft.weapons.sensitivity + - craft.weapons.armor + - craft.battle_plan + - craft.audit diff --git a/setup/analysis/class_cost_report.typ b/setup/analysis/class_cost_report.typ index b618a9c..30f030a 100644 --- a/setup/analysis/class_cost_report.typ +++ b/setup/analysis/class_cost_report.typ @@ -5,6 +5,7 @@ #import "../theme/tables.typ" as tables #import "../build_config.typ": school-tiers #import "class_alteration_report.typ": school-alteration-report +#import "report_config.typ": chapter-enabled #let class-chart-labels = ( artilleur: "Art.", @@ -147,7 +148,6 @@ tier-matrix(classes, "gauge-total") for tier in school-tiers { - pagebreak(weak: true) tier-comparison(classes, tier) } } @@ -251,10 +251,10 @@ #let render-class-cost-report(classes: all-class-costs) = { heading(level: 1)[Classes] - portfolio-overview(classes: classes) - cross-class-tier-report(classes: classes) - school-alteration-report() - for (_, class-data) in classes { - class-cost-section(class-data) + if chapter-enabled("classes.overview") { portfolio-overview(classes: classes) } + if chapter-enabled("classes.tiers") { cross-class-tier-report(classes: classes) } + if chapter-enabled("classes.alterations") { school-alteration-report() } + if chapter-enabled("classes.details") { + for (_, class-data) in classes { class-cost-section(class-data) } } } diff --git a/setup/analysis/craft_report.typ b/setup/analysis/craft_report.typ index d32a40f..897f2df 100644 --- a/setup/analysis/craft_report.typ +++ b/setup/analysis/craft_report.typ @@ -5,6 +5,9 @@ #import "../theme/tables.typ" as tables #import "../build_config.typ": craft-tiers #import "weapon_report.typ": weapon-analysis-report +#import "weapon_breakpoint_report.typ": weapon-breakpoint-report +#import "weapon_armor_report.typ": weapon-armor-report +#import "report_config.typ": chapter-enabled #let insight-card(label, value, note) = block( width: 100%, @@ -317,10 +320,12 @@ #let render-craft-report() = { pagebreak() heading(level: 1)[Artisanat] - craft-summary() - element-coverage() - mechanic-analysis() - weapon-analysis-report() - battle-plan() - craft-audit() + if chapter-enabled("craft.summary") { craft-summary() } + if chapter-enabled("craft.elements") { element-coverage() } + if chapter-enabled("craft.mechanics") { mechanic-analysis() } + if chapter-enabled("craft.weapons.core") { weapon-analysis-report() } + if chapter-enabled("craft.weapons.sensitivity") { weapon-breakpoint-report() } + if chapter-enabled("craft.weapons.armor") { weapon-armor-report() } + if chapter-enabled("craft.battle_plan") { battle-plan() } + if chapter-enabled("craft.audit") { craft-audit() } } diff --git a/setup/analysis/origin_report.typ b/setup/analysis/origin_report.typ index ba8fb9d..8900fe9 100644 --- a/setup/analysis/origin_report.typ +++ b/setup/analysis/origin_report.typ @@ -4,6 +4,7 @@ #import "origin_metrics.typ": * #import "report_style.typ": chart-theme, metric-card, report-theme, rounded #import "../theme/tables.typ" as tables +#import "report_config.typ": chapter-enabled #let dictionary-chart(data, title, height: 165pt) = horizontal-bar-chart( ( @@ -360,11 +361,13 @@ #let render-origin-report(origins: all-origin-metrics) = { pagebreak() heading(level: 1)[Origines] - origin-summary(origins: origins) - pagebreak() - characteristic-audit(origins: origins) - ability-audit(origins: origins) - resistance-audit(origins: origins) - jauge-focus(origins: origins) - passive-bonus-detail(origins: origins) + if chapter-enabled("origins.summary") { origin-summary(origins: origins) } + if chapter-enabled("origins.characteristics") { + pagebreak() + characteristic-audit(origins: origins) + } + if chapter-enabled("origins.abilities") { ability-audit(origins: origins) } + if chapter-enabled("origins.resistances") { resistance-audit(origins: origins) } + if chapter-enabled("origins.gauge") { jauge-focus(origins: origins) } + if chapter-enabled("origins.passives") { passive-bonus-detail(origins: origins) } } diff --git a/setup/analysis/report_config.typ b/setup/analysis/report_config.typ new file mode 100644 index 0000000..9719c56 --- /dev/null +++ b/setup/analysis/report_config.typ @@ -0,0 +1,49 @@ +// Typed accessors and validation for the balance-report YAML configuration. +#let report-config = yaml("/data/config/balance_report.yaml") +#let build-settings = report-config.build +#let weapon-settings = report-config.weapons +#let sensitivity-settings = weapon-settings.sensitivity +#let armor-settings = weapon-settings.armor +#let enabled-report-chapters = report-config.chapters + +#let inclusive-range(bounds) = range(bounds.min, bounds.max + 1) + +#let chapter-enabled(id) = id in enabled-report-chapters +#let chapter-family-enabled(family) = enabled-report-chapters.any(id => ( + id.split(".").first() == family +)) + +#assert(weapon-settings.die_sides > 0, message: "weapons.die_sides must be positive") +#assert(weapon-settings.action_budget == 2, message: "Only a 2-action analysis budget is currently supported") +#assert(weapon-settings.damage_scenarios.len() > 0, message: "At least one damage scenario is required") +#assert.eq( + weapon-settings.damage_scenarios.map(item => item.key).dedup().len(), + weapon-settings.damage_scenarios.len(), + message: "Damage scenario keys must be unique", +) +#for required-key in ("low", "mid", "full") { + assert( + required-key in weapon-settings.damage_scenarios.map(item => item.key), + message: "Missing required damage scenario: " + required-key, + ) +} +#assert.eq( + sensitivity-settings.breakpoint_method, + "normalized_knee", + message: "Unsupported weapon sensitivity breakpoint method", +) +#assert.eq( + armor-settings.breakpoint_method, + "largest_marginal_drop", + message: "Unsupported armor breakpoint method", +) +#assert.eq( + armor-settings.protection_between_attacks, + "static", + message: "Only static protection between attacks is currently supported", +) +#assert.eq( + armor-settings.summary_protections.len(), + 3, + message: "Exactly three armor summary protections are required", +) diff --git a/setup/analysis/weapon_armor_breakpoints.typ b/setup/analysis/weapon_armor_breakpoints.typ index be29dd9..c504a8e 100644 --- a/setup/analysis/weapon_armor_breakpoints.typ +++ b/setup/analysis/weapon_armor_breakpoints.typ @@ -1,8 +1,9 @@ // Exact probabilistic armor-destruction model for generated weapons. #import "weapon_metrics.typ": * #import "weapon_breakpoints.typ": comparison-dice-pools, mean, numeric-median +#import "report_config.typ": armor-settings, inclusive-range -#let analyzed-protections = range(5, 16) +#let analyzed-protections = inclusive-range(armor-settings.protection) #let armor-destroyed(damage, protection, armor-break) = ( calc.min(armor-break, calc.max(0, damage - protection)) @@ -86,10 +87,11 @@ let at(protection) = mean(all-weapon-metrics.map(item => ( armor-commitment-analysis(item, dice, protection).destruction ))) + let utilization-protection = armor-settings.utilization_protection let utilization = mean(all-weapon-metrics.filter(item => ( item.armor-break > 0 )).map(item => { - let result = armor-commitment-analysis(item, dice, 10) + let result = armor-commitment-analysis(item, dice, utilization-protection) result.destruction / (item.armor-break * result.attacks) * 100 })) let valid-breakpoints = all-weapon-metrics.map(item => ( @@ -97,10 +99,9 @@ )).filter(point => point != none) ( dice: dice, - protection-5: at(5), - protection-10: at(10), - protection-15: at(15), - utilization-10: utilization, + benchmark-values: armor-settings.summary_protections.map(at), + utilization-protection-damage: at(utilization-protection), + utilization: utilization, median-breakpoint: numeric-median(valid-breakpoints.map(point => point.protection)), ) }) diff --git a/setup/analysis/weapon_armor_report.typ b/setup/analysis/weapon_armor_report.typ index 9d0e46f..8eb642c 100644 --- a/setup/analysis/weapon_armor_report.typ +++ b/setup/analysis/weapon_armor_report.typ @@ -32,10 +32,8 @@ let summary-rows = armor-summary.map(row => ( str(row.dice), - rounded(row.at("protection-5"), digits: 2), - rounded(row.at("protection-10"), digits: 2), - rounded(row.at("protection-15"), digits: 2), - rounded(row.at("utilization-10"), digits: 1) + [%], + ..row.benchmark-values.map(value => rounded(value, digits: 2)), + rounded(row.utilization, digits: 1) + [%], rounded(row.at("median-breakpoint"), digits: 1), )) tables.set-table-style( @@ -43,7 +41,9 @@ columns: (0.55fr, 0.9fr, 0.9fr, 0.9fr, 1.15fr, 1.15fr), align: (right,) * 6, table.header( - [Pool], [Armure détr. P5], [P10], [P15], [Capacité à P10], + [Pool], + ..armor-settings.summary_protections.map(protection => [Armure détr. P#protection]), + [Capacité à P#armor-settings.utilization_protection], [Rupture médiane], ), ..summary-rows.flatten(), @@ -56,9 +56,10 @@ let last = armor-summary.last() let evolution(start, end) = if start == 0 { 0 } else { (end / start - 1) * 100 } [*Conclusion calculée.* Entre #first.dice et #last.dice dés, la destruction - moyenne contre P10 passe de #rounded(first.at("protection-10"), digits: 2) à - #rounded(last.at("protection-10"), digits: 2) - (#rounded(evolution(first.at("protection-10"), last.at("protection-10")), digits: 1)%). + moyenne contre P#armor-settings.utilization_protection passe de + #rounded(first.utilization-protection-damage, digits: 2) à + #rounded(last.utilization-protection-damage, digits: 2) + (#rounded(evolution(first.utilization-protection-damage, last.utilization-protection-damage), digits: 1)%). La rupture médiane se déplace de P#rounded(first.at("median-breakpoint"), digits: 1) à P#rounded(last.at("median-breakpoint"), digits: 1).] @@ -101,12 +102,12 @@ brise-armure disponible sur les attaques retenues. Elle distingue une grande statistique théorique d’une statistique effectivement exploitable.] block(breakable: false)[ - #heading(level: 5)[Utilisation à 8 dés (%) ] + #heading(level: 5)[Utilisation à #armor-settings.utilization_dice dés (%) ] #align(center, heatmap( ( rows: weapon-labels, cols: analyzed-protections.map(value => [P#value]), - values: armor-utilization-grid(8), + values: armor-utilization-grid(armor-settings.utilization_dice), ), cell-size: 17pt, show-values: true, diff --git a/setup/analysis/weapon_breakpoint_report.typ b/setup/analysis/weapon_breakpoint_report.typ index ddd828d..0c98999 100644 --- a/setup/analysis/weapon_breakpoint_report.typ +++ b/setup/analysis/weapon_breakpoint_report.typ @@ -48,7 +48,8 @@ pagebreak() heading(level: 3)[Sensibilité, corrélations et points de rupture] [Cette étude balaie automatiquement les #weapon-sensitivity-cube.len() combinaisons de - 7 seuils de base, 12 tailles de pool et #all-weapon-metrics.len() armes. + #analyzed-base-precisions.len() seuils de base, + #analyzed-dice-pools.len() tailles de pool et #all-weapon-metrics.len() armes. Chaque observation conserve les modificateurs propres à l’arme, `R.Max` et le meilleur partage possible sur 2A.] @@ -101,8 +102,10 @@ [*Conclusion calculée.* L’impact moyen absolu d’un point de précision #trend-word(precision-impacts), de - #rounded(precision-impacts.first(), digits: 1)% à 5 dés à - #rounded(precision-impacts.last(), digits: 1)% à 14 dés + #rounded(precision-impacts.first(), digits: 1)% à + #point-sensitivity-summary.first().dice dés à + #rounded(precision-impacts.last(), digits: 1)% à + #point-sensitivity-summary.last().dice dés (#rounded(relative-evolution(precision-impacts), digits: 1)%). Celui d’un point de dégâts par réussite #trend-word(p-damage-impacts), de #rounded(p-damage-impacts.first(), digits: 1)% à @@ -232,7 +235,8 @@ heading(level: 4)[Rupture de rendement] [Le point de rupture est détecté sans seuil arbitraire: pour chaque courbe, il - s’agit du point de plus forte courbure normalisée entre 3 et 14 dés.] + s’agit du point de plus forte courbure normalisée entre + #analyzed-dice-pools.first() et #analyzed-dice-pools.last() dés.] let knee-rows = knee-summary.map(row => ( str(row.precision), rounded(row.median-dice, digits: 1), diff --git a/setup/analysis/weapon_breakpoints.typ b/setup/analysis/weapon_breakpoints.typ index 46aaf0d..a3d156d 100644 --- a/setup/analysis/weapon_breakpoints.typ +++ b/setup/analysis/weapon_breakpoints.typ @@ -1,10 +1,11 @@ // Sensitivity cube and breakpoint statistics for generated weapons. // Every value is derived from the exact binomial model in weapon_metrics.typ. #import "weapon_metrics.typ": * +#import "report_config.typ": inclusive-range, sensitivity-settings -#let analyzed-base-precisions = range(2, 9) -#let analyzed-dice-pools = range(3, 15) -#let comparison-dice-pools = (5, 8, 14) +#let analyzed-base-precisions = inclusive-range(sensitivity-settings.base_precision) +#let analyzed-dice-pools = inclusive-range(sensitivity-settings.dice) +#let comparison-dice-pools = sensitivity-settings.comparison_dice #let mean(values) = values.sum() / values.len() diff --git a/setup/analysis/weapon_metrics.typ b/setup/analysis/weapon_metrics.typ index 83eda10..6273ede 100644 --- a/setup/analysis/weapon_metrics.typ +++ b/setup/analysis/weapon_metrics.typ @@ -1,6 +1,7 @@ // Offensive metrics derived from the same composed equipment records used by // the forge table. Keep formulas here so future metrics share one data model. #import "../../chapters/craft/forge-data.typ": equipments +#import "report_config.typ": weapon-settings #let weapon-nature-labels = ( Light: "Léger", @@ -21,9 +22,11 @@ // A precision modifier is applied to the natural precision of 7. Each point // changes the success probability of one die by 10 percentage points. -#let natural-precision = 7 +#let natural-precision = weapon-settings.natural_precision +#let precision-die-sides = weapon-settings.die_sides #let success-probability(precision) = ( - calc.max(0, calc.min(10, natural-precision + precision)) / 10 + calc.max(0, calc.min(precision-die-sides, natural-precision + precision)) + / precision-die-sides ) #let binomial-probability(dice, successes, probability) = ( @@ -46,11 +49,11 @@ #assert.eq(expected-attack-damage(8, 2, 5, 1, 1), 8) #assert.eq(expected-attack-damage(8, 2, 5, 5, 1), 16) -#let commitment-pools = ( - (key: "low", label: "Faible", dice: 5), - (key: "mid", label: "Moyen", dice: 8), - (key: "full", label: "Total", dice: 12), -) +#let commitment-pools = weapon-settings.damage_scenarios.map(item => ( + key: item.key, + label: item.label, + dice: item.dice, +)) #let commitment-analysis(base-damage, p-damage, rmax, actions, dice, probability) = { let single = expected-attack-damage( diff --git a/setup/analysis/weapon_report.typ b/setup/analysis/weapon_report.typ index 9366200..d3503b8 100644 --- a/setup/analysis/weapon_report.typ +++ b/setup/analysis/weapon_report.typ @@ -1,11 +1,13 @@ // Presentation layer for generated weapon balancing metrics. #import "@preview/primaviz:0.6.0": grouped-bar-chart, grouped-stacked-bar-chart, horizontal-bar-chart #import "weapon_metrics.typ": * -#import "weapon_breakpoint_report.typ": weapon-breakpoint-report -#import "weapon_armor_report.typ": weapon-armor-report #import "report_style.typ": chart-theme, metric-card, rounded #import "../theme/tables.typ" as tables +#let low-scenario = commitment-pools.find(item => item.key == "low") +#let mid-scenario = commitment-pools.find(item => item.key == "mid") +#let full-scenario = commitment-pools.find(item => item.key == "full") + #let weapon-series(key) = weapon-natures.map(nature => ( name: weapon-nature-labels.at(nature), values: weapon-shapes.map(shape => all-weapon-metrics.find(item => ( @@ -47,11 +49,11 @@ ( name: weapon-nature-labels.at(nature), segments: ( - (name: "5 dés", values: values.map(item => item.commitments.low.best)), - (name: "Gain 5→8", values: values.map(item => ( + (name: str(low-scenario.dice) + " dés", values: values.map(item => item.commitments.low.best)), + (name: "Gain " + str(low-scenario.dice) + "→" + str(mid-scenario.dice), values: values.map(item => ( item.commitments.mid.best - item.commitments.low.best ))), - (name: "Gain 8→12", values: values.map(item => ( + (name: "Gain " + str(mid-scenario.dice) + "→" + str(full-scenario.dice), values: values.map(item => ( item.commitments.full.best - item.commitments.mid.best ))), ), @@ -80,7 +82,9 @@ résultat par le coût d’action généré de l’arme.] heading(level: 3)[Dégâts probabilistes sur 2 actions] - [Chaque dé réussit avec une probabilité de `(7 + Précision) × 10 %`. Les + [Chaque dé réussit avec une probabilité de + `(Précision naturelle + modificateur) / faces`, soit + `(#natural-precision + Précision) / #precision-die-sides`. Les espérances ci-dessous utilisent la distribution binomiale exacte et plafonnent les dégâts à `R.Max`. Pour une arme à 1A, toutes les répartitions possibles du pool entre deux attaques sont comparées à une attaque unique; la meilleure @@ -99,8 +103,10 @@ columns: (1.5fr, 0.52fr, 0.62fr, 0.85fr, 0.85fr, 0.85fr), align: (left,) + (right,) * 5, table.header( - [Arme], [Préc.], [Chance/dé], [Faible · 5 dés], - [Moyen · 8 dés], [Total · 12 dés], + [Arme], [Préc.], [Chance/dé], + [#low-scenario.label · #low-scenario.dice dés], + [#mid-scenario.label · #mid-scenario.dice dés], + [#full-scenario.label · #full-scenario.dice dés], ), ..expectation-rows.flatten(), ), @@ -122,11 +128,12 @@ ) weapon-value-matrix("damage-per-action", digits: 1) - heading(level: 3)[Dégâts attendus à 5, 8 et 12 dés] + heading(level: 3)[Dégâts attendus à #low-scenario.dice, #mid-scenario.dice et #full-scenario.dice dés] [Pour chaque forme, les quatre barres suivent l’ordre léger, moyen, lourd, super-lourd. L’empilement est cumulatif: le premier segment donne les dégâts - à 5 dés, puis les gains supplémentaires jusqu’à 8 et 12 dés. Le sommet est - donc l’espérance réelle à 12 dés.] + à #low-scenario.dice dés, puis les gains supplémentaires jusqu’à + #mid-scenario.dice et #full-scenario.dice dés. Le sommet est donc l’espérance + réelle à #full-scenario.dice dés.] grouped-stacked-bar-chart( (labels: weapon-shapes, groups: commitment-stacked-groups), width: 100%, @@ -176,7 +183,8 @@ align: (left,) + (right,) * 10, table.header( [Arme], [Dég.], [+], [R.Max], [Dég. max], [Brise], [Actions], - [Dég./A], [E·5d], [E·8d], [E·12d], + [Dég./A], [E·#low-scenario.dice d], [E·#mid-scenario.dice d], + [E·#full-scenario.dice d], ), ..rows.flatten(), ), @@ -208,6 +216,4 @@ text-size: 7pt, ) - weapon-breakpoint-report() - weapon-armor-report() } diff --git a/setup/build_config.typ b/setup/build_config.typ index 4a3968e..f4cd547 100644 --- a/setup/build_config.typ +++ b/setup/build_config.typ @@ -1,7 +1,9 @@ -// Shared build-time data limits. +// Shared build-time data limits, sourced from the report configuration. // Tiers are included when `tier < max-tier-exclusive`. +#import "analysis/report_config.typ": build-settings + #let build-config = ( - max-tier-exclusive: 5, + max-tier-exclusive: build-settings.max_tier_exclusive, ) #let max-tier-exclusive = build-config.max-tier-exclusive