ravenous_typst/setup/analysis/creature_common_metrics.typ

366 lines
14 KiB
Plaintext

// 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 comma-values(value) = value.split(",").map(item => item.trim()).filter(item => item != "")
#let creature-regions(creature) = comma-values(creature.region)
#let creature-region-pairs(creature) = {
let region-values = comma-values(creature.region)
let subregion-values = comma-values(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 => (
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 => 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()