More weapon balancing
This commit is contained in:
parent
7d7a4be647
commit
420b55dc89
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
@ -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),
|
||||
)
|
||||
})
|
||||
|
|
@ -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),
|
||||
)
|
||||
|
|
@ -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()
|
||||
}
|
||||
Loading…
Reference in New Issue