Reporting on monsters
Build Successful The Ravenous rulebook, master handbook, and balance report were built successfully.
Ravenous/ravenous_typst/pipeline/head This commit looks good Details

This commit is contained in:
Dandaedre 2026-08-22 20:09:30 +02:00
parent 244744ea92
commit 30c7869a01
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
10 changed files with 1163 additions and 2 deletions

53
README.md Normal file
View File

@ -0,0 +1,53 @@
# Ravenous Typst
## Building the master handbook
Build the complete master handbook:
```sh
typst compile master_handbook.typ master_handbook.pdf
```
To work on one creature without rendering every other bestiary entry, pass its
database ID through `creature_id`:
```sh
typst compile --input creature_id=3 master_handbook.typ creature-3.pdf
```
The master handbook automatically enables its master-only glossary entries, so
no preset argument is required. An unknown ID, or an ID not visible to the
master, produces an explicit error.
For a persistent local selection, set `build.creature_id` in
`data/config/build.yaml`. Keep it as an empty string to render every
master-visible creature:
```yaml
build:
creature_id: "3"
```
To test trusted database markup and glossary evaluation one creature at a time:
```sh
tools/check_creature_eval.sh
```
Pass an ID to check only one entry:
```sh
tools/check_creature_eval.sh 3
```
## Building the master creature balance report
Build the standalone creature analysis report with:
```sh
typst compile balance_report_master.typ balance_report_master.pdf
```
Its sections are enabled in `data/config/balance_report_master.yaml`. The
initial report covers common creature profiles, rewards, and regional
difficulty; later creature-specific analyses can be added independently.

65
balance_report_master.typ Normal file
View File

@ -0,0 +1,65 @@
// Standalone master-facing creature balance-analysis target.
#import "/setup/theme/themes.typ" as themes
#import "/setup/analysis/creature_common_report.typ": (
render-common-profile-report,
render-common-region-report,
render-common-reward-report,
)
#import "/setup/analysis/creature_durability_report.typ": render-durability-report
#let report-config = yaml("/data/config/balance_report_master.yaml")
#let enabled-chapters = report-config.chapters
#let chapter-enabled(id) = id in enabled-chapters
#let report-theme = themes.make-theme(theme-name: "steingrund")
#let report-theme-var = themes.make-theme-variable(theme-name: "steingrund")
#let report-numbering(..numbers) = {
let patterns = ("1", "1", "1", "I", "a")
numbers.pos().enumerate().map(pair => numbering(
patterns.at(pair.at(0), default: "1"), pair.at(1),
)).join([.]) + [.]
}
#let configure-report(document) = {
set page(paper: "a4", margin: (x: 1.8cm, y: 1.7cm), numbering: "1")
set text(font: report-theme-var("font"), size: 9.5pt, lang: "fr", fill: report-theme.ink)
set par(justify: true, leading: 0.7em, spacing: 0.75em)
set heading(numbering: report-numbering)
let heading-label(it) = if it.numbering == none { [] } else {
counter(heading).display(it.numbering)
}
show heading.where(level: 1): it => block(above: 1.4em, below: 0.8em)[
#text(size: 20pt, weight: "bold", fill: report-theme.heading)[#heading-label(it) #h(0.45em) #it.body]
]
show heading.where(level: 2): it => block(above: 1em, below: 0.5em)[
#text(size: 13pt, weight: "bold", fill: report-theme.heading-accent)[#heading-label(it) #h(0.4em) #it.body]
]
show heading.where(level: 3): it => block(above: 0.8em, below: 0.35em)[
#text(size: 10.5pt, weight: "bold", fill: report-theme.heading-subtle)[#heading-label(it) #h(0.35em) #it.body]
]
show strong: set text(fill: report-theme.emphasis)
document
}
#show: configure-report
#set document(title: "Ravenous — Rapport d’équilibrage des créatures", author: "Dandaedre")
#page(numbering: none)[
#align(center + horizon)[
#text(size: 34pt, weight: "bold", fill: report-theme.heading)[RAPPORT D’ÉQUILIBRAGE]
#v(0.8em)
#text(size: 14pt, tracking: 0.08em, fill: report-theme.heading-accent)[CRÉATURES — LIVRE DU MJ]
#v(1.8em)
#text(size: 10pt, fill: report-theme.muted-ink)[Profils communs, récompenses et difficulté régionale]
]
]
#pagebreak()
#outline(title: "Sommaire")
#pagebreak()
#if chapter-enabled("creatures.common.profile") { render-common-profile-report() }
#if chapter-enabled("creatures.common.rewards") { render-common-reward-report() }
#if chapter-enabled("creatures.common.regions") { render-common-region-report() }
#if chapter-enabled("creatures.durability") { render-durability-report() }

View File

@ -0,0 +1,8 @@
# Sections of the standalone master creature balancing report.
# Future creature-specific analyses can be enabled here without changing the
# report entry point.
chapters:
- creatures.common.profile
- creatures.common.rewards
- creatures.common.regions
- creatures.durability

View File

@ -25,7 +25,7 @@ build:
# Compile only one creature in the master bestiary while diagnosing trusted
# database markup/glossary evaluation. Leave empty for the complete book.
# Command-line example:
# typst compile --input preset=master-handbook --input creature_id=3 master_handbook.typ
# typst compile --input creature_id=3 master_handbook.typ creature-3.pdf
creature_id: ""
# Always excluded, in addition to the exclusions from the selected preset.

@ -1 +1 @@
Subproject commit e7bb093a505ac281921e0604ec64888c5caf0a70
Subproject commit a557d9cd9e19e571da29871fd28626215370b02e

View File

