From f1ccb44ccdb71c425c04a4a4506c3af08e301a57 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Fri, 21 Aug 2026 00:39:40 +0200 Subject: [PATCH] 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() +}