604 lines
19 KiB
Plaintext
604 lines
19 KiB
Plaintext
// Common, descriptive creature metrics shared by the master balance report.
|
|
#import "../generation/creature-data.typ": master-creatures
|
|
|
|
#let geography-config = yaml("/data/config/regional_map.yaml")
|
|
#let configured-regions = geography-config.at("regions", default: (:))
|
|
#let region-display-name(id) = {
|
|
let found = configured-regions.at(id, default: none)
|
|
if found == none { id } else { found.at("name", default: id) }
|
|
}
|
|
#let region-list-display(value) = if value == none { "" } else {
|
|
str(value)
|
|
.split(",")
|
|
.map(item => item.trim())
|
|
.filter(item => item != "")
|
|
.map(region-display-name)
|
|
.join(", ")
|
|
}
|
|
#let configured-cities = (
|
|
configured-regions
|
|
.pairs()
|
|
.map(region => (
|
|
region
|
|
.last()
|
|
.at("subregions", default: (:))
|
|
.pairs()
|
|
.map(city => (
|
|
id: city.first(),
|
|
name: city.last().at("name", default: city.first()),
|
|
))
|
|
))
|
|
.flatten()
|
|
)
|
|
#let city-display-name(id) = {
|
|
let found = configured-cities.find(city => city.id == id)
|
|
if found == none { id } else { found.name }
|
|
}
|
|
#let city-list-display(value) = if value == none { "" } else {
|
|
str(value)
|
|
.split(",")
|
|
.map(item => item.trim())
|
|
.filter(item => item != "")
|
|
.map(city-display-name)
|
|
.join(", ")
|
|
}
|
|
|
|
#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 calamity-types = (
|
|
"Abyssal",
|
|
"Baloth",
|
|
"Béhémoth",
|
|
"Célestial",
|
|
"Djieien",
|
|
"Dragon",
|
|
"Fenrir",
|
|
"Guivre",
|
|
"Kraken",
|
|
"Léviathan",
|
|
"Roc",
|
|
"Treant",
|
|
"Yenuï",
|
|
)
|
|
#let canonical-calamity(value) = (
|
|
"abyssal": "Abyssal",
|
|
"baloth": "Baloth",
|
|
"behemoth": "Béhémoth",
|
|
"béhémoth": "Béhémoth",
|
|
"celestial": "Célestial",
|
|
"célestial": "Célestial",
|
|
"djieien": "Djieien",
|
|
"dragon": "Dragon",
|
|
"fenrir": "Fenrir",
|
|
"guivre": "Guivre",
|
|
"kraken": "Kraken",
|
|
"leviathan": "Léviathan",
|
|
"léviathan": "Léviathan",
|
|
"roc": "Roc",
|
|
"röc": "Roc",
|
|
"treant": "Treant",
|
|
"yenouï": "Yenuï",
|
|
"yenuï": "Yenuï",
|
|
"yenui": "Yenuï",
|
|
).at(lower(str(value).trim()), default: label-or(value, "Non renseignée"))
|
|
#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(region-list-display(creature.region), "Sans région"),
|
|
region-ids: label-or(creature.region, "Sans région"),
|
|
subregion: label-or(
|
|
city-list-display(creature.subregion),
|
|
"Sans sous-région",
|
|
),
|
|
subregion-ids: label-or(creature.subregion, "Sans sous-région"),
|
|
calamity: label-or(creature.calamity, "Non renseignée"),
|
|
calamity-type: canonical-calamity(creature.calamity),
|
|
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 comma-values(value) = (
|
|
value.split(",").map(item => item.trim()).filter(item => item != "")
|
|
)
|
|
#let creature-regions(creature) = comma-values(creature.at(
|
|
"region-ids",
|
|
default: creature.region,
|
|
))
|
|
#let creature-region-pairs(creature) = {
|
|
let region-values = comma-values(creature.region)
|
|
let subregion-values = comma-values(creature.at(
|
|
"subregion-ids",
|
|
default: creature.subregion,
|
|
))
|
|
if region-values.len() > 1 and region-values.len() == subregion-values.len() {
|
|
region-values
|
|
.enumerate()
|
|
.map(pair => (
|
|
region: pair.at(1),
|
|
subregion: subregion-values.at(pair.at(0)),
|
|
))
|
|
} else {
|
|
region-values
|
|
.map(region => subregion-values.map(subregion => (
|
|
region: region,
|
|
subregion: subregion,
|
|
)))
|
|
.flatten()
|
|
}
|
|
}
|
|
#let regions = common-creatures.map(creature-regions).flatten().dedup().sorted()
|
|
#let subregions = (
|
|
common-creatures
|
|
.map(creature-region-pairs)
|
|
.flatten()
|
|
.map(item => (
|
|
region-display-name(item.region)
|
|
+ " / "
|
|
+ city-display-name(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 calamity-type-counts(entries) = calamity-types.map(type => (
|
|
label: type,
|
|
count: entries.filter(item => item.calamity-type == type).len(),
|
|
))
|
|
#let calamity-type-representation = calamity-type-counts(common-creatures).map(
|
|
item => (
|
|
item
|
|
+ (
|
|
share: if common-creatures.len() == 0 { 0% } else {
|
|
item.count / common-creatures.len() * 100%
|
|
},
|
|
)
|
|
),
|
|
)
|
|
#let calamity-types-represented = (
|
|
calamity-type-representation.filter(item => item.count > 0).len()
|
|
)
|
|
#let calamity-type-distribution(entries) = calamity-type-counts(entries).filter(
|
|
item => item.count > 0,
|
|
)
|
|
#let calamity-type-by-region = regions.map(region => {
|
|
let entries = common-creatures.filter(item => (
|
|
region in creature-regions(item)
|
|
))
|
|
(
|
|
label: region,
|
|
creatures: entries.len(),
|
|
distribution: calamity-type-distribution(entries),
|
|
)
|
|
})
|
|
#let calamity-type-by-difficulty = hse-profiles.map(profile => {
|
|
let entries = common-creatures.filter(item => item.profile-hse == profile)
|
|
(
|
|
label: profile,
|
|
creatures: entries.len(),
|
|
distribution: calamity-type-distribution(entries),
|
|
)
|
|
})
|
|
|
|
#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 => (
|
|
region in creature-regions(item)
|
|
))
|
|
#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 => (
|
|
(region: region, subregion: subregion) in creature-region-pairs(item)
|
|
))
|
|
(
|
|
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 region in creature-regions(item))
|
|
))
|
|
.len()
|
|
)
|