658 lines
20 KiB
Plaintext
658 lines
20 KiB
Plaintext
// Craft portfolio analysis, separating observed counts from interpretation.
|
||
#import "@preview/primaviz:0.6.0": grouped-bar-chart, horizontal-bar-chart
|
||
#import "craft_metrics.typ": *
|
||
#import "report_style.typ": chart-theme, metric-card, report-theme, rounded
|
||
#import "../theme/tables.typ" as tables
|
||
#import "../build_config.typ": craft-tiers, craft-trigram
|
||
#import "weapon_report.typ": weapon-analysis-report
|
||
#import "class_weapon_report.typ": class-weapon-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 "craft_price_report.typ": craft-price-report
|
||
#import "report_config.typ": chapter-enabled
|
||
|
||
#let insight-card(label, value, note) = block(
|
||
width: 100%,
|
||
fill: report-theme.parchment,
|
||
stroke: 0.6pt + report-theme.border,
|
||
inset: 7pt,
|
||
radius: 2pt,
|
||
)[
|
||
#text(
|
||
size: 6.5pt,
|
||
tracking: 0.06em,
|
||
weight: "bold",
|
||
fill: report-theme.heading-subtle,
|
||
)[
|
||
#upper(label)
|
||
]
|
||
#v(2pt)
|
||
#text(size: 9.5pt, weight: "bold", fill: report-theme.heading)[#value]
|
||
#v(1pt)
|
||
#text(size: 7pt, fill: report-theme.muted-ink)[#note]
|
||
]
|
||
|
||
#let percentage(part, total) = if total == 0 { "0 %" } else {
|
||
str(calc.round(100 * part / total, digits: 0)) + " %"
|
||
}
|
||
|
||
#let counted-list(items, count-key: "count", limit: 4) = (
|
||
items
|
||
.slice(
|
||
0,
|
||
calc.min(limit, items.len()),
|
||
)
|
||
.map(item => item.label + " (" + str(item.at(count-key)) + ")")
|
||
.join(", ")
|
||
)
|
||
|
||
#let range-label(value) = if value == none { [—] } else {
|
||
[#value.min–#value.max (#value.count)]
|
||
}
|
||
|
||
#let craft-summary() = {
|
||
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()),
|
||
)
|
||
[L’unité mesurée est une *mention fonctionnelle* d’un élément dans un effet : dégâts, résistance, accès ou autre interaction. Elle décrit la couverture du système, pas sa puissance brute. Un effet très fort et un effet mineur comptent donc chacun une fois.]
|
||
heading(level: 3)[Fonctions élémentaires par artisanat]
|
||
grouped-bar-chart(
|
||
(
|
||
labels: craft-order,
|
||
series: context-order.map(role => (
|
||
name: role,
|
||
values: craft-order.map(craft => selected-mentions(
|
||
craft: craft,
|
||
role: role,
|
||
).len()),
|
||
)),
|
||
),
|
||
width: 100%,
|
||
height: 205pt,
|
||
theme: chart-theme,
|
||
)
|
||
heading(level: 3)[Progression par tier]
|
||
grouped-bar-chart(
|
||
(
|
||
labels: craft-tiers.map(tier => "T" + str(tier)),
|
||
series: ("Dégâts", "Résistance", "Accès").map(role => (
|
||
name: role,
|
||
values: tier-counts(role: role).map(item => item.count),
|
||
)),
|
||
),
|
||
width: 100%,
|
||
height: 180pt,
|
||
theme: chart-theme,
|
||
)
|
||
}
|
||
|
||
#let element-coverage() = {
|
||
pagebreak(weak: true)
|
||
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,
|
||
horizontal-bar-chart(
|
||
(
|
||
labels: damage.map(item => item.label),
|
||
values: damage.map(item => item.count),
|
||
),
|
||
width: 100%,
|
||
height: 235pt,
|
||
title: [Mentions dans les dégâts],
|
||
show-values: true,
|
||
theme: chart-theme,
|
||
),
|
||
horizontal-bar-chart(
|
||
(
|
||
labels: resistance.map(item => item.label),
|
||
values: resistance.map(item => item.count),
|
||
),
|
||
width: 100%,
|
||
height: 235pt,
|
||
title: [Mentions dans les résistances],
|
||
show-values: true,
|
||
theme: chart-theme,
|
||
),
|
||
)
|
||
heading(level: 3)[Matrice fonctionnelle]
|
||
let rows = ()
|
||
for element in element-definitions {
|
||
let values = context-order.map(role => selected-mentions(
|
||
role: role,
|
||
element: element.label,
|
||
).len())
|
||
if values.sum() > 0 { rows.push((element.label,) + values.map(str)) }
|
||
}
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (1.5fr,) + (0.75fr,) * 4,
|
||
align: (left,) + (right,) * 4,
|
||
table.header([Élément], [Dégâts], [Résistance], [Accès], [Autre]),
|
||
..rows.flatten(),
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 8pt,
|
||
)
|
||
}
|
||
|
||
#let mechanic-analysis() = {
|
||
pagebreak(weak: true)
|
||
heading(level: 2)[Artisanat — Effets et contraintes]
|
||
|
||
[Les familles ci-dessous sont détectées dans les textes d’effet; R.Max, Torque
|
||
et Accès élémentaire proviennent de leurs macros structurées dans tous les champs. Les moyennes
|
||
de coût, niveau, toxicité et Finitions utilisent uniquement les lignes où le champ
|
||
correspondant est présent. Le breakpoint est le tier dont l’augmentation par
|
||
rapport au tier précédent est la plus forte.]
|
||
|
||
heading(level: 3)[Volume par famille d’effet]
|
||
horizontal-bar-chart(
|
||
(
|
||
labels: mechanic-counts.map(item => item.label),
|
||
values: mechanic-counts.map(item => item.count),
|
||
),
|
||
width: 100%,
|
||
height: 190pt,
|
||
show-values: true,
|
||
theme: chart-theme,
|
||
)
|
||
|
||
heading(level: 3)[Contraintes moyennes et breakpoints]
|
||
let rows = mechanic-profiles.map(profile => (
|
||
profile.category,
|
||
str(profile.count),
|
||
"T" + str(profile.first-tier),
|
||
"T" + str(profile.peak-tier) + " (" + str(profile.peak-count) + ")",
|
||
"T"
|
||
+ str(profile.breakpoint-tier)
|
||
+ " ("
|
||
+ if profile.breakpoint-increase >= 0 { "+" } else { "" }
|
||
+ str(profile.breakpoint-increase)
|
||
+ ")",
|
||
rounded(profile.cost, digits: 1),
|
||
rounded(profile.level, digits: 1),
|
||
rounded(profile.toxicity, digits: 1),
|
||
rounded(profile.endurance, digits: 1),
|
||
))
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (
|
||
1.25fr,
|
||
0.38fr,
|
||
0.42fr,
|
||
0.72fr,
|
||
0.78fr,
|
||
0.48fr,
|
||
0.48fr,
|
||
0.48fr,
|
||
0.48fr,
|
||
),
|
||
align: (left,) + (right,) * 8,
|
||
table.header(
|
||
[Famille],
|
||
[N],
|
||
[Début],
|
||
[Pic],
|
||
[Rupture],
|
||
[Coût],
|
||
[Niv.],
|
||
[Tox.],
|
||
[Finitions],
|
||
),
|
||
..rows.flatten(),
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 7pt,
|
||
)
|
||
|
||
let constrained = ("cost", "level", "toxicity", "endurance").map(key => {
|
||
let available = mechanic-profiles
|
||
.filter(profile => profile.at(key) != none)
|
||
.sorted(
|
||
key: profile => -profile.at(key),
|
||
)
|
||
(key: key, leader: available.first())
|
||
})
|
||
grid(
|
||
columns: (1fr,) * 4,
|
||
column-gutter: 7pt,
|
||
insight-card(
|
||
"Coût max. moyen",
|
||
constrained.at(0).leader.category
|
||
+ " · "
|
||
+ str(constrained.at(0).leader.cost),
|
||
[maximum calculé entre familles],
|
||
),
|
||
insight-card(
|
||
"Niveau max. moyen",
|
||
constrained.at(1).leader.category
|
||
+ " · "
|
||
+ str(constrained.at(1).leader.level),
|
||
[maximum calculé entre familles],
|
||
),
|
||
insight-card(
|
||
"Toxicité max. moyenne",
|
||
constrained.at(2).leader.category
|
||
+ " · "
|
||
+ str(constrained.at(2).leader.toxicity),
|
||
[maximum calculé entre familles],
|
||
),
|
||
insight-card(
|
||
"Finitions moy. max.",
|
||
constrained.at(3).leader.category
|
||
+ " · "
|
||
+ str(constrained.at(3).leader.endurance),
|
||
[maximum calculé entre familles],
|
||
),
|
||
)
|
||
|
||
pagebreak(weak: true)
|
||
heading(level: 3)[Répartition par métier]
|
||
let craft-rows = ()
|
||
for category in mechanic-order {
|
||
craft-rows.push(category)
|
||
for craft in craft-order {
|
||
craft-rows.push(str(
|
||
all-craft-mechanics
|
||
.filter(item => (
|
||
item.category == category and item.craft == craft
|
||
))
|
||
.len(),
|
||
))
|
||
}
|
||
}
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (1.4fr,) + (0.78fr,) * craft-order.len(),
|
||
align: (left,) + (right,) * craft-order.len(),
|
||
table.header([Famille], ..craft-order.map(craft-trigram)),
|
||
..craft-rows,
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 7.5pt,
|
||
)
|
||
|
||
heading(level: 3)[Étendue des contraintes]
|
||
let range-rows = mechanic-order.map(category => {
|
||
let records = selected-mechanics(category: category)
|
||
(
|
||
category,
|
||
range-label(range-present(records, "cost")),
|
||
range-label(range-present(records, "level")),
|
||
range-label(range-present(records, "toxicity")),
|
||
range-label(range-present(records, "endurance")),
|
||
)
|
||
})
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (1.3fr, 1fr, 1fr, 1fr, 1fr),
|
||
align: (left, right, right, right, right),
|
||
table.header(
|
||
[Famille],
|
||
[Coût min–max],
|
||
[Niv. min–max],
|
||
[Tox. min–max],
|
||
[Finitions min–max],
|
||
),
|
||
..range-rows.flatten(),
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 7.2pt,
|
||
)
|
||
|
||
heading(level: 3)[Contraintes moyennes par tier]
|
||
let tier-rows = craft-tiers.map(tier => {
|
||
let records = all-craft-mechanics.filter(item => item.tier == tier)
|
||
(
|
||
"T" + str(tier),
|
||
str(records.len()),
|
||
rounded(average-present(records, "cost"), digits: 1),
|
||
rounded(average-present(records, "level"), digits: 1),
|
||
rounded(average-present(records, "toxicity"), digits: 1),
|
||
rounded(average-present(records, "endurance"), digits: 1),
|
||
)
|
||
})
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (0.6fr, 0.6fr, 1fr, 1fr, 1fr, 1fr),
|
||
align: (left, right, right, right, right, right),
|
||
table.header(
|
||
[Tier], [N], [Coût moy.], [Niv. moy.], [Tox. moy.], [Finitions moy.]
|
||
),
|
||
..tier-rows.flatten(),
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 7.5pt,
|
||
)
|
||
|
||
pagebreak(weak: true)
|
||
heading(level: 3)[Altérations et marques]
|
||
let alterations = subtype-counts("Altérations")
|
||
let marks = subtype-counts("Marques")
|
||
grid(
|
||
columns: (1fr, 1fr),
|
||
column-gutter: 12pt,
|
||
horizontal-bar-chart(
|
||
(
|
||
labels: alterations.map(item => item.label.replace("_", " ")),
|
||
values: alterations.map(item => item.count),
|
||
),
|
||
width: 100%,
|
||
height: 255pt,
|
||
title: [Altérations détectées],
|
||
show-values: true,
|
||
theme: chart-theme,
|
||
),
|
||
horizontal-bar-chart(
|
||
(
|
||
labels: marks.map(item => item.label.replace("_", " ")),
|
||
values: marks.map(item => item.count),
|
||
),
|
||
width: 100%,
|
||
height: 150pt,
|
||
title: [Marques détectées],
|
||
show-values: true,
|
||
theme: chart-theme,
|
||
),
|
||
)
|
||
|
||
heading(level: 3)[Contraintes des altérations les plus fréquentes]
|
||
let subtype-rows = alterations
|
||
.slice(0, calc.min(12, alterations.len()))
|
||
.map(item => {
|
||
let profile = subtype-profile("Altérations", item.label)
|
||
(
|
||
item.label.replace("_", " "),
|
||
str(profile.count),
|
||
"T" + str(profile.first-tier),
|
||
"T" + str(profile.peak-tier),
|
||
rounded(profile.cost, digits: 1),
|
||
rounded(profile.level, digits: 1),
|
||
rounded(profile.toxicity, digits: 1),
|
||
)
|
||
})
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (1.4fr, 0.45fr, 0.55fr, 0.55fr, 0.7fr, 0.7fr, 0.7fr),
|
||
align: (left,) + (right,) * 6,
|
||
table.header([Altération], [N], [Début], [Pic], [Coût], [Niv.], [Tox.]),
|
||
..subtype-rows.flatten(),
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 7pt,
|
||
)
|
||
|
||
heading(level: 3)[Contraintes des marques]
|
||
let mark-rows = marks.map(item => {
|
||
let profile = subtype-profile("Marques", item.label)
|
||
(
|
||
item.label.replace("_", " "),
|
||
str(profile.count),
|
||
"T" + str(profile.first-tier),
|
||
"T" + str(profile.peak-tier),
|
||
rounded(profile.cost, digits: 1),
|
||
rounded(profile.level, digits: 1),
|
||
rounded(profile.toxicity, digits: 1),
|
||
)
|
||
})
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (1.4fr, 0.45fr, 0.55fr, 0.55fr, 0.7fr, 0.7fr, 0.7fr),
|
||
align: (left,) + (right,) * 6,
|
||
table.header([Marque], [N], [Début], [Pic], [Coût], [Niv.], [Tox.]),
|
||
..mark-rows.flatten(),
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 7pt,
|
||
)
|
||
|
||
heading(level: 3)[Progression automatique par tier]
|
||
let progression-rows = ()
|
||
for profile in mechanic-profiles {
|
||
progression-rows.push(profile.category)
|
||
for tier in mechanic-tier-counts(profile.category) {
|
||
progression-rows.push(str(tier.count))
|
||
}
|
||
}
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (1.45fr,) + (0.6fr,) * craft-tiers.len(),
|
||
align: (left,) + (right,) * craft-tiers.len(),
|
||
table.header([Famille], ..craft-tiers.map(tier => [T#tier])),
|
||
..progression-rows,
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 7.5pt,
|
||
)
|
||
|
||
pagebreak(weak: true)
|
||
heading(level: 3)[Références aux règles et caractéristiques]
|
||
[Cette couche est exhaustive: chaque occurrence de `@rl_*` et `@ca_*` dans
|
||
les champs et valeurs analysés est comptée, même lorsqu’aucune heuristique
|
||
spécifique n’existe encore pour la macro. Les en-têtes-macros sont comptés
|
||
une fois par entrée, comme les autres variables de données.]
|
||
horizontal-bar-chart(
|
||
(
|
||
labels: rule-reference-counts.map(item => item.label),
|
||
values: rule-reference-counts.map(item => item.count),
|
||
),
|
||
width: 100%,
|
||
height: 220pt,
|
||
show-values: true,
|
||
x-label: [Occurrences],
|
||
theme: chart-theme,
|
||
)
|
||
let reference-rows = rule-reference-counts.map(item => (
|
||
item.label,
|
||
[@#item.macro],
|
||
str(item.count),
|
||
item.crafts.join(", "),
|
||
if item.first-tier == none { [—] } else { str(item.first-tier) },
|
||
if item.last-tier == none { [—] } else { str(item.last-tier) },
|
||
))
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (1.35fr, 1fr, 0.45fr, 1.25fr, 0.5fr, 0.5fr),
|
||
align: (left, left, right, left, right, right),
|
||
table.header([Effet], [Macro], [N], [Artisanats], [T. min], [T. max]),
|
||
..reference-rows.flatten(),
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 7.2pt,
|
||
)
|
||
}
|
||
|
||
#let battle-plan() = {
|
||
pagebreak(weak: true)
|
||
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")
|
||
let resistance-gaps = coverage-gap("Résistance", "Dégâts")
|
||
let damage-crafts = ranked-crafts("Dégâts")
|
||
let resistance-crafts = ranked-crafts("Résistance")
|
||
let access-crafts = ranked-crafts("Accès")
|
||
let damage-tiers = ranked-tiers("Dégâts")
|
||
let resistance-tiers = ranked-tiers("Résistance")
|
||
let damage-total = selected-mentions(role: "Dégâts").len()
|
||
let resistance-total = selected-mentions(role: "Résistance").len()
|
||
let access-total = selected-mentions(role: "Accès").len()
|
||
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: 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: 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: 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: 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]
|
||
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),
|
||
table.header(
|
||
[Métier], [Source], [Entrée], [T.], [Rôle], [Élément], [Segment détecté]
|
||
),
|
||
..rows.flatten(),
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 5.9pt,
|
||
)
|
||
|
||
heading(level: 3)[Audit des références `@rl_*` et `@ca_*`]
|
||
let reference-rows = all-craft-rule-references.map(reference => (
|
||
reference.craft,
|
||
reference.dataset,
|
||
reference.item,
|
||
if reference.tier == none { [—] } else { str(reference.tier) },
|
||
[@#reference.macro],
|
||
reference.field,
|
||
reference.raw,
|
||
))
|
||
tables.set-table-style(
|
||
table(
|
||
columns: (0.58fr, 0.68fr, 1fr, 0.28fr, 0.75fr, 0.9fr, 1.8fr),
|
||
table.header(
|
||
[Métier], [Source], [Entrée], [T.], [Macro], [Champ], [Valeur source]
|
||
),
|
||
..reference-rows.flatten(),
|
||
),
|
||
table-theme: "steingrund",
|
||
text-size: 5.9pt,
|
||
)
|
||
}
|
||
|
||
#let render-craft-report() = {
|
||
pagebreak()
|
||
heading(level: 1)[Artisanat]
|
||
if chapter-enabled("craft.summary") { craft-summary() }
|
||
if chapter-enabled("craft.prices") { craft-price-report() }
|
||
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.weapons.classes") { class-weapon-report() }
|
||
if chapter-enabled("craft.defenses") { defense-report() }
|
||
if chapter-enabled("craft.audit") { craft-audit() }
|
||
}
|