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
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:
parent
244744ea92
commit
30c7869a01
|
|
@ -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.
|
||||
|
|
@ -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() }
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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()
|
||||
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
@ -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()
|
||||
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
@ -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),
|
||||
|
|
|
|||
Loading…
Reference in New Issue