ravenous_typst/setup/analysis/creature_advanced_metrics.typ

382 lines
18 KiB
Plaintext

// Creature-by-creature combat metrics compatible with rust_base/monsters.
// Quirks from the reference implementation are intentionally isolated here so
// a future corrected model can coexist without changing report presentation.
#import "../generation/creature-data.typ": master-creatures, player-balancing-rows
#let compatibility-model = "rust_base"
#let clamp(value, minimum, maximum) = calc.min(calc.max(value, minimum), maximum)
#let number(value, fallback: 0) = if value == none or value == "" { fallback } else { int(str(value)) }
#let tagged-number(value, suffix) = if value == none or value == "" { 0 } else {
let cleaned = str(value).replace(suffix, "").trim()
if cleaned.match(regex("^-?\\d+$")) == none { 0 } else { int(cleaned) }
}
#let damage-vector(value) = if value == none or value == "" { () } else {
let cleaned = str(value).trim()
// Rust collects parsed segments through Option<Vec<_>>: one malformed
// segment invalidates the complete damage profile instead of aborting.
if cleaned.match(regex("^-?\\d+(?:/-?\\d+)*$")) == none { () } else {
cleaned.split("/").map(int)
}
}
#let category-or(value, fallback) = if value == none or value == "" { fallback } else { str(value) }
#let binomial-distribution(threshold, dice) = {
if dice <= 0 { return ((successes: 0, probability: 1.0),) }
let probability = clamp(threshold / 10, 0.0000000001, 0.9999999999)
range(dice + 1).map(successes => (
successes: successes,
probability: calc.binom(dice, successes)
* calc.pow(probability, successes)
* calc.pow(1 - probability, dice - successes),
))
}
#let damage-at-successes(profile, successes) = {
if successes <= 0 or profile.len() == 0 { 0 } else {
profile.at(clamp(successes - 1, 0, profile.len() - 1))
}
}
#let expected-damage(profile, threshold, dice) = binomial-distribution(threshold, dice).map(item => (
damage-at-successes(profile, item.successes) * item.probability
)).sum()
#let resistance-value(value) = if value == none { 0 } else {
str(value).clusters().map(char => if char == "+" { 2 } else if char == "-" { -2 } else { 0 }).sum()
}
#let worst-physical-resistance(part) = calc.min(
resistance-value(part.slash), resistance-value(part.blunt), resistance-value(part.piercing),
)
#let safe-ratio(numerator, denominator) = if denominator == 0 { none } else { numerator / denominator }
#let safe-sum(values) = if none in values { none } else { values.sum() }
#let rust-ratio(numerator, denominator) = if denominator == 0 and numerator == 0 {
(kind: "nan", value: none)
} else if denominator == 0 {
(kind: "infinite", value: none)
} else { (kind: "finite", value: numerator / denominator) }
#let rust-sum(values) = if values.any(item => item.kind == "nan") {
"NaN"
} else if values.any(item => item.kind == "infinite") {
none
} else { values.map(item => item.value).sum() }
#let damage-category(percent) = {
if percent < 0.01 { "None" }
else if percent < 0.25 { "Chip" }
else if percent < 0.5 { "Moderate" }
else if percent < 0.8 { "High" }
else if percent < 1.0 { "NearDeath" }
else if percent < 1.5 { "Kill" }
else { "Overkill" }
}
// The overlapping 0.5..0.9 and 0.8..1.2 Rust ranges resolve at 0.9 because
// match arms are evaluated in order.
#let armor-category(percent) = {
if percent < 0.01 { "None" }
else if percent < 0.3 { "Chip" }
else if percent < 0.5 { "Moderate" }
else if percent < 0.9 { "High" }
else if percent < 1.2 { "FullBreak" }
else { "Overkill" }
}
#let profile-damage-to-part(part, player, parried, phase, creature-strength) = {
let threshold = part.at("threshold_" + phase) + player.precision
let protection = part.at("protection_" + phase)
let resistance = worst-physical-resistance(part)
// Rust uses 1..max_successes_off (exclusive upper bound).
let damage-profile = range(1, player.max_successes_off).map(value => int(value * player.damage_per_s))
let dice = clamp(player.successes_off - parried, 0, player.successes_off)
let damage-a = calc.max(expected-damage(damage-profile, threshold, dice) - resistance, 0)
let damage-b1 = calc.max(expected-damage(damage-profile, threshold, calc.floor(dice / 2)) - resistance, 0)
let damage-b2 = calc.max(expected-damage(damage-profile, threshold, dice - calc.floor(dice / 2)) - resistance, 0)
let through-a = calc.max(damage-a - protection - creature-strength, 0)
let through-b1 = calc.max(damage-b1 - protection - creature-strength, 0)
let through-b2 = calc.max(damage-b2 - protection - creature-strength, 0)
let ab-a = clamp(damage-a - protection, 0, player.armor_break)
let ab-b1 = clamp(damage-b1 - protection, 0, player.armor_break)
let ab-b2 = clamp(damage-b2 - protection, 0, player.armor_break)
(
hp: calc.max(damage-a, damage-b1 + damage-b2),
armor: calc.max(ab-a, ab-b1 + ab-b2),
through: calc.max(through-a, through-b1 + through-b2),
)
}
#let scaled-damage(value, factor) = (
hp: value.hp * factor, armor: value.armor * factor, through: value.through * factor,
)
#let add-damage(left, right) = (
hp: left.hp + right.hp, armor: left.armor + right.armor, through: left.through + right.through,
)
#let player-profiles(profile-hse) = player-balancing-rows.filter(row => row.profile_hse == profile-hse)
#let player-profile(profile-hse, stance) = player-profiles(profile-hse).find(row => row.profile_stance == stance)
#let defense-row(creature, part, stance, showcase) = {
let balancing = creature.raw.balancing.first()
let player = player-profile(balancing.profile_hse, stance)
let remaining-defense = balancing.average_defensive_successes
let total-p1 = (hp: 0.0, armor: 0.0, through: 0.0)
let total-p2 = (hp: 0.0, armor: 0.0, through: 0.0)
let remaining-players = balancing.player_groupsize
while remaining-players > 0 {
let chunk = calc.min(remaining-players, 1.0)
let parried = calc.min(remaining-defense, player.successes_off)
let p1 = profile-damage-to-part(part, player, parried, "p1", creature.stats.strength)
let p2 = profile-damage-to-part(part, player, parried, "p2", creature.stats.strength)
total-p1 = add-damage(total-p1, scaled-damage(p1, chunk))
total-p2 = add-damage(total-p2, scaled-damage(p2, chunk))
remaining-defense = calc.max(remaining-defense - parried, 0)
remaining-players -= chunk
}
let time-p1 = safe-ratio(part.life_points_p1, total-p1.hp)
let time-p2 = safe-ratio(part.life_points_p2, total-p2.hp)
let through-p1 = calc.max(total-p1.through - creature.stats.strength, 0)
let through-p2 = calc.max(total-p2.through - creature.stats.strength, 0)
(
part: part.body_part_name,
stance: stance,
showcase: showcase,
armor-per-turn: total-p1.armor,
integrity-p1: part.integrity_p1,
time-armor: safe-ratio(part.integrity_p1, total-p1.armor),
target-armor: balancing.time_to_armorbreak,
damage-p1: total-p1.hp,
health-p1: part.life_points_p1,
time-p1: time-p1,
target-p1: balancing.time_to_p2,
damage-p2: total-p2.hp,
health-p2: part.life_points_p2,
time-p2: time-p2,
target-p2: balancing.time_to_kill,
through-p1: total-p1.through,
through-p2: total-p2.through,
time-through: rust-sum((
rust-ratio(part.life_points_p1, through-p1),
rust-ratio(part.life_points_p2, through-p2),
)),
)
}
#let creature-defense-report(creature, show-extra: true) = creature.raw.body-parts.map(part => {
let stances = if show-extra {
((stance: "Neutral", showcase: "Display"), (stance: "Defensive", showcase: "Balancing"), (stance: "Offensive", showcase: "Balancing"))
} else { ((stance: "Neutral", showcase: "Display"),) }
stances.map(item => defense-row(creature, part, item.stance, item.showcase))
}).flatten()
#let attack-report(attack, player, showcase) = {
// Compatibility quirk: Best and Worst both use max(parry, dodge).
let threshold = calc.max(number(attack.threshold_parry), number(attack.threshold_dodge)) + player.specialty_def
let successes = tagged-number(attack.success, "r")
let distribution = binomial-distribution(threshold, player.successes_def)
let successes-left = distribution.map(item => (successes - item.successes) * item.probability).sum()
let damage = damage-vector(attack.damage_regular)
let incoming = distribution.map(item => (
damage-at-successes(damage, successes - item.successes) * item.probability
)).sum()
let tanked = calc.max(incoming - player.protection - player.strength, 0)
let armor-loss = clamp(incoming - player.protection, 0, number(attack.armor_break))
(
attack-id: attack.attack_id,
name: attack.name,
attack-type: category-or(attack.attack_type, "—"),
phase: attack.phase,
stance: player.profile_stance,
showcase: showcase,
incoming: incoming,
fatigue: tagged-number(attack.damage_fatigue, "F"),
successes-left: successes-left,
threshold: threshold,
attack-successes: successes,
tanked: tanked,
health: player.health,
damage-category: damage-category(tanked / player.health),
damage-expected: {
let expected = category-or(attack.target_damage_category, "Malformed")
if expected in ("Malformed", "None", "Chip", "Moderate", "High", "NearDeath", "Kill", "Overkill") {
expected
} else { "Malformed" }
},
armor-loss: armor-loss,
integrity: player.integrity,
armor-category: armor-category(armor-loss / player.integrity),
armor-expected: {
let expected = category-or(attack.target_ab_category, "Malformed")
if expected in ("Malformed", "None", "Chip", "Moderate", "High", "FullBreak", "Overkill") {
expected
} else { "Malformed" }
},
)
}
#let creature-attack-report(creature, show-extra: true, show-balanced: true) = {
let balancing = creature.raw.balancing.first()
let profiles = player-profiles(balancing.profile_hse)
creature.raw.abilities.filter(attack => damage-vector(attack.damage_regular).len() > 0).map(attack => {
let target-stance = category-or(attack.target_stance, "Neutral")
let target = profiles.find(player => player.profile_stance == target-stance)
let balancing-row = attack-report(attack, target, "Balancing")
let rows = if show-balanced or balancing-row.damage-category != balancing-row.damage-expected or balancing-row.armor-category != balancing-row.armor-expected {
(balancing-row,)
} else { () }
if show-extra {
rows += profiles.filter(player => player.profile_stance != target-stance).map(player => attack-report(attack, player, "Display"))
}
rows
}).flatten()
}
#let category-rank(category) = (
None: 0, Chip: 1, Moderate: 2, High: 3, NearDeath: 4, Kill: 5, Overkill: 6, Malformed: -1,
).at(category, default: -1)
#let attack-type-labels = (
ATK: "Attaque", TRA: "Thrashing", TBU: "Tank buster", TBZ: "Tank buster zone",
WIP: "Raid wipe", WID: "Raid-wide", AOE: "AOE", CLV: "Cleave", CMB: "Combo",
FLR: "Flurry", GRB: "Saisie", BYP: "Bypass", TSH: "Tank shred", ASE: "Setup",
BIS: "Best action", BAD: "Bad action",
)
#let deterministic-hit(attack, player, remaining-successes) = {
let incoming = damage-at-successes(damage-vector(attack.damage_regular), remaining-successes)
let tanked = calc.max(incoming - player.protection - player.strength, 0)
(
incoming: incoming,
tanked: tanked,
ratio: tanked / player.health,
category: damage-category(tanked / player.health),
survives: tanked < player.health,
)
}
#let defense-required-to-survive(attack, player) = {
let successes = tagged-number(attack.success, "r")
let found = range(successes + 1).find(defended => (
deterministic-hit(attack, player, calc.max(successes - defended, 0)).survives
))
if found == none { successes + 1 } else { found }
}
#let survival-probability(attack, player, required) = {
let threshold = calc.max(number(attack.threshold_parry), number(attack.threshold_dodge)) + player.specialty_def
let outcomes = binomial-distribution(threshold, player.successes_def).filter(item => item.successes >= required)
if outcomes.len() == 0 { 0.0 } else { outcomes.map(item => item.probability).sum() }
}
#let attack-group-members(creature, attack) = {
let group = if attack.attack_group == none { "" } else { str(attack.attack_group).trim() }
if group == "" { (attack,) } else {
creature.raw.abilities.filter(item => (
item.phase == attack.phase
and item.attack_group != none
and str(item.attack_group).trim() == group
and damage-vector(item.damage_regular).len() > 0
))
}
}
#let diagnostic-base(creature, attack) = {
let balancing = creature.raw.balancing.first()
let profiles = player-profiles(balancing.profile_hse)
let target-stance = category-or(attack.target_stance, "Neutral")
let target = profiles.find(profile => profile.profile_stance == target-stance)
let successes = tagged-number(attack.success, "r")
let one = deterministic-hit(attack, target, 1)
let two = deterministic-hit(attack, target, calc.min(2, successes))
let maximum = deterministic-hit(attack, target, successes)
let survival = profiles.map(profile => (
stance: profile.profile_stance,
..deterministic-hit(attack, profile, successes),
))
let survivors = survival.filter(item => item.survives).len()
let required = defense-required-to-survive(attack, target)
let threshold = calc.max(number(attack.threshold_parry), number(attack.threshold_dodge)) + target.specialty_def
let group = attack-group-members(creature, attack)
let group-successes = group.map(item => tagged-number(item.success, "r")).sorted().rev()
let expected = attack-report(attack, target, "Balancing")
(
creature-id: creature.id,
creature: creature.name,
difficulty: balancing.profile_hse,
attack-id: attack.attack_id,
name: attack.name,
phase: attack.phase,
group: if attack.attack_group == none or str(attack.attack_group).trim() == "" { "—" } else { str(attack.attack_group) },
group-size: group.len(),
group-rank: group-successes.position(value => value == successes) + 1,
declared-type: category-or(attack.attack_type, "—"),
declared-label: attack-type-labels.at(category-or(attack.attack_type, ""), default: category-or(attack.attack_type, "—")),
target-stance: target-stance,
successes: successes,
threshold: threshold,
defense-required: required,
defense-dice: target.successes_def,
survival-probability: survival-probability(attack, target, required),
one: one,
two: two,
maximum: maximum,
survivors: survivors,
profile-count: profiles.len(),
survival: survival,
expected-category: expected.damage-category,
)
}
#let all-diagnostic-bases = master-creatures.map(creature => creature.raw.abilities.filter(attack => (
damage-vector(attack.damage_regular).len() > 0
)).map(attack => diagnostic-base(creature, attack))).flatten()
#let diagnostic-cohort(item) = all-diagnostic-bases.filter(other => other.difficulty == item.difficulty)
#let diagnostic-average(values) = if values.len() == 0 { none } else { values.sum() / values.len() }
#let diagnostic-deviation(values) = if values.len() < 2 { 0 } else {
let mean = diagnostic-average(values)
calc.sqrt(values.map(value => calc.pow(value - mean, 2)).sum() / values.len())
}
#let heuristic-tags(item) = {
let tags = ()
let max-rank = category-rank(item.maximum.category)
let expected-rank = category-rank(item.expected-category)
if item.survivors == 0 or item.maximum.ratio >= 2 { tags.push("Nuke") }
if (
item.survival.find(profile => profile.stance == "Defensive").survives
and item.survivors <= calc.max(2, calc.floor(item.profile-count / 2))
and max-rank >= category-rank("Kill")
) { tags.push("Tank buster") }
if max-rank >= category-rank("Kill") and expected-rank <= category-rank("Moderate") {
tags.push("Contrôle de défense")
}
if item.one.ratio < 0.25 and item.maximum.ratio < 1 and item.maximum.ratio >= 0.25 {
tags.push("Thrashing")
}
if item.one.ratio < 0.25 and item.two.ratio >= 0.25 { tags.push("Pression progressive") }
if item.one.ratio >= 1 { tags.push("Exécution immédiate") }
if item.defense-required >= 3 { tags.push("Défense en profondeur") }
if item.threshold <= 5 and item.defense-required > 0 { tags.push("Défense difficile") }
if item.maximum.ratio < 0.25 { tags.push("Faible menace directe") }
if tags.len() == 0 { tags.push("Pression standard") }
tags
}
#let attack-diagnostics = all-diagnostic-bases.map(item => {
let cohort = diagnostic-cohort(item)
let success-values = cohort.map(other => other.successes)
let threshold-values = cohort.map(other => other.threshold)
let success-deviation = diagnostic-deviation(success-values)
let threshold-deviation = diagnostic-deviation(threshold-values)
item + (
success-z: if success-deviation == 0 { 0 } else { (item.successes - diagnostic-average(success-values)) / success-deviation },
threshold-z: if threshold-deviation == 0 { 0 } else { (item.threshold - diagnostic-average(threshold-values)) / threshold-deviation },
tags: heuristic-tags(item),
)
})
#let creature-attack-diagnostics(creature-id) = attack-diagnostics.filter(item => item.creature-id == creature-id)
#let advanced-creature-analysis(creature, show-extra: true, show-balanced: true) = (
creature: creature,
model: compatibility-model,
defense: creature-defense-report(creature, show-extra: show-extra),
attacks: creature-attack-report(creature, show-extra: show-extra, show-balanced: show-balanced),
diagnostics: creature-attack-diagnostics(creature.id),
)
#let advanced-analysis(creature-ids: (), show-extra: true, show-balanced: true) = master-creatures.filter(creature => (
creature-ids.len() == 0 or creature.id in creature-ids
)).map(creature => advanced-creature-analysis(
creature, show-extra: show-extra, show-balanced: show-balanced,
))