ravenous_typst/setup/analysis/class_balance_families.typ

192 lines
6.3 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// Heuristic review buckets for class-technique balancing.
#import "../generation/radar_graphs.typ": school-sources
#import "../build_config.typ": tier-is-enabled
#import "class_costs.typ": class-display-names
#let balance-families = (
(key: "bonuses", label: "Bonus de classe"),
(key: "control", label: "Contrôle et CC"),
(key: "reactions", label: "Réactions"),
(key: "defense", label: "Défense et invulnérabilité"),
)
#let normalized-balance-text(value) = lower(value).replace("’", "'")
.replace("à", "a").replace("â", "a").replace("é", "e").replace("è", "e")
.replace("ê", "e").replace("ô", "o").replace("î", "i").replace("ï", "i")
.replace("ù", "u").replace("û", "u").replace("ç", "c")
#let detects(text, pattern) = text.find(regex(pattern)) != none
#let technique-families(type-text, effect) = {
let raw-type = lower(type-text)
let type = normalized-balance-text(type-text)
let text = normalized-balance-text(effect)
let families = ()
let signals = (:)
let bonus = detects(
text,
"(?:bonus|gagnez|gagnent|beneficiez|augmentez|augmentent|ameliorez|supplementaire|\\+[0-9]+).{0,55}(?:@ca_|@rl_|degats?|reussite|seuil|test|action|fatigue|jauge|vitesse|initiative|mouvement|resistance|protection|integrite)|(?:@ca_|@rl_precision|@rl_rmax|@rl_arbreak|@rl_am).{0,28}(?:bonus|gagne|augmente|supplementaire|\\+[0-9]+)",
)
if bonus {
families.push("bonuses")
signals.insert("bonuses", "gain ou amélioration chiffrée")
}
let declared-cc = type
.split(",")
.map(item => item.trim())
.any(item => (
item == "cc" or item.starts-with("cc ")
))
let control = (
declared-cc
or detects(
text,
"@al_(?:concussif|paralysie|debilitation|rage|entrave|immobil|etourdi)|paraly|immobili|entrav|etourdi|assomm|repouss|projett|deplac.{0,20}(?:cible|adversaire|ennemi)|perd.{0,24}actions?|ne peut (?:plus )?(?:agir|se deplacer)|malus.{0,32}(?:mouvement|action|attaque|defense)",
)
)
if control {
families.push("control")
signals.insert("control", if declared-cc { "catégorie CC" } else {
"contrôle détecté dans l’effet"
})
}
let declared-reaction = (
raw-type.contains("réaction") or raw-type.contains("reaction")
)
let reaction = (
declared-reaction or detects(text, "(?:une |en tant que |comme )reaction")
)
if reaction {
families.push("reactions")
signals.insert("reactions", if declared-reaction {
"catégorie Réaction"
} else { "réaction mentionnée dans l’effet" })
}
let defense = detects(
text,
"invulner|immunis|ne (?:pouvez|peut|peuvent) (?:pas|plus) (?:etre|subir)|ignorez?.{0,30}(?:degats?|attaque)|redui(?:t|sez|sent).{0,30}(?:degats?|pertes?|dommages?)|@rl_(?:protection|integrite|resist)|protection|integrite|resistance|armure|bouclier|parade|esquive|defense|indestructible",
)
if defense {
families.push("defense")
signals.insert("defense", if detects(
text,
"invulner|immunis|indestructible",
) { "immunité ou invulnérabilité" } else { "mitigation ou défense" })
}
(families: families.dedup(), signals: signals)
}
#let analyze-school-balance-families(name, source) = {
let rows = csv(source, delimiter: "\t")
let records = ()
let current-tier = none
let columns = none
for row in rows {
if row.len() == 0 { continue }
let first = row.first().trim()
if first.starts-with("Tier") {
let digits = first.match(regex("\\d+"))
if digits != none { current-tier = int(digits.text) }
continue
}
if first == "Technique" {
columns = (
level: row.position(cell => cell.trim() == "Niv"),
type: row.position(cell => cell.trim() == "Type"),
blood: row.position(cell => cell.trim() == "Sang"),
gauge: row.position(cell => cell.trim() == "Jauge"),
effect: row.position(cell => cell.trim() == "Effet"),
)
continue
}
if (
first == ""
or current-tier == none
or columns == none
or not tier-is-enabled(current-tier)
) { continue }
if columns.type >= row.len() or columns.effect >= row.len() { continue }
let type-text = row.at(columns.type).trim()
let effect = row.at(columns.effect).trim()
let detection = technique-families(type-text, effect)
records.push((
class: name,
display: class-display-names.at(name),
tier: current-tier,
level: if columns.level < row.len() {
row.at(columns.level).trim()
} else { "" },
blood: if columns.blood != none and columns.blood < row.len() {
row.at(columns.blood).trim()
} else { "" },
gauge: if columns.gauge != none and columns.gauge < row.len() {
row.at(columns.gauge).trim()
} else { "" },
technique: first,
type: type-text,
effect: effect,
families: detection.families,
signals: detection.signals,
))
}
records
}
#let all-school-balance-techniques = (
school-sources
.pairs()
.map(pair => (
analyze-school-balance-families(pair.first(), pair.last())
))
.flatten()
)
#let balance-techniques(
family: none,
class: none,
) = all-school-balance-techniques.filter(item => (
(family == none or family in item.families)
and (class == none or item.class == class)
))
#let family-class-profile(family) = (
school-sources
.keys()
.map(name => {
let total = balance-techniques(class: name).len()
let count = balance-techniques(class: name, family: family).len()
(
class: name,
display: class-display-names.at(name),
count: count,
total: total,
share: if total == 0 { 0.0 } else { count / total * 100 },
)
})
)
#let family-extremes = balance-families.map(family => {
let profiles = family-class-profile(family.key)
let mean = profiles.map(item => item.share).sum() / profiles.len()
let deviation = calc.sqrt(
profiles.map(item => calc.pow(item.share - mean, 2)).sum() / profiles.len(),
)
let high = profiles.sorted(key: item => -item.share).first()
let low = profiles.sorted(key: item => item.share).first()
(
key: family.key,
label: family.label,
high: high,
low: low,
mean: mean,
deviation: deviation,
high-outlier: deviation > 0 and high.share >= mean + deviation,
low-outlier: deviation > 0 and low.share <= mean - deviation,
total: balance-techniques(family: family.key).len(),
)
})