// 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 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(creature.region, "Sans région"), subregion: 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.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 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()