ravenous_typst/setup/analysis/creature_common_metrics.typ

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()
)