From 30c7869a01ff43e4ae0188e5b3bb454070fef4f2 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Sat, 22 Aug 2026 20:09:30 +0200 Subject: [PATCH] Reporting on monsters --- README.md | 53 ++ balance_report_master.typ | 65 +++ data/config/balance_report_master.yaml | 8 + data/config/build.yaml | 2 +- data/src/db | 2 +- setup/analysis/creature_common_metrics.typ | 348 +++++++++++++ setup/analysis/creature_common_report.typ | 478 ++++++++++++++++++ .../analysis/creature_durability_metrics.typ | 101 ++++ setup/analysis/creature_durability_report.typ | 106 ++++ setup/generation/creature-data.typ | 2 + 10 files changed, 1163 insertions(+), 2 deletions(-) create mode 100644 README.md create mode 100644 balance_report_master.typ create mode 100644 data/config/balance_report_master.yaml create mode 100644 setup/analysis/creature_common_metrics.typ create mode 100644 setup/analysis/creature_common_report.typ create mode 100644 setup/analysis/creature_durability_metrics.typ create mode 100644 setup/analysis/creature_durability_report.typ diff --git a/README.md b/README.md new file mode 100644 index 0000000..ee3f838 --- /dev/null +++ b/README.md @@ -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. diff --git a/balance_report_master.typ b/balance_report_master.typ new file mode 100644 index 0000000..1affc0b --- /dev/null +++ b/balance_report_master.typ @@ -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() } diff --git a/data/config/balance_report_master.yaml b/data/config/balance_report_master.yaml new file mode 100644 index 0000000..3e7917e --- /dev/null +++ b/data/config/balance_report_master.yaml @@ -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 diff --git a/data/config/build.yaml b/data/config/build.yaml index 880b39d..55b4498 100644 --- a/data/config/build.yaml +++ b/data/config/build.yaml @@ -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. diff --git a/data/src/db b/data/src/db index e7bb093..a557d9c 160000 --- a/data/src/db +++ b/data/src/db @@ -1 +1 @@ -Subproject commit e7bb093a505ac281921e0604ec64888c5caf0a70 +Subproject commit a557d9cd9e19e571da29871fd28626215370b02e diff --git a/setup/analysis/creature_common_metrics.typ b/setup/analysis/creature_common_metrics.typ new file mode 100644 index 0000000..b077a80 --- /dev/null +++ b/setup/analysis/creature_common_metrics.typ @@ -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() diff --git a/setup/analysis/creature_common_report.typ b/setup/analysis/creature_common_report.typ new file mode 100644 index 0000000..76bd69a --- /dev/null +++ b/setup/analysis/creature_common_report.typ @@ -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, + ) +} diff --git a/setup/analysis/creature_durability_metrics.typ b/setup/analysis/creature_durability_metrics.typ new file mode 100644 index 0000000..1c2dbfa --- /dev/null +++ b/setup/analysis/creature_durability_metrics.typ @@ -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() diff --git a/setup/analysis/creature_durability_report.typ b/setup/analysis/creature_durability_report.typ new file mode 100644 index 0000000..eaa5354 --- /dev/null +++ b/setup/analysis/creature_durability_report.typ @@ -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, + ) +} diff --git a/setup/generation/creature-data.typ b/setup/generation/creature-data.typ index 7d63e77..5d8b90c 100644 --- a/setup/generation/creature-data.typ +++ b/setup/generation/creature-data.typ @@ -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),