@ -0,0 +1,348 @@
// Common, descriptive creature metrics shared by the master balance report.
#import "../generation/creature-data.typ": master-creatures
#let present(value) = value != none and value != ""
#let label-or(value, fallback) = if present(value) { str(value) } else { fallback }
#let average(values) = {
let usable = values.filter(value => value != none)
if usable.len() == 0 { none } else { usable.sum() / usable.len() }
}
#let standard-deviation(values) = {
let usable = values.filter(value => value != none)
if usable.len() == 0 { none } else {
let mean = average(usable)
calc.sqrt(usable.map(value => (value - mean) * (value - mean)).sum() / usable.len())
}
}
#let extent(values) = {
let usable = values.filter(value => value != none).sorted()
if usable.len() == 0 { (min: none, max: none) } else {
(min: usable.first(), max: usable.last())
}
}
#let counts(values) = values.dedup().map(value => (
label: value,
count: values.filter(candidate => candidate == value).len(),
)).sorted(key: item => -item.count)
#let csv-values(value) = if value == none { () } else {
str(value).split(",").map(item => item.trim()).filter(item => item != "")
}
#let action-value(value) = {
let found = value.match(regex("\d+"))
if found == none { 0 } else { int(found.text) }
}
#let action-total(value) = {
let values = csv-values(value).map(action-value)
if values.len() == 0 { 0 } else { values.sum() }
}
#let quantile(values, probability) = {
let sorted = values.sorted()
if sorted.len() == 0 { return none }
let position = (sorted.len() - 1) * probability
let low = calc.floor(position)
let high = calc.ceil(position)
if low == high { sorted.at(low) } else {
sorted.at(low) + (sorted.at(high) - sorted.at(low)) * (position - low)
}
}
#let common-creatures = master-creatures.map(creature => {
let balancing = creature.raw.balancing
let balance = if balancing.len() == 0 { none } else { balancing.first() }
(
id: creature.id,
name: creature.name,
region: label-or(creature.region, "Sans région"),
subregion: label-or(creature.subregion, "Sans sous-région"),
calamity: label-or(creature.calamity, "Non renseignée"),
profile-hse: if balance == none { "Non renseigné" } else {
label-or(balance.profile_hse, "Non renseigné")
},
strength: creature.stats.strength,
perception: creature.stats.perception,
willpower: creature.stats.willpower,
alteration-resistance: creature.stats.alteration-resistance,
transcendental-resistance: creature.stats.transcendental-resistance,
torque: creature.stats.torque,
awareness: creature.stats.awareness,
fatigue: creature.stats.fatigue,
walk: creature.stats.movement.walk,
trot: creature.stats.movement.trot,
run: creature.stats.movement.run,
flight: creature.stats.movement.flight,
p1-initiative-steps: csv-values(creature.raw.stats.p1_init).len(),
p2-initiative-steps: csv-values(creature.raw.stats.p2_init).len(),
p1-action-total: action-total(creature.raw.stats.p1_actions),
p2-action-total: action-total(creature.raw.stats.p2_actions),
physical-bonus: creature.stats.physical-bonus,
elemental-bonus: creature.stats.elemental-bonus,
blood-base: creature.blood.base,
blood-battle: creature.blood.battle,
blood-carve: creature.blood.carve,
reward-count: creature.rewards.len(),
rewards: creature.rewards,
monster-group-size: if balance == none { none } else { balance.monster_groupsize },
player-group-size: if balance == none { none } else { balance.player_groupsize },
time-to-armorbreak: if balance == none { none } else { balance.time_to_armorbreak },
time-to-p2: if balance == none { none } else { balance.time_to_p2 },
time-to-kill: if balance == none { none } else { balance.time_to_kill },
defensive-successes: if balance == none { none } else { balance.average_defensive_successes },
time-to-player-kill: if balance == none { none } else { balance.time_to_player_kill },
balance-configured: balance != none,
source: creature,
)
})
#let regions = common-creatures.map(item => item.region).dedup().sorted()
#let subregions = common-creatures.map(item => item.region + " / " + item.subregion).dedup().sorted()
#let hse-profiles = ("Lowest", "Low", "Mid", "High", "Highest", "Non renseigné").filter(
profile => common-creatures.any(item => item.profile-hse == profile),
)
#let difficulty-counts = counts(common-creatures.map(item => item.profile-hse))
#let dominant-difficulty = difficulty-counts.first()
#let calamities = common-creatures.map(item => item.calamity).dedup().sorted()
#let average-fatigue = average(common-creatures.map(item => item.fatigue))
#let average-torque = average(common-creatures.map(item => item.torque))
#let average-rewards = average(common-creatures.map(item => item.reward-count))
#let configured-balancing = common-creatures.filter(item => item.balance-configured)
#let creatures-with-rewards = common-creatures.filter(item => item.reward-count > 0)
#let creatures-without-rewards = common-creatures.filter(item => item.reward-count == 0)
#let inner-stat-fields = (
(key: "strength", label: "Force"),
(key: "perception", label: "Perception"),
(key: "willpower", label: "Volonté"),
(key: "alteration-resistance", label: "Rés. alt."),
(key: "transcendental-resistance", label: "Rés. trans."),
(key: "torque", label: "Torque"),
(key: "awareness", label: "Vigilance"),
(key: "fatigue", label: "Fatigue"),
(key: "physical-bonus", label: "Bonus phy."),
(key: "elemental-bonus", label: "Bonus élém."),
(key: "walk", label: "Marche"),
(key: "run", label: "Course"),
(key: "flight", label: "Vol"),
)
#let inner-stat-value(creature, key) = creature.at(key)
#let inner-stat-summaries = inner-stat-fields.map(field => {
let observations = common-creatures.map(creature => (
creature: creature,
value: inner-stat-value(creature, field.key),
)).filter(item => item.value != none)
let values = observations.map(item => item.value)
let limits = extent(values)
let mean = average(values)
let deviation = standard-deviation(values)
let enriched = observations.map(item => item + (
z: if deviation == none or deviation == 0 { 0 } else { (item.value - mean) / deviation },
))
(
key: field.key,
label: field.label,
average: mean,
deviation: deviation,
min: limits.min,
max: limits.max,
observations: enriched,
low-outliers: enriched.filter(item => item.z <= -1.5).sorted(key: item => item.z),
high-outliers: enriched.filter(item => item.z >= 1.5).sorted(key: item => -item.z),
)
})
#let inner-stat-boxes = inner-stat-summaries.map(summary => {
let values = summary.observations.map(item => item.z)
let q1 = quantile(values, 0.25)
let median = quantile(values, 0.5)
let q3 = quantile(values, 0.75)
let iqr = q3 - q1
let lower-fence = q1 - 1.5 * iqr
let upper-fence = q3 + 1.5 * iqr
let inner = values.filter(value => value >= lower-fence and value <= upper-fence).sorted()
(
label: summary.label,
min: inner.first(),
q1: q1,
median: median,
q3: q3,
max: inner.last(),
outliers: values.filter(value => value < lower-fence or value > upper-fence),
)
})
#let inner-stat-tier-summaries = hse-profiles.map(difficulty => {
let creatures = common-creatures.filter(item => item.profile-hse == difficulty)
inner-stat-fields.map(field => {
let observations-source = creatures.filter(creature => (
inner-stat-value(creature, field.key) != none
))
let values = observations-source.map(creature => inner-stat-value(creature, field.key))
let mean = average(values)
let deviation = standard-deviation(values)
let observations = observations-source.map(creature => (
creature: creature,
value: inner-stat-value(creature, field.key),
z: if deviation == none or deviation == 0 { 0 } else {
(inner-stat-value(creature, field.key) - mean) / deviation
},
))
(
difficulty: difficulty,
key: field.key,
label: field.label,
average: mean,
deviation: deviation,
low-outliers: observations.filter(item => item.z <= -1.5).sorted(key: item => item.z),
high-outliers: observations.filter(item => item.z >= 1.5).sorted(key: item => -item.z),
)
})
}).flatten()
#let inner-stat-tier-outliers = inner-stat-tier-summaries.filter(item => (
item.low-outliers.len() > 0 or item.high-outliers.len() > 0
))
#let difficulty-stat-summaries = hse-profiles.map(difficulty => {
let entries = common-creatures.filter(item => item.profile-hse == difficulty)
(
difficulty: difficulty,
count: entries.len(),
strength: average(entries.map(item => item.strength)),
perception: average(entries.map(item => item.perception)),
willpower: average(entries.map(item => item.willpower)),
awareness: average(entries.map(item => item.awareness)),
alteration-resistance: average(entries.map(item => item.alteration-resistance)),
transcendental-resistance: average(entries.map(item => item.transcendental-resistance)),
torque: average(entries.map(item => item.torque)),
fatigue: average(entries.map(item => item.fatigue)),
walk: average(entries.map(item => item.walk)),
trot: average(entries.map(item => item.trot)),
run: average(entries.map(item => item.run)),
flight: average(entries.map(item => item.flight)),
p1-actions: average(entries.map(item => item.p1-action-total)),
p2-actions: average(entries.map(item => item.p2-action-total)),
p1-steps: average(entries.map(item => item.p1-initiative-steps)),
p2-steps: average(entries.map(item => item.p2-initiative-steps)),
)
})
#let reward-entries = common-creatures.map(creature => creature.rewards.map(reward => (
creature-id: creature.id,
creature: creature.name,
region: creature.region,
name: reward.name,
category: label-or(reward.category, "Non renseignée"),
family: if not present(reward.category) { "Non renseignée" } else {
reward.category.split(":").first().trim()
},
cost: reward.cost,
effect: reward.effect,
))).flatten()
#let reward-family-counts = counts(reward-entries.map(item => item.family))
#let reward-coverage-by-profile = hse-profiles.map(profile => {
let entries = common-creatures.filter(item => item.profile-hse == profile)
let rewarded = entries.filter(item => item.reward-count > 0)
(
profile: profile,
creatures: entries.len(),
rewarded: rewarded.len(),
missing: entries.len() - rewarded.len(),
rewards: entries.map(item => item.reward-count).sum(),
coverage: if entries.len() == 0 { 0% } else { rewarded.len() / entries.len() * 100% },
)
})
// The first three resistance slots are physical. The remaining ten slots are
// elemental and retain the importer order used by the creature sheet.
#let elemental-resistances = (
(key: "celestial", label: "Céleste"),
(key: "fire", label: "Feu"),
(key: "earth", label: "Terre"),
(key: "wood", label: "Bois"),
(key: "magma", label: "Magma"),
(key: "abyssal", label: "Abyssal"),
(key: "water", label: "Eau"),
(key: "wind", label: "Vent"),
(key: "ice", label: "Glace"),
(key: "thunder", label: "Foudre"),
)
#let resistance-score(value) = (
"--": -2, "-": -1, "": 0, "+": 1, "++": 2,
).at(value, default: 0)
#let resistance-family(score) = if score < 0 { "Vulnérable" } else if score > 0 {
"Résistant"
} else { "Neutre" }
#let elemental-observations = common-creatures.map(creature => (
creature.source.body-parts.map(part => range(elemental-resistances.len()).map(index => {
let element = elemental-resistances.at(index)
let raw = part.resistances.at(index + 3)
let score = resistance-score(raw)
(
creature: creature.name,
creature-id: creature.id,
profile: creature.profile-hse,
body-part: part.name,
element: element.key,
element-label: element.label,
raw: raw,
score: score,
family: resistance-family(score),
)
})).flatten()
)).flatten()
#let elemental-profile-summaries = hse-profiles.map(profile => {
let entries = elemental-observations.filter(item => item.profile == profile)
let vulnerable = entries.filter(item => item.score < 0).len()
let neutral = entries.filter(item => item.score == 0).len()
let resistant = entries.filter(item => item.score > 0).len()
let total = entries.len()
(
profile: profile,
total: total,
vulnerable: vulnerable,
neutral: neutral,
resistant: resistant,
vulnerable-share: if total == 0 { 0% } else { vulnerable / total * 100% },
neutral-share: if total == 0 { 0% } else { neutral / total * 100% },
resistant-share: if total == 0 { 0% } else { resistant / total * 100% },
average: average(entries.map(item => item.score)),
)
})
#let elemental-profile-average(profile, element) = average(
elemental-observations.filter(item => (
item.profile == profile and item.element == element
)).map(item => item.score),
)
#let region-creatures(region) = common-creatures.filter(item => item.region == region)
#let region-summaries = regions.map(region => {
let entries = region-creatures(region)
(
region: region,
count: entries.len(),
profiles: counts(entries.map(item => item.profile-hse)),
fatigue-average: average(entries.map(item => item.fatigue)),
torque-average: average(entries.map(item => item.torque)),
rewards: entries.map(item => item.reward-count).sum(),
)
})
#let subregion-summaries = subregions.map(composite => {
let parts = composite.split(" / ")
let region = parts.first()
let subregion = parts.slice(1).join(" / ")
let entries = common-creatures.filter(item => (
item.region == region and item.subregion == subregion
))
(
region: region,
subregion: subregion,
count: entries.len(),
profiles: counts(entries.map(item => item.profile-hse)),
)
})
#let profile-count(profile, region: none) = common-creatures.filter(item => (
item.profile-hse == profile and (region == none or item.region == region)
)).len()

