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