ravenous_typst/setup/analysis/weapon_report.typ

212 lines
7.7 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// 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()
}