View File

@ -0,0 +1,478 @@
// Presentation of common creature profiles, rewards, and regional difficulty.
#import "@preview/primaviz:0.6.0": (
bar-chart, box-plot, grouped-bar-chart, horizontal-bar-chart,
)
#import "creature_common_metrics.typ": *
#import "report_style.typ": chart-theme, metric-card, report-theme, rounded
#import "../theme/tables.typ" as tables
#let dash(value, digits: 1) = if value == none { [—] } else { rounded(value, digits: digits) }
#let compact-profile(profile) = (
"Lowest": "Très bas", "Low": "Bas", "Mid": "Moyen",
"High": "Haut", "Highest": "Très haut", "Non renseigné": "—",
).at(profile, default: profile)
#let short-name(name, limit: 27) = if name.clusters().len() <= limit {
name
} else {
name.clusters().slice(0, limit - 1).join() + "…"
}
#let percent(value) = str(calc.round(value / 1%)) + "%"
#let resistance-cell(value) = {
let fill = if value == none or value == 0 {
report-theme.parchment-light
} else if value > 0 {
report-theme.chart-2.transparentize(calc.max(18%, 72% - value * 18%))
} else {
report-theme.chart-1.transparentize(calc.max(18%, 72% + value * 18%))
}
table.cell(fill: fill)[#dash(value, digits: 2)]
}
#let outlier-pill(item, high: true) = box(
inset: (x: 4pt, y: 1.5pt),
radius: 4pt,
fill: (if high { report-theme.chart-2 } else { report-theme.chart-1 }).transparentize(72%),
stroke: 0.4pt + (if high { report-theme.chart-2 } else { report-theme.chart-1 }),
text(size: 6.4pt)[#item.creature.name · #rounded(item.value, digits: 1)],
)
#let outlier-list(items, high: true) = if items.len() == 0 { [—] } else {
items.map(item => outlier-pill(item, high: high)).join(h(3pt))
}
#let render-common-profile-report() = {
heading(level: 1)[Créatures — Valeurs communes]
grid(
columns: (1fr,) * 4,
column-gutter: 8pt,
metric-card("Créatures", common-creatures.len()),
metric-card("Régions", regions.len()),
metric-card("Difficultés", hse-profiles.len(), note: [niveaux représentés]),
metric-card(
"Cibles configurées",
str(configured-balancing.len()) + " / " + str(common-creatures.len()),
note: [lignes `creature_balancing`],
),
)
[Cette première couche décrit les valeurs communes telles qu’elles sont
enregistrées. Elle met en évidence les amplitudes, concentrations et données
absentes, sans encore attribuer de score de puissance ni comparer directement
les kits d’attaque des créatures.]
heading(level: 2)[Vue globale]
grid(
columns: (1fr, 1fr, 1fr, 1fr),
column-gutter: 8pt,
metric-card("Fatigue moyenne", rounded(average-fatigue, digits: 1)),
metric-card("Torque moyen", rounded(average-torque, digits: 1)),
metric-card(
"Difficulté dominante",
compact-profile(dominant-difficulty.label),
note: [#dominant-difficulty.count créatures],
),
metric-card("Niveaux", hse-profiles.len()),
)
heading(level: 3)[Caractéristiques communes]
bar-chart(
(
labels: ([Force], [Perception], [Volonté], [Rés. alt.], [Rés. trans.], [Vigilance]),
values: (
calc.round(average(common-creatures.map(item => item.strength)), digits: 1),
calc.round(average(common-creatures.map(item => item.perception)), digits: 1),
calc.round(average(common-creatures.map(item => item.willpower)), digits: 1),
calc.round(average(common-creatures.map(item => item.alteration-resistance)), digits: 1),
calc.round(average(common-creatures.map(item => item.transcendental-resistance)), digits: 1),
calc.round(average(common-creatures.map(item => item.awareness)), digits: 1),
),
),
width: 100%, height: 170pt, y-label: [Moyenne], show-values: true, theme: chart-theme,
)
heading(level: 3)[Valeurs internes atypiques]
[Une valeur est signalée lorsqu’elle se situe à au moins 1,5 écart-type de la
moyenne de la population actuelle. Ces pastilles détectent des écarts
statistiques; elles ne qualifient pas encore une valeur d’équilibrée ou
problématique.]
let stat-outlier-rows = inner-stat-summaries.map(item => (
item.label,
dash(item.average, digits: 1),
str(item.min) + "–" + str(item.max),
outlier-list(item.low-outliers, high: false),
outlier-list(item.high-outliers),
))
tables.set-table-style(
table(
columns: (0.9fr, 0.55fr, 0.55fr, 1.7fr, 1.7fr),
align: (left, right, right, left, left),
table.header([Valeur], [Moyenne], [Étendue], [Atypiques basses], [Atypiques hautes]),
..stat-outlier-rows.flatten(),
),
table-theme: "steingrund",
text-size: 6.8pt,
)
heading(level: 3)[Répartition globale normalisée]
[Chaque caractéristique est recentrée sur sa moyenne et exprimée en
écarts-types. Les boîtes montrent la médiane et les quartiles; les points
isolés suivent la règle interquartile usuelle. Cette normalisation rend
comparables des échelles aussi différentes que Force et Torque.]
box-plot(
(
labels: inner-stat-boxes.map(item => item.label),
boxes: inner-stat-boxes.map(item => (
min: item.min, q1: item.q1, median: item.median,
q3: item.q3, max: item.max, outliers: item.outliers,
)),
),
width: 100%, height: 210pt,
y-label: [Écart à la moyenne globale],
outlier-radius: 2.2pt,
theme: chart-theme,
)
heading(level: 3)[Atypiques à l’intérieur de chaque difficulté]
[Les moyennes et écarts-types sont recalculés séparément dans chaque niveau.
Les groupes ne contiennent actuellement que 4 à 7 créatures : ces alertes
locales sont utiles pour la revue, mais restent sensibles aux petits
effectifs. Seules les lignes comportant au moins une alerte sont affichées.]
if inner-stat-tier-outliers.len() == 0 {
[Aucune valeur ne dépasse ±1,5 écart-type dans son niveau de difficulté.]
} else {
let tier-outlier-rows = inner-stat-tier-outliers.map(item => (
compact-profile(item.difficulty), item.label,
dash(item.average, digits: 1),
outlier-list(item.low-outliers, high: false),
outlier-list(item.high-outliers),
))
tables.set-table-style(
table(
columns: (0.75fr, 0.85fr, 0.55fr, 1.8fr, 1.8fr),
align: (left, left, right, left, left),
table.header([Difficulté], [Valeur], [Moyenne], [Atypiques basses], [Atypiques hautes]),
..tier-outlier-rows.flatten(),
),
table-theme: "steingrund",
text-size: 6.7pt,
)
}
heading(level: 3)[Résistances élémentaires par difficulté]
[Chaque observation correspond à un couple _partie du corps × élément_. Les
signes `--`, `-`, vide, `+` et `++` sont convertis respectivement en −2, −1,
0, +1 et +2. Cette lecture sépare donc la fréquence des vulnérabilités et
résistances de leur intensité moyenne.]
let distribution-rows = elemental-profile-summaries.map(item => (
compact-profile(item.profile), str(item.total),
str(item.vulnerable) + " · " + percent(item.vulnerable-share),
str(item.neutral) + " · " + percent(item.neutral-share),
str(item.resistant) + " · " + percent(item.resistant-share),
dash(item.average, digits: 2),
))
tables.set-table-style(
table(
columns: (1fr, 0.65fr, 1fr, 1fr, 1fr, 0.75fr),
align: (left,) + (right,) * 5,
table.header([Difficulté], [Observations], [Vulnérables], [Neutres], [Résistantes], [Score moyen]),
..distribution-rows.flatten(),
),
table-theme: "steingrund",
text-size: 7pt,
)
heading(level: 3)[Score moyen par élément et difficulté]
let element-matrix = ()
for element in elemental-resistances {
element-matrix.push(element.label)
for profile in hse-profiles {
element-matrix.push(resistance-cell(elemental-profile-average(profile, element.key)))
}
}
tables.set-table-style(
table(
columns: (1.15fr,) + (0.85fr,) * hse-profiles.len(),
align: (left,) + (center,) * hse-profiles.len(),
table.header([Élément], ..hse-profiles.map(compact-profile)),
..element-matrix,
),
table-theme: "steingrund",
text-size: 7.2pt,
)
heading(level: 3)[Inventaire des difficultés]
let rows = common-creatures.map(item => (
str(item.id), item.name, item.region, compact-profile(item.profile-hse),
str(item.strength) + "/" + str(item.perception) + "/" + str(item.willpower),
str(item.alteration-resistance) + "/" + str(item.transcendental-resistance),
str(item.torque), str(item.fatigue),
str(item.walk) + "/" + str(item.trot) + "/" + str(item.run)
+ (if item.flight > 0 { "/" + str(item.flight) } else { "" }),
))
tables.set-table-style(
table(
columns: (0.28fr, 1.45fr, 0.75fr, 0.7fr, 0.72fr, 0.55fr, 0.42fr, 0.42fr, 0.8fr),
align: (right, left, left, left, center, center, right, right, center),
table.header([ID], [Créature], [Région], [Difficulté], [F/P/V], [RA/RT], [Tor.], [Fat.], [M/T/C/V]),
..rows.flatten(),
),
table-theme: "steingrund",
text-size: 6.5pt,
)
heading(level: 3)[Cibles de rythme déclarées]
let balancing-rows = common-creatures.map(item => (
item.name,
dash(item.monster-group-size), dash(item.player-group-size),
compact-profile(item.profile-hse), dash(item.time-to-armorbreak),
dash(item.time-to-p2), dash(item.time-to-kill),
dash(item.defensive-successes), dash(item.time-to-player-kill),
))
tables.set-table-style(
table(
columns: (1.45fr, 0.55fr, 0.55fr, 0.7fr, 0.65fr, 0.55fr, 0.55fr, 0.72fr, 0.65fr),
align: (left,) + (center,) * 8,
table.header([Créature], [Monstres], [Joueurs], [Difficulté], [Bris arm.], [P2], [Mort], [Déf. moy.], [Tue joueur]),
..balancing-rows.flatten(),
),
table-theme: "steingrund",
text-size: 6.4pt,
)
pagebreak(weak: true)
heading(level: 2)[Statistiques, mouvement et rythme par difficulté]
[Les valeurs suivantes sont des moyennes arithmétiques à l’intérieur de chaque
niveau. Une étape d’initiative est un élément non vide de la liste déclarée;
le nombre d’actions additionne la première valeur numérique de chaque entrée
(`3A`, `A1`, etc.).]
heading(level: 3)[Caractéristiques moyennes]
grouped-bar-chart(
(
labels: difficulty-stat-summaries.map(item => compact-profile(item.difficulty)),
series: (
(name: "Force", values: difficulty-stat-summaries.map(item => item.strength)),
(name: "Perception", values: difficulty-stat-summaries.map(item => item.perception)),
(name: "Volonté", values: difficulty-stat-summaries.map(item => item.willpower)),
(name: "Vigilance", values: difficulty-stat-summaries.map(item => item.awareness)),
),
),
width: 100%, height: 190pt, y-label: [Valeur moyenne], theme: chart-theme,
)
let stat-rows = difficulty-stat-summaries.map(item => (
compact-profile(item.difficulty), str(item.count),
dash(item.strength), dash(item.perception), dash(item.willpower), dash(item.awareness),
dash(item.alteration-resistance), dash(item.transcendental-resistance),
dash(item.torque), dash(item.fatigue),
))
tables.set-table-style(
table(
columns: (0.85fr, 0.45fr) + (0.62fr,) * 8,
align: (left,) + (right,) * 9,
table.header([Difficulté], [N], [Force], [Perc.], [Vol.], [Vig.], [R. alt.], [R. trans.], [Torque], [Fatigue]),
..stat-rows.flatten(),
),
table-theme: "steingrund", text-size: 6.8pt,
)
heading(level: 3)[Mouvement moyen]
grouped-bar-chart(
(
labels: difficulty-stat-summaries.map(item => compact-profile(item.difficulty)),
series: (
(name: "Marche", values: difficulty-stat-summaries.map(item => item.walk)),
(name: "Trot", values: difficulty-stat-summaries.map(item => item.trot)),
(name: "Course", values: difficulty-stat-summaries.map(item => item.run)),
(name: "Vol", values: difficulty-stat-summaries.map(item => item.flight)),
),
),
width: 100%, height: 190pt, y-label: [Distance moyenne], theme: chart-theme,
)
heading(level: 3)[Actions et étapes d’initiative]
grid(
columns: (1fr, 1fr),
column-gutter: 12pt,
grouped-bar-chart(
(
labels: difficulty-stat-summaries.map(item => compact-profile(item.difficulty)),
series: (
(name: "Actions P1", values: difficulty-stat-summaries.map(item => item.p1-actions)),
(name: "Actions P2", values: difficulty-stat-summaries.map(item => item.p2-actions)),
),
),
width: 100%, height: 165pt, y-label: [Actions moyennes], theme: chart-theme,
),
grouped-bar-chart(
(
labels: difficulty-stat-summaries.map(item => compact-profile(item.difficulty)),
series: (
(name: "Étapes P1", values: difficulty-stat-summaries.map(item => item.p1-steps)),
(name: "Étapes P2", values: difficulty-stat-summaries.map(item => item.p2-steps)),
),
),
width: 100%, height: 165pt, y-label: [Étapes moyennes], theme: chart-theme,
),
)
let rhythm-rows = difficulty-stat-summaries.map(item => (
compact-profile(item.difficulty), str(item.count),
dash(item.p1-actions), dash(item.p2-actions),
dash(item.p1-steps), dash(item.p2-steps),
dash(item.walk), dash(item.trot), dash(item.run), dash(item.flight),
))
tables.set-table-style(
table(
columns: (0.85fr, 0.4fr) + (0.65fr,) * 8,
align: (left,) + (right,) * 9,
table.header([Difficulté], [N], [Act. P1], [Act. P2], [Ét. P1], [Ét. P2], [Marche], [Trot], [Course], [Vol]),
..rhythm-rows.flatten(),
),
table-theme: "steingrund", text-size: 6.8pt,
)
}
#let render-common-reward-report() = {
pagebreak(weak: true)
heading(level: 2)[Récompenses et rendement]
grid(
columns: (1fr,) * 4,
column-gutter: 8pt,
metric-card("Récompenses", reward-entries.len()),
metric-card("Créatures dotées", creatures-with-rewards.len()),
metric-card("Moyenne/créature", rounded(average-rewards, digits: 2)),
metric-card("Sans récompense", creatures-without-rewards.len()),
)
[La couverture considère qu’une créature est dotée dès qu’elle possède au
moins une entrée dans `creature_rewards`. Cette section ne juge pas encore la
valeur individuelle des récompenses : elle répond d’abord à _combien_ et
_où en manque-t-il_ ?]
horizontal-bar-chart(
(
labels: reward-family-counts.map(item => item.label),
values: reward-family-counts.map(item => item.count),
),
width: 100%, height: calc.max(135pt, reward-family-counts.len() * 22pt),
title: [Familles de récompenses], show-values: true, theme: chart-theme,
)
heading(level: 3)[Couverture par difficulté]
let coverage-rows = reward-coverage-by-profile.map(item => (
compact-profile(item.profile), str(item.creatures), str(item.rewarded),
str(item.missing), percent(item.coverage), str(item.rewards),
))
tables.set-table-style(
table(
columns: (1.1fr, 0.8fr, 0.8fr, 0.8fr, 0.8fr, 0.9fr),
align: (left,) + (right,) * 5,
table.header([Difficulté], [Créatures], [Dotées], [Sans], [Couverture], [Récompenses]),
..coverage-rows.flatten(),
),
table-theme: "steingrund",
text-size: 7.2pt,
)
heading(level: 3)[Créatures sans récompense]
if creatures-without-rewards.len() == 0 {
[Toutes les créatures possèdent au moins une récompense.]
} else {
let missing-rows = creatures-without-rewards.map(item => (
str(item.id), item.name, item.region, item.subregion,
compact-profile(item.profile-hse),
))
tables.set-table-style(
table(
columns: (0.35fr, 1.75fr, 0.8fr, 1fr, 0.85fr),
align: (right, left, left, left, left),
table.header([ID], [Créature], [Région], [Sous-région], [Difficulté]),
..missing-rows.flatten(),
),
table-theme: "steingrund",
text-size: 7pt,
)
}
pagebreak()
heading(level: 3)[Nombre de récompenses par créature]
[Cette table remplace le graphique à hauteur variable. Elle conserve les
zéros, se répète proprement sur plusieurs pages et restera lisible lorsque le
bestiaire couvrira davantage de régions.]
let reward-count-rows = common-creatures.map(item => (
str(item.id), item.name, item.region, item.subregion,
compact-profile(item.profile-hse),
str(item.reward-count), if item.reward-count == 0 { [*Manquante*] } else { [Présente] },
))
tables.set-table-style(
table(
columns: (0.35fr, 1.7fr, 0.75fr, 1fr, 0.8fr, 0.65fr, 0.8fr),
align: (right, left, left, left, left, right, left),
table.header([ID], [Créature], [Région], [Sous-région], [Difficulté], [Nombre], [État]),
..reward-count-rows.flatten(),
),
table-theme: "steingrund",
text-size: 7pt,
)
}
#let render-common-region-report() = {
pagebreak(weak: true)
heading(level: 2)[Difficulté par région]
[La difficulté régionale utilise uniquement les niveaux de difficulté
déclarés. Les effectifs et leur répartition restent visibles afin qu’une
région encore peu documentée ne soit pas prise pour une référence stable.]
let region-rows = region-summaries.map(item => (
item.region, str(item.count),
compact-profile(item.profiles.first().label),
item.profiles.map(profile => compact-profile(profile.label) + " " + str(profile.count)).join(" · "),
dash(item.fatigue-average), dash(item.torque-average), str(item.rewards),
))
tables.set-table-style(
table(
columns: (1fr, 0.55fr, 0.8fr, 1.8fr, 0.7fr, 0.7fr, 0.65fr),
align: (left, right, left, left, right, right, right),
table.header([Région], [Créatures], [Difficulté dom.], [Répartition], [Fatigue], [Torque], [Récomp.]),
..region-rows.flatten(),
),
table-theme: "steingrund",
text-size: 7.2pt,
)
heading(level: 3)[Difficultés par région]
let profile-matrix = ()
for region in regions {
profile-matrix.push(region)
for profile in hse-profiles { profile-matrix.push(str(profile-count(profile, region: region))) }
}
tables.set-table-style(
table(
columns: (1.4fr,) + (0.75fr,) * hse-profiles.len(),
align: (left,) + (center,) * hse-profiles.len(),
table.header([Région], ..hse-profiles.map(compact-profile)),
..profile-matrix,
),
table-theme: "steingrund",
text-size: 7pt,
)
heading(level: 3)[Détail par sous-région]
let subregion-rows = subregion-summaries.map(item => (
item.region, item.subregion, str(item.count),
item.profiles.map(profile => compact-profile(profile.label) + " " + str(profile.count)).join(" · "),
))
tables.set-table-style(
table(
columns: (0.9fr, 1.1fr, 0.5fr, 2fr),
align: (left, left, right, left),
table.header([Région], [Sous-région], [Créat.], [Difficultés]),
..subregion-rows.flatten(),
),
table-theme: "steingrund",
text-size: 7pt,
)
}

