ravenous_typst/setup/analysis/weapon_report.typ

220 lines
8.3 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 "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 => (
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: 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 " + str(mid-scenario.dice) + "→" + str(full-scenario.dice), 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
`(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
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é],
[#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(),
),
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 à #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
à #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%,
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·#low-scenario.dice d], [E·#mid-scenario.dice d],
[E·#full-scenario.dice d],
),
..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,
)
}