From f1ccb44ccdb71c425c04a4a4506c3af08e301a57 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Fri, 21 Aug 2026 00:39:40 +0200 Subject: [PATCH 1/5] More weapon balancing --- setup/analysis/_info.md | 2 + setup/analysis/craft_report.typ | 2 + setup/analysis/weapon_breakpoint_report.typ | 141 +++++++++++++ setup/analysis/weapon_breakpoints.typ | 147 ++++++++++++++ setup/analysis/weapon_metrics.typ | 144 +++++++++++++ setup/analysis/weapon_report.typ | 211 ++++++++++++++++++++ 6 files changed, 647 insertions(+) create mode 100644 setup/analysis/weapon_breakpoint_report.typ create mode 100644 setup/analysis/weapon_breakpoints.typ create mode 100644 setup/analysis/weapon_metrics.typ create mode 100644 setup/analysis/weapon_report.typ diff --git a/setup/analysis/_info.md b/setup/analysis/_info.md index 328f923..a9332bb 100644 --- a/setup/analysis/_info.md +++ b/setup/analysis/_info.md @@ -9,4 +9,6 @@ sections can reuse the same normalized datasets. abilities, and heuristically detected resistance grants. - `craft_metrics.typ` and `craft_report.typ` analyze elemental damage, resistance, access, progression, and the resulting heuristic battle plan. +- `weapon_metrics.typ` and `weapon_report.typ` derive offensive balance values + from the generated forge equipment records. - `report_style.typ` contains presentation primitives shared by report sections. diff --git a/setup/analysis/craft_report.typ b/setup/analysis/craft_report.typ index 716c32b..d32a40f 100644 --- a/setup/analysis/craft_report.typ +++ b/setup/analysis/craft_report.typ @@ -4,6 +4,7 @@ #import "report_style.typ": chart-theme, metric-card, report-theme, rounded #import "../theme/tables.typ" as tables #import "../build_config.typ": craft-tiers +#import "weapon_report.typ": weapon-analysis-report #let insight-card(label, value, note) = block( width: 100%, @@ -319,6 +320,7 @@ craft-summary() element-coverage() mechanic-analysis() + weapon-analysis-report() battle-plan() craft-audit() } diff --git a/setup/analysis/weapon_breakpoint_report.typ b/setup/analysis/weapon_breakpoint_report.typ new file mode 100644 index 0000000..8d7e37b --- /dev/null +++ b/setup/analysis/weapon_breakpoint_report.typ @@ -0,0 +1,141 @@ +// Visual report for the weapon sensitivity cube and its computed breakpoints. +#import "@preview/primaviz:0.6.0": correlation-matrix, heatmap, multi-scatter-plot +#import "weapon_breakpoints.typ": * +#import "report_style.typ": chart-theme, rounded +#import "../theme/tables.typ" as tables +#import "../theme/themes.typ": make-theme + +#let report-theme = make-theme(theme-name: "steingrund") +#let sensitivity-palette = ( + report-theme.at("chart-4"), + report-theme.at("chart-3"), + report-theme.at("chart-2"), + report-theme.at("parchment-light"), +) +#let correlation-palette = ( + report-theme.at("chart-1"), + report-theme.at("parchment-light"), + report-theme.at("chart-2"), +) + +#let weapon-breakpoint-report() = { + 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. + Chaque observation conserve les modificateurs propres à l’arme, `R.Max` et le + meilleur partage possible sur 2A.] + + heading(level: 4)[Surface de dégâts attendus] + [Les cellules agrègent la moyenne de toutes les armes. Le seuil indiqué est + la valeur naturelle avant application du modificateur de précision de l’arme.] + heatmap( + ( + rows: analyzed-base-precisions.map(value => [Seuil #value]), + cols: analyzed-dice-pools.map(value => [#value dés]), + values: average-damage-grid, + ), + cell-size: 32pt, + show-values: true, + palette: sensitivity-palette, + theme: chart-theme, + ) + + heading(level: 4)[Rendement marginal d’un dé supplémentaire] + [Chaque cellule mesure `E[dégâts à n dés] − E[dégâts à n−1 dés]`. Les zones + sombres signalent les pools où `R.Max` et la précision ont déjà absorbé + l’essentiel du rendement marginal.] + heatmap( + ( + rows: analyzed-base-precisions.map(value => [Seuil #value]), + cols: marginal-dice-pools.map(value => [→ #value dés]), + values: average-marginal-grid, + ), + cell-size: 32pt, + show-values: true, + palette: sensitivity-palette, + theme: chart-theme, + ) + [Le gain moyen maximal calculé est de + #rounded(strongest-marginal.gain, digits: 2) dégâts en passant à + #strongest-marginal.dice dés au seuil #strongest-marginal.base-precision. + À l’autre extrême, il tombe à #rounded(weakest-marginal.gain, digits: 2) en + passant à #weakest-marginal.dice dés au seuil #weakest-marginal.base-precision.] + + heading(level: 4)[Trajectoires dés × précision] + multi-scatter-plot( + ( + series: (2, 4, 6, 8).map(precision => ( + name: "Seuil " + str(precision), + points: analyzed-dice-pools.map(dice => ( + dice, average-swept-damage(precision, dice), + )), + )), + ), + width: 100%, + height: 225pt, + point-size: 5pt, + x-label: [Dés engagés], + y-label: [Dégâts moyens attendus], + theme: chart-theme, + ) + + heading(level: 4)[Corrélations globales] + [La matrice mesure les corrélations de Pearson sur le cube complet. Elle décrit + des associations, pas une causalité; les effets non linéaires de `R.Max` sont + détaillés par les cartes et les ruptures.] + correlation-matrix( + ( + labels: correlation-fields.map(field => field.label), + values: weapon-correlation-values, + ), + cell-size: 36pt, + show-values: true, + palette: correlation-palette, + theme: chart-theme, + ) + + let correlation-rows = damage-correlations.map(result => ( + result.label, + rounded(result.value, digits: 3), + if result.value >= 0 { [Positive] } else { [Négative] }, + )) + tables.set-table-style( + table( + columns: (1.4fr, 0.8fr, 0.9fr), + align: (left, right, left), + table.header([Variable], [Corr. avec E[dég.]], [Sens]), + ..correlation-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) + let strongest = damage-correlations.first() + [La relation linéaire la plus forte avec les dégâts attendus est calculée pour + *#strongest.label* ($r = #rounded(strongest.value, digits: 3)$). Le classement + ci-dessus est entièrement recalculé avec le cube.] + + 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.] + let knee-rows = knee-summary.map(row => ( + str(row.precision), + rounded(row.median-dice, digits: 1), + rounded(row.average-damage, digits: 2), + rounded(row.average-end-damage, digits: 2), + rounded(row.retained * 100, digits: 1) + [%], + )) + tables.set-table-style( + table( + columns: (0.8fr, 1fr, 1.15fr, 1.15fr, 1fr), + align: (right,) * 5, + table.header( + [Seuil], [Rupture médiane], [Dég. à rupture], [Dég. à 14 dés], + [Part atteinte], + ), + ..knee-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) +} diff --git a/setup/analysis/weapon_breakpoints.typ b/setup/analysis/weapon_breakpoints.typ new file mode 100644 index 0000000..f07b365 --- /dev/null +++ b/setup/analysis/weapon_breakpoints.typ @@ -0,0 +1,147 @@ +// 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": * + +#let analyzed-base-precisions = range(2, 9) +#let analyzed-dice-pools = range(3, 15) + +#let mean(values) = values.sum() / values.len() + +#let numeric-median(values) = { + let ordered = values.sorted() + let middle = calc.floor(ordered.len() / 2) + if calc.rem(ordered.len(), 2) == 0 { + (ordered.at(middle - 1) + ordered.at(middle)) / 2 + } else { + ordered.at(middle) + } +} + +#let analyzed-probability(base-precision, weapon-precision) = ( + calc.max(0, calc.min(10, base-precision + weapon-precision)) / 10 +) + +#let swept-damage(item, base-precision, dice) = commitment-analysis( + item.base-damage, + item.p-damage, + item.rmax, + item.actions, + dice, + analyzed-probability(base-precision, item.precision), +).best + +#let weapon-sensitivity-cube = analyzed-base-precisions.fold((), (rows, precision) => ( + rows + analyzed-dice-pools.fold((), (pool-rows, dice) => ( + pool-rows + all-weapon-metrics.map(item => ( + weapon: item.name, + shape: item.shape, + nature: item.nature, + base-precision: precision, + effective-precision: calc.max(0, calc.min(10, precision + item.precision)), + dice: dice, + base-damage: item.base-damage, + p-damage: item.p-damage, + rmax: item.rmax, + actions: item.actions, + armor-break: item.armor-break, + expected-damage: swept-damage(item, precision, dice), + )) + )) +)) + +#let average-swept-damage(base-precision, dice) = mean( + all-weapon-metrics.map(item => swept-damage(item, base-precision, dice)), +) + +#let average-damage-grid = analyzed-base-precisions.map(precision => ( + analyzed-dice-pools.map(dice => average-swept-damage(precision, dice)) +)) + +#let marginal-dice-pools = analyzed-dice-pools.slice(1) +#let average-marginal-grid = analyzed-base-precisions.map(precision => ( + marginal-dice-pools.map(dice => ( + average-swept-damage(precision, dice) + - average-swept-damage(precision, dice - 1) + )) +)) + +#let marginal-observations = analyzed-base-precisions.fold((), (rows, precision) => ( + rows + marginal-dice-pools.map(dice => ( + base-precision: precision, + dice: dice, + gain: average-swept-damage(precision, dice) + - average-swept-damage(precision, dice - 1), + )) +)) +#let strongest-marginal = marginal-observations.sorted(key: point => -point.gain).first() +#let weakest-marginal = marginal-observations.sorted(key: point => point.gain).first() + +#let pearson(records, x-key, y-key) = { + let xs = records.map(row => row.at(x-key)) + let ys = records.map(row => row.at(y-key)) + let x-mean = mean(xs) + let y-mean = mean(ys) + let numerator = xs.zip(ys).map(pair => ( + (pair.at(0) - x-mean) * (pair.at(1) - y-mean) + )).sum() + let x-square = xs.map(value => calc.pow(value - x-mean, 2)).sum() + let y-square = ys.map(value => calc.pow(value - y-mean, 2)).sum() + if x-square == 0 or y-square == 0 { 0 } else { + numerator / calc.sqrt(x-square * y-square) + } +} + +#let correlation-fields = ( + (key: "base-precision", label: "Seuil"), + (key: "dice", label: "Dés"), + (key: "base-damage", label: "Dég."), + (key: "p-damage", label: "+/réuss."), + (key: "rmax", label: "R.Max"), + (key: "actions", label: "Actions"), + (key: "armor-break", label: "Brise"), + (key: "expected-damage", label: "E[dég.]"), +) + +#let weapon-correlation-values = correlation-fields.map(left => ( + correlation-fields.map(right => pearson( + weapon-sensitivity-cube, left.key, right.key, + )) +)) + +#let damage-correlations = correlation-fields.filter(field => ( + field.key != "expected-damage" +)).map(field => ( + label: field.label, + value: pearson(weapon-sensitivity-cube, field.key, "expected-damage"), +)).sorted(key: result => -calc.abs(result.value)) + +// Discrete knee: greatest normalized height above the line joining the first +// and last points. This detects where a concave damage curve bends most. +#let weapon-knee(item, base-precision) = { + let damages = analyzed-dice-pools.map(dice => swept-damage(item, base-precision, dice)) + let first-damage = damages.first() + let damage-span = damages.last() - first-damage + let dice-span = analyzed-dice-pools.last() - analyzed-dice-pools.first() + let candidates = analyzed-dice-pools.enumerate().map(pair => { + let index = pair.at(0) + let dice = pair.at(1) + let x = (dice - analyzed-dice-pools.first()) / dice-span + let y = if damage-span == 0 { 0 } else { + (damages.at(index) - first-damage) / damage-span + } + (dice: dice, damage: damages.at(index), curvature: y - x) + }) + candidates.sorted(key: point => -point.curvature).first() +} + +#let knee-summary = analyzed-base-precisions.map(precision => { + let knees = all-weapon-metrics.map(item => weapon-knee(item, precision)) + let end-damages = all-weapon-metrics.map(item => swept-damage(item, precision, 14)) + ( + precision: precision, + median-dice: numeric-median(knees.map(knee => knee.dice)), + average-damage: mean(knees.map(knee => knee.damage)), + average-end-damage: mean(end-damages), + retained: mean(knees.map(knee => knee.damage)) / mean(end-damages), + ) +}) diff --git a/setup/analysis/weapon_metrics.typ b/setup/analysis/weapon_metrics.typ new file mode 100644 index 0000000..83eda10 --- /dev/null +++ b/setup/analysis/weapon_metrics.typ @@ -0,0 +1,144 @@ +// 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 + +#let weapon-nature-labels = ( + Light: "Léger", + Medium: "Moyen", + Heavy: "Lourd", + SuperHeavy: "Super-lourd", +) + +// The first success deals base damage. Each later success adds `p-damage`. +#let damage-at-successes(base-damage, p-damage, successes) = if successes <= 0 { + 0 +} else { + base-damage + (successes - 1) * p-damage +} + +// Guard the core rule against regressions as the metric model grows. +#assert.eq(damage-at-successes(8, 2, 5), 16) + +// 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 success-probability(precision) = ( + calc.max(0, calc.min(10, natural-precision + precision)) / 10 +) + +#let binomial-probability(dice, successes, probability) = ( + calc.binom(dice, successes) + * (if successes == 0 { 1 } else { calc.pow(probability, successes) }) + * (if dice == successes { 1 } else { + calc.pow(1 - probability, dice - successes) + }) +) + +// Expected damage of one attack. Successes beyond R.Max still occur, but do +// not increase damage and are therefore folded into the capped damage value. +#let expected-attack-damage(base-damage, p-damage, rmax, dice, probability) = { + range(0, dice + 1).map(successes => ( + binomial-probability(dice, successes, probability) + * damage-at-successes(base-damage, p-damage, calc.min(successes, rmax)) + )).sum() +} + +#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-analysis(base-damage, p-damage, rmax, actions, dice, probability) = { + let single = expected-attack-damage( + base-damage, p-damage, rmax, dice, probability, + ) + let candidates = if actions == 1 and dice >= 2 { + range(1, calc.floor(dice / 2) + 1).map(first => ( + first: first, + second: dice - first, + damage: expected-attack-damage( + base-damage, p-damage, rmax, first, probability, + ) + expected-attack-damage( + base-damage, p-damage, rmax, dice - first, probability, + ), + )) + } else { + () + } + let best-split = if candidates.len() == 0 { none } else { + candidates.sorted(key: candidate => -candidate.damage).first() + } + let use-split = best-split != none and best-split.damage > single + ( + dice: dice, + single: single, + split: best-split, + best: if use-split { best-split.damage } else { single }, + strategy: if use-split { + str(best-split.first) + "+" + str(best-split.second) + } else { + str(dice) + }, + attacks: if use-split { 2 } else { 1 }, + ) +} + +#let analyze-weapon(item) = { + let actions = calc.max(1, item.action_cost) + let capped-damage = damage-at-successes(item.damage, item.p_damage, item.rmax) + let probability = success-probability(item.precision) + let commitments = (:) + for commitment in commitment-pools { + commitments.insert(commitment.key, commitment-analysis( + item.damage, + item.p_damage, + item.rmax, + actions, + commitment.dice, + probability, + )) + } + ( + name: item.shape_name + " · " + weapon-nature-labels.at(item.nature_category), + shape: item.shape_name, + nature: weapon-nature-labels.at(item.nature_category), + nature-key: item.nature_category, + base-damage: item.damage, + p-damage: item.p_damage, + precision: item.precision, + effective-precision: natural-precision + item.precision, + success-probability: probability, + rmax: item.rmax, + armor-break: item.armor_break, + actions: actions, + max-damage: capped-damage, + damage-per-action: capped-damage / actions, + commitments: commitments, + damage-curve: range(1, item.rmax + 1).map(successes => ( + successes: successes, + damage: damage-at-successes(item.damage, item.p_damage, successes), + )), + source: item, + ) +} + +#let all-weapon-metrics = equipments.filter(item => ( + item.apply_category == "Weapons" +)).map(analyze-weapon) + +#let weapon-shapes = all-weapon-metrics.map(item => item.shape).dedup() +#let weapon-natures = ("Light", "Medium", "Heavy", "SuperHeavy") + +#let weapon-average(key, weapons: all-weapon-metrics) = { + if weapons.len() == 0 { none } else { + weapons.map(item => item.at(key)).sum() / weapons.len() + } +} + +#let ranked-weapons(key, weapons: all-weapon-metrics) = weapons.sorted( + key: item => -item.at(key), +) diff --git a/setup/analysis/weapon_report.typ b/setup/analysis/weapon_report.typ new file mode 100644 index 0000000..5bb9483 --- /dev/null +++ b/setup/analysis/weapon_report.typ @@ -0,0 +1,211 @@ +// 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 "report_style.typ": chart-theme, metric-card, rounded +#import "../theme/tables.typ" as tables + +#let weapon-series(key) = weapon-natures.map(nature => ( + name: weapon-nature-labels.at(nature), + values: weapon-shapes.map(shape => all-weapon-metrics.find(item => ( + item.shape == shape and item.nature-key == nature + )).at(key)), +)) + +#let weapon-value-matrix(key, digits: 1) = { + let rows = () + for shape in weapon-shapes { + rows.push(shape) + for nature in weapon-natures { + rows.push(rounded(all-weapon-metrics.find(item => ( + item.shape == shape and item.nature-key == nature + )).at(key), digits: digits)) + } + } + tables.set-table-style( + table( + columns: (1.3fr,) + (0.8fr,) * weapon-natures.len(), + align: (left,) + (right,) * weapon-natures.len(), + table.header([Forme], ..weapon-natures.map(nature => [#weapon-nature-labels.at(nature)])), + ..rows, + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) +} + +#let expected-damage-cell(item, commitment-key) = { + let result = item.commitments.at(commitment-key) + [#rounded(result.best, digits: 2) #text(size: 6pt, fill: luma(90))[#result.strategy dés]] +} + +#let commitment-stacked-groups = weapon-natures.map(nature => { + let values = weapon-shapes.map(shape => all-weapon-metrics.find(item => ( + item.shape == shape and item.nature-key == nature + ))) + ( + 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 => ( + item.commitments.mid.best - item.commitments.low.best + ))), + (name: "Gain 8→12", values: values.map(item => ( + item.commitments.full.best - item.commitments.mid.best + ))), + ), + ) +}) + +#let weapon-analysis-report() = { + pagebreak() + heading(level: 2)[Artisanat — équilibre des armes] + + let max-ranked = ranked-weapons("max-damage") + let action-ranked = ranked-weapons("damage-per-action") + let break-ranked = ranked-weapons("armor-break") + + grid( + columns: (1fr,) * 4, + column-gutter: 8pt, + metric-card("Armes générées", all-weapon-metrics.len()), + metric-card("Dégâts max. moyens", rounded(weapon-average("max-damage"), digits: 1)), + metric-card("Dégâts/action moyens", rounded(weapon-average("damage-per-action"), digits: 1)), + metric-card("Brise-armure moyen", rounded(weapon-average("armor-break"), digits: 1)), + ) + + [Les dégâts à $n$ réussites valent `Dégâts + (n − 1) × Dégâts/réussite`. + Les dégâts maximaux utilisent `R.Max`; les dégâts par action divisent ce + 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 + 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 + option est affichée. Une arme à 2A conserve nécessairement le pool entier.] + + let expectation-rows = all-weapon-metrics.map(item => ( + item.name, + str(item.effective-precision), + str(calc.round(item.success-probability * 100)) + "%", + expected-damage-cell(item, "low"), + expected-damage-cell(item, "mid"), + expected-damage-cell(item, "full"), + )) + tables.set-table-style( + table( + 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], + ), + ..expectation-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.2pt, + ) + + heading(level: 3)[Dégâts maximaux par forme et poids] + grouped-bar-chart( + (labels: weapon-shapes, series: weapon-series("max-damage")), + width: 100%, height: 205pt, y-label: [Dégâts à R.Max], theme: chart-theme, + ) + weapon-value-matrix("max-damage", digits: 0) + + heading(level: 3)[Dégâts maximaux par action] + grouped-bar-chart( + (labels: weapon-shapes, series: weapon-series("damage-per-action")), + width: 100%, height: 205pt, y-label: [Dégâts / action], theme: chart-theme, + ) + weapon-value-matrix("damage-per-action", digits: 1) + + heading(level: 3)[Dégâts attendus à 5, 8 et 12 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.] + grouped-stacked-bar-chart( + (labels: weapon-shapes, groups: commitment-stacked-groups), + width: 100%, + height: 230pt, + y-label: [Dégâts attendus sur 2A], + theme: chart-theme, + ) + + heading(level: 3)[Classements offensifs] + grid( + columns: (1fr, 1fr, 1fr), + column-gutter: 10pt, + horizontal-bar-chart( + (labels: max-ranked.slice(0, 8).map(item => item.name), values: max-ranked.slice(0, 8).map(item => item.max-damage)), + width: 100%, height: 210pt, title: [Dégâts maximaux], show-values: true, theme: chart-theme, + ), + horizontal-bar-chart( + (labels: action-ranked.slice(0, 8).map(item => item.name), values: action-ranked.slice(0, 8).map(item => item.damage-per-action)), + width: 100%, height: 210pt, title: [Dégâts par action], show-values: true, theme: chart-theme, + ), + horizontal-bar-chart( + (labels: break-ranked.slice(0, 8).map(item => item.name), values: break-ranked.slice(0, 8).map(item => item.armor-break)), + width: 100%, height: 210pt, title: [Brise-armure], show-values: true, theme: chart-theme, + ), + ) + + heading(level: 3)[Tableau d’équilibrage] + let rows = all-weapon-metrics.map(item => ( + item.name, + str(item.base-damage), + if item.p-damage >= 0 { "+" + str(item.p-damage) } else { str(item.p-damage) }, + str(item.rmax), + str(item.max-damage), + str(item.armor-break), + str(item.actions) + "A", + rounded(item.damage-per-action, digits: 1), + rounded(item.commitments.low.best, digits: 2), + rounded(item.commitments.mid.best, digits: 2), + rounded(item.commitments.full.best, digits: 2), + )) + tables.set-table-style( + table( + columns: ( + 1.55fr, 0.46fr, 0.42fr, 0.48fr, 0.62fr, 0.52fr, + 0.48fr, 0.62fr, 0.62fr, 0.62fr, 0.62fr, + ), + 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], + ), + ..rows.flatten(), + ), + table-theme: "steingrund", + text-size: 6.5pt, + ) + + heading(level: 3)[Courbes de dégâts par réussite] + let curve-rows = () + let max-successes = all-weapon-metrics.map(item => item.rmax).sorted().last() + for item in all-weapon-metrics { + curve-rows.push(item.name) + for successes in range(1, max-successes + 1) { + if successes <= item.rmax { + curve-rows.push(str(damage-at-successes(item.base-damage, item.p-damage, successes))) + } else { + curve-rows.push(text(size: 6pt, smallcaps[(capped)])) + } + } + } + tables.set-table-style( + table( + columns: (1.65fr,) + (0.65fr,) * max-successes, + align: (left,) + (right,) * max-successes, + table.header([Arme], ..range(1, max-successes + 1).map(successes => [#successes réuss.])), + ..curve-rows, + ), + table-theme: "steingrund", + text-size: 7pt, + ) + + weapon-breakpoint-report() +} -- 2.45.1 From 6d9b0b5a1742ab16612ff3d0ea716372e58f3684 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Fri, 21 Aug 2026 01:08:30 +0200 Subject: [PATCH 2/5] Finished icons & more data analisys --- data/src/glossaries/elements.yml | 6 +- images/icons/blood.png | Bin 2658 -> 0 bytes images/icons/blood.svg | 2 +- images/icons/existence.png | Bin 30733 -> 0 bytes images/icons/{ex.svg => existence.svg} | 2 +- images/icons/integrity.png | Bin 54748 -> 0 bytes images/icons/integrity.svg | 2 +- images/icons/pierce.png | Bin 781 -> 0 bytes images/icons/pierce.svg | 15 ++- images/icons/protection.png | Bin 57302 -> 0 bytes images/icons/protection.svg | 2 +- images/icons/slash.png | Bin 4190 -> 0 bytes setup/analysis/weapon_breakpoint_report.typ | 115 ++++++++++++++++++++ setup/analysis/weapon_breakpoints.typ | 66 +++++++++++ setup/theme/symbols.typ | 6 +- 15 files changed, 203 insertions(+), 13 deletions(-) delete mode 100644 images/icons/blood.png delete mode 100644 images/icons/existence.png rename images/icons/{ex.svg => existence.svg} (98%) delete mode 100644 images/icons/integrity.png delete mode 100644 images/icons/pierce.png delete mode 100644 images/icons/protection.png delete mode 100644 images/icons/slash.png diff --git a/data/src/glossaries/elements.yml b/data/src/glossaries/elements.yml index 1e118dc..c171d8e 100644 --- a/data/src/glossaries/elements.yml +++ b/data/src/glossaries/elements.yml @@ -4,7 +4,7 @@ custom: icon: true short: - typst: 'box(height: 0.65em, baseline: 0.5pt, inset: 0pt, image("/images/icons/slash.png"))' + typst: 'box(height: 0.65em, baseline: 0.5pt, inset: 0pt, image("/images/icons/slash.svg"))' long: Tranchant description: "Type de dégât physique décrivant les attaques portées avec des objets acérés visant à couper leur cible." group: Dégâts physiques @@ -13,7 +13,7 @@ custom: icon: true short: - typst: 'box(height: 0.7em, baseline: 0.7pt, inset: 0pt, image("/images/icons/pierce.png"))' + typst: 'box(height: 0.7em, baseline: 0.7pt, inset: 0pt, image("/images/icons/pierce.svg"))' long: Perçant description: "Type de dégât physique décrivant les attaques portées avec des objets pointus cherchant à pénétrer les défences de leur cible." group: Dégâts physiques @@ -130,7 +130,7 @@ custom: icon: true short: - typst: 'box(height: 0.75em, baseline: 1.1pt, inset: 0pt, image("/images/icons/existence.png"))' + typst: 'box(height: 0.75em, baseline: 1.1pt, inset: 0pt, image("/images/icons/existence.svg"))' long: Existence description: > Dégâts absolus, ces dégâts ignorent toute forme de résistance, ces attaques ne peuvent être parées ou esquivées diff --git a/images/icons/blood.png b/images/icons/blood.png deleted file mode 100644 index 401724ac90548320c33e0b15b47a60104ca9a83f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2658 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 diff --git a/images/icons/blood.svg b/images/icons/blood.svg index d72e491..07adf82 100644 --- a/images/icons/blood.svg +++ b/images/icons/blood.svg @@ -6,7 +6,7 @@ preserveAspectRatio="xMidYMid meet"> +fill="#ea1223" stroke="none"> +fill="#dcab35" stroke="none"> +fill="#1d592e" stroke="none"> - - \ No newline at end of file + + + + + + + + + + + + diff --git a/images/icons/protection.png b/images/icons/protection.png deleted file mode 100644 index ce4638b47596dcefababd10c228f0d0f1b642190..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 57302 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

)?GX$uFUEbV7huuU8b?&S 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 mE?l^9;lhOr7cN|!7W{u89A7mR?BgK-0000 +fill="#1f5394" stroke="none"> [ + #shape-short.at(item.shape) · #nature-short.at(item.nature-key) +]) +#let swing-columns = comparison-dice-pools.fold((), (labels, dice) => ( + labels + ([−1 · #dice d], [+1 · #dice d]) +)) + +#let sensitivity-heatmap(title, values) = block( + breakable: false, +)[ + #heading(level: 5)[#title] + #align(center, heatmap( + (rows: weapon-row-labels, cols: swing-columns, values: values), + cell-size: 20pt, + show-values: true, + show-legend: true, + palette: correlation-palette, + theme: chart-theme, + )) +] + #let weapon-breakpoint-report() = { pagebreak() heading(level: 3)[Sensibilité, corrélations et points de rupture] @@ -26,6 +52,95 @@ Chaque observation conserve les modificateurs propres à l’arme, `R.Max` et le meilleur partage possible sur 2A.] + heading(level: 4)[Impact d’un point d’équilibrage] + [Ces cartes répondent directement à « que coûte ou rapporte un point ? ». Les + valeurs sont les variations relatives des dégâts attendus par rapport à + l’arme actuelle. Chaque variante recalcule aussi le meilleur partage du pool; + un saut peut donc révéler un changement de stratégie, pas seulement un effet + arithmétique local.] + + let sensitivity-rows = point-sensitivity-summary.map(row => ( + str(row.dice), + rounded(row.precision-loss, digits: 1) + [%], + rounded(row.precision-gain, digits: 1) + [%], + rounded(row.p-damage-loss, digits: 1) + [%], + rounded(row.p-damage-gain, digits: 1) + [%], + )) + tables.set-table-style( + table( + columns: (0.65fr,) + (1fr,) * 4, + align: (right,) * 5, + table.header( + [Pool], [Préc. −1], [Préc. +1], [Dég./réuss. −1], [Dég./réuss. +1], + ), + ..sensitivity-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) + + let paired-impact(row, loss-key, gain-key) = ( + (calc.abs(row.at(loss-key)) + calc.abs(row.at(gain-key))) / 2 + ) + let precision-impacts = point-sensitivity-summary.map(row => ( + paired-impact(row, "precision-loss", "precision-gain") + )) + let p-damage-impacts = point-sensitivity-summary.map(row => ( + paired-impact(row, "p-damage-loss", "p-damage-gain") + )) + let trend-word(values) = if values.last() < values.first() { + "diminue" + } else if values.last() > values.first() { + "augmente" + } else { + "reste stable" + } + let relative-evolution(values) = if values.first() == 0 { 0 } else { + (values.last() / values.first() - 1) * 100 + } + + [*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(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)% à + #rounded(p-damage-impacts.last(), digits: 1)% + (#rounded(relative-evolution(p-damage-impacts), digits: 1)%). Cette phrase, + ses valeurs et ses verbes sont reconstruits à chaque compilation.] + + sensitivity-heatmap( + [Précision ±1 — variation des dégâts (%)], + precision-swing-grid, + ) + sensitivity-heatmap( + [Dégâts par réussite ±1 — variation des dégâts (%)], + p-damage-swing-grid, + ) + + pagebreak() + heading(level: 4)[Seuil × arme à engagement fixe] + [Ces cartes conservent chaque arme individuellement et font varier le seuil de + base. Elles permettent de voir si une arme reste stable entre les régimes de + faible engagement, d’engagement médian et de saturation.] + for dice in comparison-dice-pools { + block(breakable: false)[ + #heading(level: 5)[Espérance à #dice dés] + #align(center, heatmap( + ( + rows: weapon-row-labels, + cols: analyzed-base-precisions.map(value => [Seuil #value]), + values: weapon-threshold-grid(dice), + ), + cell-size: 17pt, + show-values: true, + palette: sensitivity-palette, + theme: chart-theme, + )) + ] + } + heading(level: 4)[Surface de dégâts attendus] [Les cellules agrègent la moyenne de toutes les armes. Le seuil indiqué est la valeur naturelle avant application du modificateur de précision de l’arme.] diff --git a/setup/analysis/weapon_breakpoints.typ b/setup/analysis/weapon_breakpoints.typ index f07b365..46aaf0d 100644 --- a/setup/analysis/weapon_breakpoints.typ +++ b/setup/analysis/weapon_breakpoints.typ @@ -4,6 +4,7 @@ #let analyzed-base-precisions = range(2, 9) #let analyzed-dice-pools = range(3, 15) +#let comparison-dice-pools = (5, 8, 14) #let mean(values) = values.sum() / values.len() @@ -30,6 +31,71 @@ analyzed-probability(base-precision, item.precision), ).best +#let perturbed-damage( + item, + dice, + precision-delta: 0, + p-damage-delta: 0, + base-precision: natural-precision, +) = commitment-analysis( + item.base-damage, + item.p-damage + p-damage-delta, + item.rmax, + item.actions, + dice, + analyzed-probability(base-precision, item.precision + precision-delta), +).best + +#let relative-change(item, dice, precision-delta: 0, p-damage-delta: 0) = { + let baseline = perturbed-damage(item, dice) + let changed = perturbed-damage( + item, + dice, + precision-delta: precision-delta, + p-damage-delta: p-damage-delta, + ) + if baseline == 0 { 0 } else { (changed / baseline - 1) * 100 } +} + +#let weapon-threshold-grid(dice) = all-weapon-metrics.map(item => ( + analyzed-base-precisions.map(precision => swept-damage(item, precision, dice)) +)) + +#let weapon-sensitivity-grid(precision-delta: 0, p-damage-delta: 0) = ( + all-weapon-metrics.map(item => comparison-dice-pools.map(dice => relative-change( + item, + dice, + precision-delta: precision-delta, + p-damage-delta: p-damage-delta, + ))) +) + +#let precision-loss-grid = weapon-sensitivity-grid(precision-delta: -1) +#let precision-gain-grid = weapon-sensitivity-grid(precision-delta: 1) +#let p-damage-loss-grid = weapon-sensitivity-grid(p-damage-delta: -1) +#let p-damage-gain-grid = weapon-sensitivity-grid(p-damage-delta: 1) +#let precision-swing-grid = precision-loss-grid.zip(precision-gain-grid).map(pair => ( + range(0, comparison-dice-pools.len()).fold((), (values, index) => ( + values + (pair.at(0).at(index), pair.at(1).at(index)) + )) +)) +#let p-damage-swing-grid = p-damage-loss-grid.zip(p-damage-gain-grid).map(pair => ( + range(0, comparison-dice-pools.len()).fold((), (values, index) => ( + values + (pair.at(0).at(index), pair.at(1).at(index)) + )) +)) +#let point-sensitivity-summary = comparison-dice-pools.enumerate().map(pair => { + let index = pair.at(0) + let dice = pair.at(1) + ( + dice: dice, + precision-loss: mean(precision-loss-grid.map(row => row.at(index))), + precision-gain: mean(precision-gain-grid.map(row => row.at(index))), + p-damage-loss: mean(p-damage-loss-grid.map(row => row.at(index))), + p-damage-gain: mean(p-damage-gain-grid.map(row => row.at(index))), + ) +}) + #let weapon-sensitivity-cube = analyzed-base-precisions.fold((), (rows, precision) => ( rows + analyzed-dice-pools.fold((), (pool-rows, dice) => ( pool-rows + all-weapon-metrics.map(item => ( diff --git a/setup/theme/symbols.typ b/setup/theme/symbols.typ index 698357c..5aa5f0e 100644 --- a/setup/theme/symbols.typ +++ b/setup/theme/symbols.typ @@ -20,7 +20,7 @@ height: 0.65em, baseline: 0.5pt, inset: 0pt, - image("/images/icons/blood.png"), + image("/images/icons/blood.svg"), ) #let jauge-box = box( height: 0.65em, @@ -80,13 +80,13 @@ height: 0.65em, baseline: 0.5pt, inset: 0pt, - image("/images/icons/protection.png"), + image("/images/icons/protection.svg"), ) #let integrity-box = box( height: 0.65em, baseline: 0.5pt, inset: 0pt, - image("/images/icons/integrity.png"), + image("/images/icons/integrity.svg"), ) #let cost-box = box( height: 0.65em, -- 2.45.1 From 8f88fdb1219185b5b2c3fa9e6ad38edfa5224386 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Fri, 21 Aug 2026 01:21:26 +0200 Subject: [PATCH 3/5] Breakpoints & ab --- setup/analysis/weapon_armor_breakpoints.typ | 116 ++++++++++++++++ setup/analysis/weapon_armor_report.typ | 139 ++++++++++++++++++++ setup/analysis/weapon_report.typ | 2 + 3 files changed, 257 insertions(+) create mode 100644 setup/analysis/weapon_armor_breakpoints.typ create mode 100644 setup/analysis/weapon_armor_report.typ diff --git a/setup/analysis/weapon_armor_breakpoints.typ b/setup/analysis/weapon_armor_breakpoints.typ new file mode 100644 index 0000000..be29dd9 --- /dev/null +++ b/setup/analysis/weapon_armor_breakpoints.typ @@ -0,0 +1,116 @@ +// Exact probabilistic armor-destruction model for generated weapons. +#import "weapon_metrics.typ": * +#import "weapon_breakpoints.typ": comparison-dice-pools, mean, numeric-median + +#let analyzed-protections = range(5, 16) + +#let armor-destroyed(damage, protection, armor-break) = ( + calc.min(armor-break, calc.max(0, damage - protection)) +) + +#let expected-attack-armor-destruction(item, dice, protection) = { + let probability = item.success-probability + range(0, dice + 1).map(successes => { + let damage = damage-at-successes( + item.base-damage, + item.p-damage, + calc.min(successes, item.rmax), + ) + ( + binomial-probability(dice, successes, probability) + * armor-destroyed(damage, protection, item.armor-break) + ) + }).sum() +} + +#let armor-commitment-analysis(item, dice, protection) = { + let single = expected-attack-armor-destruction(item, dice, protection) + let candidates = if item.actions == 1 and dice >= 2 { + range(1, calc.floor(dice / 2) + 1).map(first => ( + first: first, + second: dice - first, + destruction: expected-attack-armor-destruction(item, first, protection) + + expected-attack-armor-destruction(item, dice - first, protection), + )) + } else { + () + } + let best-split = if candidates.len() == 0 { none } else { + candidates.sorted(key: candidate => -candidate.destruction).first() + } + let use-split = best-split != none and best-split.destruction > single + ( + destruction: if use-split { best-split.destruction } else { single }, + attacks: if use-split { 2 } else { 1 }, + strategy: if use-split { + str(best-split.first) + "+" + str(best-split.second) + } else { + str(dice) + }, + ) +} + +#let armor-destruction-grid(dice) = all-weapon-metrics.map(item => ( + analyzed-protections.map(protection => ( + armor-commitment-analysis(item, dice, protection).destruction + )) +)) + +#let armor-utilization-grid(dice) = all-weapon-metrics.map(item => ( + analyzed-protections.map(protection => { + let result = armor-commitment-analysis(item, dice, protection) + let capacity = item.armor-break * result.attacks + if capacity == 0 { 0 } else { result.destruction / capacity * 100 } + }) +)) + +#let armor-protection-breakpoint(item, dice) = { + if item.armor-break == 0 { return none } + let values = analyzed-protections.map(protection => ( + armor-commitment-analysis(item, dice, protection).destruction + )) + let drops = range(1, analyzed-protections.len()).map(index => ( + protection: analyzed-protections.at(index), + drop: values.at(index - 1) - values.at(index), + )) + let strongest = drops.sorted(key: point => -point.drop).first() + if strongest.drop <= 0.000001 { none } else { strongest } +} + +#let armor-breakpoint-table = all-weapon-metrics.map(item => ( + weapon: item.name, + points: comparison-dice-pools.map(dice => armor-protection-breakpoint(item, dice)), +)) + +#let armor-summary = comparison-dice-pools.map(dice => { + let at(protection) = mean(all-weapon-metrics.map(item => ( + armor-commitment-analysis(item, dice, protection).destruction + ))) + let utilization = mean(all-weapon-metrics.filter(item => ( + item.armor-break > 0 + )).map(item => { + let result = armor-commitment-analysis(item, dice, 10) + result.destruction / (item.armor-break * result.attacks) * 100 + })) + let valid-breakpoints = all-weapon-metrics.map(item => ( + armor-protection-breakpoint(item, dice) + )).filter(point => point != none) + ( + dice: dice, + protection-5: at(5), + protection-10: at(10), + protection-15: at(15), + utilization-10: utilization, + median-breakpoint: numeric-median(valid-breakpoints.map(point => point.protection)), + ) +}) + +#let nature-armor-series(dice) = weapon-natures.map(nature => ( + name: weapon-nature-labels.at(nature), + points: analyzed-protections.map(protection => ( + protection, + mean(all-weapon-metrics.filter(item => item.nature-key == nature).map(item => ( + armor-commitment-analysis(item, dice, protection).destruction + ))), + )), +)) diff --git a/setup/analysis/weapon_armor_report.typ b/setup/analysis/weapon_armor_report.typ new file mode 100644 index 0000000..9d0e46f --- /dev/null +++ b/setup/analysis/weapon_armor_report.typ @@ -0,0 +1,139 @@ +// Report views for exact armor-destruction expectations and breakpoints. +#import "@preview/primaviz:0.6.0": heatmap, multi-scatter-plot +#import "weapon_armor_breakpoints.typ": * +#import "report_style.typ": chart-theme, rounded +#import "../theme/tables.typ" as tables +#import "../theme/themes.typ": make-theme + +#let report-theme = make-theme(theme-name: "steingrund") +#let armor-palette = ( + report-theme.at("chart-4"), + report-theme.at("chart-3"), + report-theme.at("chart-2"), + report-theme.at("parchment-light"), +) +#let shape-short = ( + "Griffes": "Grif.", "Hast": "Hast", "Épée": "Épée", + "Marteau": "Mart.", "Hache": "Hache", "Arbalète": "Arba.", "Arc": "Arc", +) +#let nature-short = (Light: "L", Medium: "M", Heavy: "Ld", SuperHeavy: "SL") +#let weapon-labels = all-weapon-metrics.map(item => [ + #shape-short.at(item.shape) · #nature-short.at(item.nature-key) +]) + +#let weapon-armor-report() = { + pagebreak() + heading(level: 3)[Franchissement et destruction d’armure] + [Une attaque qui inflige $D$ dégâts contre une protection $P$ détruit + `min(Brise-armure, max(0, D − P))` points d’armure. Les résultats ci-dessous + intègrent toute la distribution binomiale. Les armes à 1A testent tous les + partages légaux sur 2A et retiennent celui qui maximise la destruction; la + protection reste un seuil de référence constant entre les deux attaques.] + + 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) + [%], + rounded(row.at("median-breakpoint"), digits: 1), + )) + tables.set-table-style( + table( + 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], + [Rupture médiane], + ), + ..summary-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) + + let first = armor-summary.first() + 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)%). + La rupture médiane se déplace de P#rounded(first.at("median-breakpoint"), digits: 1) + à P#rounded(last.at("median-breakpoint"), digits: 1).] + + heading(level: 4)[Courbes de résistance par poids] + grid( + columns: (1fr, 1fr, 1fr), + column-gutter: 8pt, + ..comparison-dice-pools.map(dice => multi-scatter-plot( + (series: nature-armor-series(dice)), + width: 100%, + height: 180pt, + title: [#dice dés], + point-size: 4pt, + x-label: [Protection], + y-label: [Armure détruite], + theme: chart-theme, + )), + ) + + heading(level: 4)[Destruction attendue par arme] + for dice in comparison-dice-pools { + block(breakable: false)[ + #heading(level: 5)[#dice dés] + #align(center, heatmap( + ( + rows: weapon-labels, + cols: analyzed-protections.map(value => [P#value]), + values: armor-destruction-grid(dice), + ), + cell-size: 17pt, + show-values: true, + palette: armor-palette, + theme: chart-theme, + )) + ] + } + + heading(level: 4)[Rendement de la capacité de brise-armure] + [Cette carte normalise la destruction attendue par la capacité maximale de + 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 (%) ] + #align(center, heatmap( + ( + rows: weapon-labels, + cols: analyzed-protections.map(value => [P#value]), + values: armor-utilization-grid(8), + ), + cell-size: 17pt, + show-values: true, + palette: armor-palette, + theme: chart-theme, + )) + ] + + heading(level: 4)[Points de rupture par arme] + [La rupture est le passage de protection qui provoque la plus forte perte + marginale de destruction attendue; aucun seuil de pourcentage n’est imposé.] + let breakpoint-rows = armor-breakpoint-table.map(row => ( + row.weapon, + ..row.points.map(point => ( + if point == none { [Inopérant] } else { + [P#point.protection · −#rounded(point.drop, digits: 2)] + }, + )), + )) + tables.set-table-style( + table( + columns: (1.45fr, 1fr, 1fr, 1fr), + align: (left, right, right, right), + table.header([Arme], [5 dés], [8 dés], [14 dés]), + ..breakpoint-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.2pt, + ) +} diff --git a/setup/analysis/weapon_report.typ b/setup/analysis/weapon_report.typ index 5bb9483..9366200 100644 --- a/setup/analysis/weapon_report.typ +++ b/setup/analysis/weapon_report.typ @@ -2,6 +2,7 @@ #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 @@ -208,4 +209,5 @@ ) weapon-breakpoint-report() + weapon-armor-report() } -- 2.45.1 From d3dae935985b66df16c4b7de0c5bd1c3c60c8e6c Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Fri, 21 Aug 2026 01:38:15 +0200 Subject: [PATCH 4/5] Yaml for config --- balance_report.typ | 18 ++++-- data/config/balance_report.yaml | 62 +++++++++++++++++++++ setup/analysis/class_cost_report.typ | 12 ++-- setup/analysis/craft_report.typ | 17 ++++-- setup/analysis/origin_report.typ | 17 +++--- setup/analysis/report_config.typ | 49 ++++++++++++++++ setup/analysis/weapon_armor_breakpoints.typ | 13 +++-- setup/analysis/weapon_armor_report.typ | 21 +++---- setup/analysis/weapon_breakpoint_report.typ | 12 ++-- setup/analysis/weapon_breakpoints.typ | 7 ++- setup/analysis/weapon_metrics.typ | 17 +++--- setup/analysis/weapon_report.typ | 34 ++++++----- setup/build_config.typ | 6 +- 13 files changed, 216 insertions(+), 69 deletions(-) create mode 100644 data/config/balance_report.yaml create mode 100644 setup/analysis/report_config.typ 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 -- 2.45.1 From 692e73920505e00cb4b1bf997be52f9ccd3babf8 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Fri, 21 Aug 2026 01:55:13 +0200 Subject: [PATCH 5/5] Reporting final? --- chapters/creation.typ | 2 +- data/config/balance_report.yaml | 1 + data/src/craft/alchemy_solvants.csv | 14 ++--- data/src/craft/restoration_sides.csv | 4 +- setup/analysis/class_alteration_report.typ | 2 +- setup/analysis/craft_report.typ | 35 ++++++++---- setup/analysis/defense_metrics.typ | 60 +++++++++++++++++++++ setup/analysis/defense_report.typ | 62 ++++++++++++++++++++++ setup/analysis/origin_report.typ | 14 ++--- setup/analysis/weapon_armor_report.typ | 14 +++-- setup/analysis/weapon_report.typ | 43 ++++++++++++++- 11 files changed, 219 insertions(+), 32 deletions(-) create mode 100644 setup/analysis/defense_metrics.typ create mode 100644 setup/analysis/defense_report.typ diff --git a/chapters/creation.typ b/chapters/creation.typ index 53131c9..24adafa 100644 --- a/chapters/creation.typ +++ b/chapters/creation.typ @@ -82,7 +82,7 @@ Bien que rarement utilisés par les chasseurs, ces deux caractéristiques sont e === Choix des armes et des consommables -L'arme de l'école choisie et une armure possible à équiper sont en général fournies lors de la création de personnage. Selon l'expérience et l'ancienneté de ces derniers, leurs armes et armures pourront posséder jusqu'à 10#ddlvl(1) de modifications chacune; et un certain nombre de consommables sauront aussi fournis à hauteur de 6#ddlvl(1) à 15#ddlvl(1) de rareté. +L'arme de l'école choisie et une armure possible à équiper sont en général fournies lors de la création de personnage. Selon l'expérience et l'ancienneté de ces derniers, leurs armes et armures pourront posséder jusqu'à #ddlvl(10) de modifications chacune; et un certain nombre de consommables sauront aussi fournis à hauteur de #ddlvl(6) à #ddlvl(15) de rareté. Ce choix reste entièrement dépendant du scénario et du @maitredejeu, qui peut souhaiter faire commencer la partie après une cuisante défaite ayant détruit tout le matériel des chasseurs ou la veille d'une grande bataille où tous les équipements seraient fournis pour la mission (bien que cela soit excessivement rarement le cas). diff --git a/data/config/balance_report.yaml b/data/config/balance_report.yaml index abe1eea..52de15f 100644 --- a/data/config/balance_report.yaml +++ b/data/config/balance_report.yaml @@ -56,6 +56,7 @@ chapters: - craft.elements - craft.mechanics - craft.weapons.core + - craft.defenses - craft.weapons.sensitivity - craft.weapons.armor - craft.battle_plan diff --git a/data/src/craft/alchemy_solvants.csv b/data/src/craft/alchemy_solvants.csv index e923207..25396b7 100644 --- a/data/src/craft/alchemy_solvants.csv +++ b/data/src/craft/alchemy_solvants.csv @@ -8,11 +8,11 @@ Graisse de Zizfir (Yenuï),2,#ddlvl(3),#ddlvl(1),#ddlvl(0),"Vous pouvez prendre Larmes d'Ulcen Clairvoyant (Célestial),3,#ddlvl(4),"#ddlvl(-2)",#ddlvl(0),Diminuez la difficulté de la recette Sang de Vathaknor (Yenuï),3,#ddlvl(2),#ddlvl(2),#ddlvl(0),Augmente les dégâts élémentaires de votre potion de 4 Lymphe de Dremaë Mantelaube (Célestial),3,#ddlvl(0),#ddlvl(4),#ddlvl(0),Vous pouvez choisir un ingrédient d'un tiers supérieur au vôtre -Venin de Herkan Noir (Djieien),3,#ddlvl(3),6#ddlvl(1),7#ddlvl(1),Augmente les dégâts des éléments de couleur Abyssale de votre potion de 4d6 -Sang d'Yggradren Vertueux (Abyssal),3,#ddlvl(2),5#ddlvl(1),#ddlvl(1),Diminue de moitié les effets [marqués] de la recette -Bile de Clémar irritable (Dragon),4,#ddlvl(3),7#ddlvl(1),#ddlvl(3),Augmente les dégâts des éléments de couleur Céleste de votre potion de 1d6 et son rayon d'action de +2d10 métres -Lymphe d'Arjatayu (Röc),4,#ddlvl(3),6#ddlvl(1),#ddlvl(2),Donne deux points de brise-armure aux dégâts élémentaires de votre potion +Venin de Herkan Noir (Djieien),3,#ddlvl(3),#ddlvl(6),#ddlvl(7),Augmente les dégâts des éléments de couleur Abyssale de votre potion de 4d6 +Sang d'Yggradren Vertueux (Abyssal),3,#ddlvl(2),#ddlvl(5),#ddlvl(1),Diminue de moitié les effets [marqués] de la recette +Bile de Clémar irritable (Dragon),4,#ddlvl(3),#ddlvl(7),#ddlvl(3),Augmente les dégâts des éléments de couleur Céleste de votre potion de 1d6 et son rayon d'action de +2d10 métres +Lymphe d'Arjatayu (Röc),4,#ddlvl(3),#ddlvl(6),#ddlvl(2),Donne deux points de brise-armure aux dégâts élémentaires de votre potion Sang de Karvadon Aveugle (Béhémoth),4,#ddlvl(2),#ddlvl(2),#ddlvl(1),Vous pouvez prendre jusqu'à trois ingrédients alchémiques pour votre potion -Huile de Pyraxen des profondeurs (Léviathen),4,#ddlvl(3),7#ddlvl(1),#ddlvl(2),Supprime les effets [marqués] de la recette -Sépia d'Hodrevyr Astucieux (Kraken),5,9#ddlvl(1),5#ddlvl(1),#ddlvl(3),Les dégâts subis par les marques de @al_poison:pl sont augmentés de un (ne cumule pas) (#ddlvl(3)) -Sang de Skavaranth Scorique (Dragon),5,#ddlvl(3),6#ddlvl(1),#ddlvl(4),Augmente les dégâts de @el_magma de la potion 5d10 +Huile de Pyraxen des profondeurs (Léviathen),4,#ddlvl(3),#ddlvl(7),#ddlvl(2),Supprime les effets [marqués] de la recette +Sépia d'Hodrevyr Astucieux (Kraken),5,#ddlvl(9),#ddlvl(5),#ddlvl(3),Les dégâts subis par les marques de @al_poison:pl sont augmentés de un (ne cumule pas) (#ddlvl(3)) +Sang de Skavaranth Scorique (Dragon),5,#ddlvl(3),#ddlvl(6),#ddlvl(4),Augmente les dégâts de @el_magma de la potion 5d10 diff --git a/data/src/craft/restoration_sides.csv b/data/src/craft/restoration_sides.csv index 6cdc4b5..a257ee0 100644 --- a/data/src/craft/restoration_sides.csv +++ b/data/src/craft/restoration_sides.csv @@ -2,9 +2,9 @@ Accompagnement,@ar_tier,@ar_cst,@ar_lvl,@ar_tox,@rl_satiete,Effet Perkol (Courges),0,#ddlvl(0),#ddlvl(1),#ddlvl(-3),#ddlvl(2),Diminue la toxicité de la recette Biadok (Navets),0,#ddlvl(0),#ddlvl(1),#ddlvl(0),#ddlvl(1),Gagne deux points de \jtox maximum temporaire Bluk'ta (Oigonos),1,#ddlvl(0),#ddlvl(-4),#ddlvl(0),#ddlvl(1),Diminue la difficulté de la recette -Antaris (Riz),2,#ddlvl(1),#ddlvl(2),ddlvl(-4),#ddlvl(3),Diminue la toxicité de la recette +Antaris (Riz),2,#ddlvl(1),#ddlvl(2),#ddlvl(-4),#ddlvl(3),Diminue la toxicité de la recette Vegilous (Tomates),2,#ddlvl(1),#ddlvl(4),#ddlvl(0),#ddlvl(1),Diminue de un point les effets [marqués] de la recette -Tiblin (Potirons),3,#ddlvl(1),\ddmod-51,#ddlvl(0),#ddlvl(2),Diminue la difficulté de la recette +Tiblin (Potirons),3,#ddlvl(1),#ddlvl(-5),#ddlvl(0),#ddlvl(2),Diminue la difficulté de la recette Ardanta (Racine),3,#ddlvl(1),#ddlvl(3),#ddlvl(0),#ddlvl(3),Gagne cinq points de \jtox maximum temporaire Taltos (Patates),3,#ddlvl(1),#ddlvl(4),#ddlvl(2),#ddlvl(1),Augmente une valeur de résistance des effets de la recette (#ddlvl(2)) ou #resist(1) Cerfa (Carottes),3,#ddlvl(2),#ddlvl(5),#ddlvl(0),#ddlvl(1),Diminue de moitié les effets [marqués] de la recette diff --git a/setup/analysis/class_alteration_report.typ b/setup/analysis/class_alteration_report.typ index d578007..515e1f9 100644 --- a/setup/analysis/class_alteration_report.typ +++ b/setup/analysis/class_alteration_report.typ @@ -9,7 +9,7 @@ #let school-alteration-report() = { pagebreak() - heading(level: 2)[Classes — altérations] + heading(level: 2)[Classes — Altérations] let technique-keys = (:) for item in all-school-alterations { diff --git a/setup/analysis/craft_report.typ b/setup/analysis/craft_report.typ index 897f2df..8ab668e 100644 --- a/setup/analysis/craft_report.typ +++ b/setup/analysis/craft_report.typ @@ -7,6 +7,8 @@ #import "weapon_report.typ": weapon-analysis-report #import "weapon_breakpoint_report.typ": weapon-breakpoint-report #import "weapon_armor_report.typ": weapon-armor-report +#import "defense_report.typ": defense-report +#import "defense_metrics.typ": global-protection-efficiency-leader #import "report_config.typ": chapter-enabled #let insight-card(label, value, note) = block( @@ -38,7 +40,7 @@ } #let craft-summary() = { - heading(level: 2)[Artisanat — couverture élémentaire] + heading(level: 2)[Artisanat — Couverture élémentaire] grid(columns: (1fr,) * 4, column-gutter: 8pt, metric-card("Sources", craft-sources.len()), metric-card("Entrées", craft-entry-count()), metric-card("Mentions élémentaires", all-craft-mentions.len()), metric-card("Éléments distincts", element-counts().len())) @@ -55,7 +57,7 @@ #let element-coverage() = { pagebreak(weak: true) - heading(level: 2)[Artisanat — éléments représentés] + heading(level: 2)[Artisanat — Éléments représentés] let damage = ranked-elements("Dégâts") let resistance = ranked-elements("Résistance") grid(columns: (1fr, 1fr), column-gutter: 12pt, @@ -74,7 +76,7 @@ #let mechanic-analysis() = { pagebreak(weak: true) - heading(level: 2)[Artisanat — effets et contraintes] + heading(level: 2)[Artisanat — Effets et contraintes] [Les familles ci-dessous sont détectées dans les textes d’effet. Les moyennes de coût, niveau, toxicité et Finitions utilisent uniquement les lignes où le champ @@ -267,7 +269,7 @@ #let battle-plan() = { pagebreak(weak: true) - heading(level: 2)[Artisanat — plan de bataille] + heading(level: 2)[Artisanat — Plan de bataille] let damage = ranked-elements("Dégâts") let resistance = ranked-elements("Résistance") let damage-gaps = coverage-gap("Dégâts", "Résistance") @@ -283,33 +285,45 @@ let versatile = versatile-elements [Cette page ne formule aucune recommandation manuelle. Chaque signal est calculé à partir des mentions détectées ; il mesure la disponibilité des options, pas leur puissance numérique.] heading(level: 3)[Abondance et polyvalence] - grid(columns: (1fr, 1fr), column-gutter: 10pt, + grid(columns: (1fr, 1fr), column-gutter: 12pt, row-gutter: 10pt, insight-card("Axes offensifs abondants", counted-list(damage), [nombre de mentions de dégâts]), insight-card("Défenses abondantes", counted-list(resistance), [nombre de mentions de résistance]), insight-card("Éléments polyvalents", counted-list(versatile, count-key: "overlap"), [minimum commun entre dégâts et résistance]), insight-card("Accès disponibles", counted-list(ranked-elements("Accès")), [nombre de mentions donnant accès à l’élément])) heading(level: 3)[Concentration par métier] - grid(columns: (1fr, 1fr, 1fr, 1fr), column-gutter: 8pt, + grid(columns: (1fr, 1fr, 1fr, 1fr), column-gutter: 10pt, insight-card("Dégâts", counted-list(damage-crafts, limit: 2), [leader : #percentage(damage-crafts.first().count, damage-total) du total]), insight-card("Résistances", counted-list(resistance-crafts, limit: 2), [leader : #percentage(resistance-crafts.first().count, resistance-total) du total]), insight-card("Accès", counted-list(access-crafts, limit: 2), [leader : #percentage(access-crafts.first().count, access-total) du total]), insight-card("Diversité", counted-list(ranked-craft-breadth, limit: 2), [nombre d’éléments distincts par métier])) heading(level: 3)[Fenêtres de disponibilité] - grid(columns: (1fr, 1fr), column-gutter: 10pt, + grid(columns: (1fr, 1fr), column-gutter: 12pt, row-gutter: 10pt, insight-card("Pic offensif", "Tier " + str(damage-tiers.first().tier), [#damage-tiers.first().count mentions de dégâts]), insight-card("Pic défensif", "Tier " + str(resistance-tiers.first().tier), [#resistance-tiers.first().count mentions de résistance])) heading(level: 3)[Couverture asymétrique] - grid(columns: (1fr, 1fr), column-gutter: 10pt, + grid(columns: (1fr, 1fr), column-gutter: 12pt, row-gutter: 10pt, insight-card("Sans résistance détectée", if damage-gaps.len() == 0 { "Aucun" } else { damage-gaps.join(", ") }, [éléments présents en dégâts seulement]), insight-card("Sans dégâts détectés", if resistance-gaps.len() == 0 { "Aucun" } else { resistance-gaps.join(", ") }, [éléments présents en résistance seulement])) + + heading(level: 3)[Sélection d’équipement] + let efficiency = global-protection-efficiency-leader + grid( + columns: (1fr,), + row-gutter: 10pt, + insight-card( + "Protection par torque", + efficiency.name, + [#calc.round(efficiency.protection / efficiency.torque, digits: 2) protection / torque · #efficiency.protection protection pour #efficiency.torque torque], + ), + ) } #let craft-audit() = { pagebreak() - heading(level: 2)[Artisanat — audit des mentions] + heading(level: 2)[Artisanat — Audit des mentions] let rows = all-craft-mentions.map(mention => (mention.craft, mention.dataset, mention.item, if mention.tier == none { [—] } else { mention.tier }, mention.role, mention.element, mention.raw)) tables.set-table-style(table(columns: (0.62fr, 0.7fr, 1.15fr, 0.25fr, 0.55fr, 0.58fr, 1.85fr), @@ -321,11 +335,12 @@ pagebreak() heading(level: 1)[Artisanat] if chapter-enabled("craft.summary") { craft-summary() } + if chapter-enabled("craft.battle_plan") { battle-plan() } 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.defenses") { defense-report() } if chapter-enabled("craft.audit") { craft-audit() } } diff --git a/setup/analysis/defense_metrics.typ b/setup/analysis/defense_metrics.typ new file mode 100644 index 0000000..242d38d --- /dev/null +++ b/setup/analysis/defense_metrics.typ @@ -0,0 +1,60 @@ +// Compact defensive-equipment metrics derived from forge compositions. +#import "../../chapters/craft/forge-data.typ": equipments + +#let defense-category-labels = (Armors: "Armure", Shields: "Bouclier") +#let defense-nature-labels = ( + Light: "Léger", Medium: "Moyen", Heavy: "Lourd", SuperHeavy: "Super-lourd", +) + +#let minimum-torque(item) = { + let available = (item.torque_one_handed, item.torque_two_handed).filter(value => value != none) + if available.len() == 0 { none } else { calc.min(..available) } +} + +#let defensive-equipment = equipments.filter(item => ( + item.apply_category in ("Armors", "Shields") +)).map(item => ( + name: defense-category-labels.at(item.apply_category) + " · " + + defense-nature-labels.at(item.nature_category), + category: item.apply_category, + category-label: defense-category-labels.at(item.apply_category), + nature: item.nature_category, + nature-label: defense-nature-labels.at(item.nature_category), + protection: item.protection, + integrity: item.integrity, + parry: item.parry, + torque-one: item.torque_one_handed, + torque-two: item.torque_two_handed, + torque: minimum-torque(item), + source: item, +)) + +#let all-equipment-efficiency = equipments.filter(item => ( + item.apply_category in ("Weapons", "Armors", "Shields") +)).map(item => ( + name: item.name, + category: item.apply_category, + protection: item.protection, + torque: minimum-torque(item), +)).filter(item => item.torque != none and item.torque > 0) + +#let defense-leader(key, filter: item => true) = defensive-equipment.filter(filter).sorted( + key: item => if key == "torque" { item.at(key) } else { -item.at(key) }, +).first() + +#let protection-leader = defense-leader("protection") +#let integrity-leader = defense-leader("integrity") +#let parry-leader = defense-leader("parry") +#let torque-leader = defense-leader("torque") + +#let defense-efficiency(item, key) = if item.torque == 0 { 0 } else { + item.at(key) / item.torque +} + +#let protection-efficiency-leader = defensive-equipment.sorted( + key: item => -defense-efficiency(item, "protection"), +).first() + +#let global-protection-efficiency-leader = all-equipment-efficiency.sorted( + key: item => -(item.protection / item.torque), +).first() diff --git a/setup/analysis/defense_report.typ b/setup/analysis/defense_report.typ new file mode 100644 index 0000000..e1b6c3a --- /dev/null +++ b/setup/analysis/defense_report.typ @@ -0,0 +1,62 @@ +// Concise armor and shield comparison for the balance report. +#import "@preview/primaviz:0.6.0": line-chart +#import "defense_metrics.typ": * +#import "report_style.typ": chart-theme +#import "../theme/tables.typ" as tables + +#let defense-report() = { + pagebreak() + heading(level: 2)[Artisanat — Armures et boucliers] + [La torque est traitée comme la contrainte; protection, intégrité et parade + comme des bénéfices indépendants. Pour comparer les équipements, `Torque min.` + retient la plus faible prise valide. Les deux prises restent visibles dans le + tableau afin de ne pas masquer les contraintes d’équipement.] + + heading(level: 3)[Protection face à la torque] + grid( + columns: (1fr, 1fr), + column-gutter: 12pt, + ..("Armors", "Shields").map(category => { + let items = defensive-equipment.filter(item => item.category == category) + line-chart( + ( + labels: items.map(item => [T#item.torque]), + values: items.map(item => item.protection), + ), + width: 100%, + height: 180pt, + title: [#defense-category-labels.at(category)], + show-points: true, + line-width: 1.4pt, + point-size: 5pt, + x-label: [Torque minimale], + y-label: [Protection], + theme: chart-theme, + ) + }), + ) + + heading(level: 3)[Tableau défensif] + let rows = defensive-equipment.map(item => ( + item.name, + str(item.protection), + str(item.integrity), + if item.parry > 0 { "+" + str(item.parry) } else { str(item.parry) }, + if item.torque-one == none { [—] } else { str(item.torque-one) }, + if item.torque-two == none { [—] } else { str(item.torque-two) }, + str(item.torque), + )) + tables.set-table-style( + table( + columns: (1.5fr, 0.72fr, 0.72fr, 0.65fr, 0.72fr, 0.72fr, 0.78fr), + align: (left,) + (right,) * 6, + table.header( + [Équipement], [Protection], [Intégrité], [Parade], + [Torque 1M], [Torque 2M], [Torque min.], + ), + ..rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) +} diff --git a/setup/analysis/origin_report.typ b/setup/analysis/origin_report.typ index 8900fe9..afff7fa 100644 --- a/setup/analysis/origin_report.typ +++ b/setup/analysis/origin_report.typ @@ -24,7 +24,7 @@ let seven = characteristic-counts(origins: origins, value: 7) let five = characteristic-counts(origins: origins, value: 5) - heading(level: 2)[Origines — synthèse] + heading(level: 2)[Origines — Synthèse] grid( columns: (1fr, 1fr, 1fr, 1fr), @@ -100,7 +100,7 @@ } #let characteristic-audit(origins: all-origin-metrics) = { - heading(level: 2)[Origines — détail des caractéristiques] + heading(level: 2)[Origines — Détail des caractéristiques] let rows = () for origin in origins { rows.push(( @@ -151,7 +151,7 @@ #let ability-audit(origins: all-origin-metrics) = { pagebreak(weak: true) - heading(level: 2)[Origines — capacités par famille] + heading(level: 2)[Origines — Capacités par famille] let families = abilities-by-family(origins: origins) grouped-bar-chart( @@ -186,7 +186,7 @@ #let resistance-audit(origins: all-origin-metrics) = { pagebreak(weak: true) - heading(level: 2)[Origines — audit des résistances] + heading(level: 2)[Origines — Audit des résistances] [Cette extraction est heuristique. Elle analyse uniquement les descriptions de capacités `passive` et retient les segments contenant « résistance » ou @@ -215,7 +215,7 @@ #let passive-bonus-detail(origins: all-origin-metrics) = { pagebreak() - heading(level: 2)[Origines — gains numériques des passifs] + heading(level: 2)[Origines — Gains numériques des passifs] [L’extraction retient uniquement les bonus numériques explicites séparés par des virgules. Elle distingue Jauge, Initiative, mobilité, Fatigue, PV et @@ -262,7 +262,7 @@ ) pagebreak() - heading(level: 2)[Origines — audit des gains passifs] + heading(level: 2)[Origines — Audit des gains passifs] let audit-rows = grants.map(grant => ( grant.family, @@ -288,7 +288,7 @@ #let jauge-focus(origins: all-origin-metrics) = { pagebreak() - heading(level: 2)[Origines — focus Jauge] + heading(level: 2)[Origines — Focus Jauge] let grants = all-passive-bonuses(origins: origins).filter( grant => grant.category == "Jauge", diff --git a/setup/analysis/weapon_armor_report.typ b/setup/analysis/weapon_armor_report.typ index 8eb642c..33f8504 100644 --- a/setup/analysis/weapon_armor_report.typ +++ b/setup/analysis/weapon_armor_report.typ @@ -1,5 +1,5 @@ // Report views for exact armor-destruction expectations and breakpoints. -#import "@preview/primaviz:0.6.0": heatmap, multi-scatter-plot +#import "@preview/primaviz:0.6.0": heatmap, multi-line-chart #import "weapon_armor_breakpoints.typ": * #import "report_style.typ": chart-theme, rounded #import "../theme/tables.typ" as tables @@ -67,11 +67,19 @@ grid( columns: (1fr, 1fr, 1fr), column-gutter: 8pt, - ..comparison-dice-pools.map(dice => multi-scatter-plot( - (series: nature-armor-series(dice)), + ..comparison-dice-pools.map(dice => multi-line-chart( + ( + labels: analyzed-protections.map(str), + series: nature-armor-series(dice).map(series => ( + name: series.name, + values: series.points.map(point => point.at(1)), + )), + ), width: 100%, height: 180pt, title: [#dice dés], + show-points: true, + line-width: 1.2pt, point-size: 4pt, x-label: [Protection], y-label: [Armure détruite], diff --git a/setup/analysis/weapon_report.typ b/setup/analysis/weapon_report.typ index d3503b8..60a430f 100644 --- a/setup/analysis/weapon_report.typ +++ b/setup/analysis/weapon_report.typ @@ -3,6 +3,8 @@ #import "weapon_metrics.typ": * #import "report_style.typ": chart-theme, metric-card, rounded #import "../theme/tables.typ" as tables +#import "weapon_armor_breakpoints.typ": armor-commitment-analysis +#import "report_config.typ": armor-settings #let low-scenario = commitment-pools.find(item => item.key == "low") #let mid-scenario = commitment-pools.find(item => item.key == "mid") @@ -62,7 +64,7 @@ #let weapon-analysis-report() = { pagebreak() - heading(level: 2)[Artisanat — équilibre des armes] + heading(level: 2)[Artisanat — Équilibre des armes] let max-ranked = ranked-weapons("max-damage") let action-ranked = ranked-weapons("damage-per-action") @@ -142,6 +144,45 @@ theme: chart-theme, ) + heading(level: 3)[Plan de bataille — Sélection des armes] + let low-leader = all-weapon-metrics.sorted( + key: item => -item.commitments.low.best, + ).first() + let full-leader = all-weapon-metrics.sorted( + key: item => -item.commitments.full.best, + ).first() + let armor-protection = armor-settings.utilization_protection + let armor-dice = armor-settings.utilization_dice + let armor-leader = all-weapon-metrics.map(item => ( + item: item, + value: armor-commitment-analysis(item, armor-dice, armor-protection).destruction, + )).sorted(key: result => -result.value).first() + let scaling-leader = all-weapon-metrics.map(item => ( + item: item, + gain: item.commitments.full.best - item.commitments.low.best, + )).sorted(key: result => -result.gain).first() + grid( + columns: (1fr, 1fr), + column-gutter: 12pt, + row-gutter: 12pt, + metric-card( + "Faible engagement", low-leader.name, + note: [#rounded(low-leader.commitments.low.best, digits: 2) dégâts à #low-scenario.dice dés], + ), + metric-card( + "Engagement total", full-leader.name, + note: [#rounded(full-leader.commitments.full.best, digits: 2) dégâts à #full-scenario.dice dés], + ), + metric-card( + "Destruction d’armure", armor-leader.item.name, + note: [#rounded(armor-leader.value, digits: 2) armure contre P#armor-protection à #armor-dice dés], + ), + metric-card( + "Meilleure montée en puissance", scaling-leader.item.name, + note: [+#rounded(scaling-leader.gain, digits: 2) dégâts entre #low-scenario.dice et #full-scenario.dice dés], + ), + ) + heading(level: 3)[Classements offensifs] grid( columns: (1fr, 1fr, 1fr), -- 2.45.1