View File

@ -0,0 +1,101 @@
// Descriptive durability aggregates. No combat conversion or target model is
// applied: values are summarized and standardized only against this dataset.
#import "creature_common_metrics.typ": (
average, common-creatures, extent, standard-deviation,
)
#let phase-aggregate(creature, phase) = {
let parts = creature.source.body-parts
let phase-parts = parts.map(part => part.at(phase))
let thresholds = phase-parts.map(part => part.threshold.base)
let protections = phase-parts.map(part => part.protection.base)
let integrities = phase-parts.map(part => part.integrity)
let lives = phase-parts.map(part => part.life)
let threshold-range = extent(thresholds)
let protection-range = extent(protections)
(
threshold-average: average(thresholds),
threshold-min: threshold-range.min,
threshold-max: threshold-range.max,
protection-average: average(protections),
protection-min: protection-range.min,
protection-max: protection-range.max,
integrity-total: integrities.sum(),
life-total: lives.sum(),
)
}
#let durability-creatures-base = common-creatures.map(creature => (
id: creature.id,
name: creature.name,
difficulty: creature.profile-hse,
region: creature.region,
parts: creature.source.body-parts.len(),
p1: phase-aggregate(creature, "p1"),
p2: phase-aggregate(creature, "p2"),
source: creature,
))
#let durability-fields = (
(key: "threshold-average", label: "Seuil moyen", profile: "Seuil"),
(key: "protection-average", label: "Protection moyenne", profile: "Protection"),
(key: "integrity-total", label: "Intégrité totale", profile: "Intégrité"),
(key: "life-total", label: "PV totaux", profile: "PV"),
)
#let phase-field-values(phase, key) = durability-creatures-base.map(item => item.at(phase).at(key))
#let durability-summary(phase, field) = {
let values = phase-field-values(phase, field.key)
let limits = extent(values)
(
phase: phase,
key: field.key,
label: field.label,
profile: field.profile,
average: average(values),
deviation: standard-deviation(values),
min: limits.min,
max: limits.max,
)
}
#let durability-summaries = ("p1", "p2").map(phase => (
durability-fields.map(field => durability-summary(phase, field))
)).flatten()
#let summary-for(phase, key) = durability-summaries.find(item => (
item.phase == phase and item.key == key
))
#let durability-zscore(item, phase, key) = {
let summary = summary-for(phase, key)
if summary.deviation == none or summary.deviation == 0 { 0 } else {
(item.at(phase).at(key) - summary.average) / summary.deviation
}
}
#let durability-signature(item, phase) = {
let scores = durability-fields.map(field => (
label: field.profile,
z: durability-zscore(item, phase, field.key),
)).sorted(key: score => -score.z)
let leader = scores.first()
if leader.z < 0.75 { "Équilibré" } else { leader.label }
}
#let durability-creatures = durability-creatures-base.map(item => item + (
p1-signature: durability-signature(item, "p1"),
p2-signature: durability-signature(item, "p2"),
))
#let average-parts = average(durability-creatures.map(item => item.parts))
#let durability-outliers = ("p1", "p2").map(phase => durability-fields.map(field => {
let summary = summary-for(phase, field.key)
let observations = durability-creatures.map(item => (
creature: item,
value: item.at(phase).at(field.key),
z: durability-zscore(item, phase, field.key),
))
(
phase: phase,
field: field,
summary: summary,
low: observations.filter(item => item.z <= -1.5).sorted(key: item => item.z),
high: observations.filter(item => item.z >= 1.5).sorted(key: item => -item.z),
)
})).flatten()

View File

@ -0,0 +1,106 @@
// Preliminary, mechanics-agnostic durability distributions and profiles.
#import "creature_durability_metrics.typ": *
#import "creature_common_report.typ": compact-profile, dash, outlier-pill, outlier-list
#import "report_style.typ": metric-card, report-theme, rounded
#import "../theme/tables.typ" as tables
#let phase-label(phase) = if phase == "p1" { "P1" } else { "P2" }
#let durability-cell(item, phase, field) = {
let z = durability-zscore(item, phase, field.key)
let accent = if z >= 0 { report-theme.chart-2 } else { report-theme.chart-1 }
let fill = if calc.abs(z) < 0.5 {
report-theme.parchment-light
} else {
accent.transparentize(calc.max(20%, 82% - calc.abs(z) * 18%))
}
table.cell(fill: fill)[#rounded(item.at(phase).at(field.key), digits: 1)]
}
#let durability-phase-table(phase) = {
let rows = ()
for item in durability-creatures {
rows.push(item.name)
rows.push(compact-profile(item.difficulty))
rows.push(str(item.parts))
for field in durability-fields { rows.push(durability-cell(item, phase, field)) }
rows.push(item.at(phase + "-signature"))
}
tables.set-table-style(
table(
columns: (1.55fr, 0.72fr, 0.42fr) + (0.72fr,) * durability-fields.len() + (0.8fr,),
align: (left, left, right) + (right,) * durability-fields.len() + (left,),
table.header(
[Créature], [Difficulté], [Parties],
..durability-fields.map(field => field.label),
[Profil relatif],
),
..rows,
),
table-theme: "steingrund",
text-size: 6.4pt,
)
}
#let render-durability-report() = {
pagebreak()
heading(level: 2)[Durabilité — Répartition préliminaire]
grid(
columns: (1fr,) * 4,
column-gutter: 8pt,
metric-card("Créatures", durability-creatures.len()),
metric-card("Parties moyennes", rounded(average-parts, digits: 1)),
metric-card("Dimensions", durability-fields.len()),
metric-card("Phases", 2, note: [P1 et P2]),
)
[Cette analyse ne simule aucun dégât et ne suppose aucune règle de ciblage.
Le Seuil et la Protection sont moyennés entre les parties du corps; leur
étendue brute reste auditée dans les données. L’Intégrité et les PV sont
additionnés afin de décrire le volume déclaré de chaque phase. Les profils
sont relatifs à la population actuelle, pas à une cible idéale.]
heading(level: 3)[Distribution des quatre dimensions]
let summary-rows = durability-summaries.map(item => (
phase-label(item.phase), item.label,
dash(item.average, digits: 1), dash(item.min, digits: 1), dash(item.max, digits: 1),
dash(item.deviation, digits: 2),
))
tables.set-table-style(
table(
columns: (0.45fr, 1.45fr, 0.75fr, 0.65fr, 0.65fr, 0.75fr),
align: (center, left, right, right, right, right),
table.header([Phase], [Dimension], [Moyenne], [Minimum], [Maximum], [Écart-type]),
..summary-rows.flatten(),
),
table-theme: "steingrund",
text-size: 7.2pt,
)
heading(level: 3)[Profils relatifs P1]
[La couleur indique l’écart à la moyenne de chaque colonne : rouge en dessous,
bleu au-dessus. Le profil retient la dimension la plus haute lorsqu’elle
dépasse +0,75 écart-type; sinon il est noté _Équilibré_.]
durability-phase-table("p1")
pagebreak(weak: true)
heading(level: 3)[Profils relatifs P2]
durability-phase-table("p2")
heading(level: 3)[Valeurs atypiques de durabilité]
[Le seuil de signalement est identique aux valeurs internes : ±1,5 écart-type.]
let outlier-rows = durability-outliers.map(item => (
phase-label(item.phase), item.field.label,
outlier-list(item.low, high: false), outlier-list(item.high),
))
tables.set-table-style(
table(
columns: (0.42fr, 1.15fr, 2fr, 2fr),
align: (center, left, left, left),
table.header([Phase], [Dimension], [Atypiques basses], [Atypiques hautes]),
..outlier-rows.flatten(),
),
table-theme: "steingrund",
text-size: 6.7pt,
)
}

View File

@ -227,6 +227,8 @@
danger-level: _text(core.danger_level).replace(".", ","),
image: _image(core),
habitat: _text(core.habitat),
region: _text(core.region),
subregion: _text(core.subregion),
dysmorphism: _text(core.dysmorphism),
colors: _text(core.colors),
human-reaction: _text(core.default_human_reaction),