ravenous_typst/setup/analysis/class_actions.typ

131 lines
5.7 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 action-economy classification for enabled school techniques.
#import "../generation/radar_graphs.typ": school-sources
#import "../build_config.typ": tier-is-enabled
#import "class_costs.typ": class-display-names
#let action-families = (
"Action gratuite ou générée",
"Coût en action neutre",
"Coût en action spécifique",
"Application différée",
"Passif sans coût d’action",
"Actif sans coût détecté",
)
#let normalized-action-text(text) = lower(text).replace("’", "'")
.replace("à", "a").replace("â", "a").replace("é", "e").replace("è", "e")
.replace("ê", "e").replace("ô", "o").replace("î", "i").replace("ï", "i")
.replace("ù", "u").replace("û", "u").replace("ç", "c")
#let has-pattern(text, pattern) = text.find(regex(pattern)) != none
#let action-signals(effect) = {
let text = normalized-action-text(effect)
let free = has-pattern(text,
"(?:action|attaque|parade|esquive)s? gratuites?|ne (?:coute|consomme) (?:plus |pas )?d[' ]actions?|sans (?:depenser|consommer) d[' ]?actions?|(?:gagnez|beneficiez d[' ]une) (?:aussi )?une action .{0,28}supplementaire",
)
let neutral = has-pattern(text,
"action @rl_neutre|action neutre|actions neutres",
)
let specific = has-pattern(text,
"(?:depensez|depenser|coute) (?:une|deux|trois|quatre|cinq|six|[0-9]+) actions? (?:de |d[' ])(?:mouvement|attaque|defense|replacement|deplacement)|au prix d[' ]une action (?:de |d[' ])(?:mouvement|attaque|defense|replacement|deplacement)|effectuez? (?:immediatement )?une action (?:de |d[' ])(?:mouvement|attaque|defense|replacement|deplacement)|canalis(?:ez|ee?) .{0,24}(?:sur|pendant) [0-9]+ actions?|investi(?:e|r|ssez) .{0,20}actions?",
)
let deferred = has-pattern(text,
"(?:votre |sa |la )?prochain(?:e|es)? (?:attaque|action|esquive|parade|defense|deplacement|mouvement|test|jet|reussite|tir)|(?:cette|cet) (?:attaque|action|esquive|parade|defense|deplacement|mouvement|test|jet|tir)",
)
(free: free, neutral: neutral, specific: specific, deferred: deferred)
}
#let primary-action-family(passive, signals) = {
if signals.neutral { "Coût en action neutre" }
else if signals.specific { "Coût en action spécifique" }
else if signals.free { "Action gratuite ou générée" }
else if signals.deferred { "Application différée" }
else if passive { "Passif sans coût d’action" }
else { "Actif sans coût détecté" }
}
#let reaction-action-associated(effect, signals) = {
let text = normalized-action-text(effect)
let source = lower(effect)
let explicit-conversion = (
"action", "attaque", "parade", "esquive", "defense", "deplacement", "mouvement",
).any(operation => (
text.find(operation + " devient une reaction") != none or
source.find(operation + " devient une réaction") != none
))
(
signals.free or signals.neutral or signals.specific or signals.deferred or explicit-conversion or
has-pattern(text,
"(?:action|attaque|parade|esquive|defense|deplacement|mouvement).{0,55}(?:comme|devient|en tant que) (?:une )?reaction|(?:reaction).{0,55}(?:action|attaque|parade|esquive|defense|deplacement|mouvement)",
)
)
}
#let analyze-school-actions(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"),
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 normalized-type = normalized-action-text(type-text)
let passive = has-pattern(normalized-type, "(?:^|, )pass?if(?: |$)")
let reaction = type-text.match(regex("Réaction|Reaction")) != none
let signals = action-signals(effect)
let family = primary-action-family(passive, signals)
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 { "" },
technique: first,
type: type-text,
effect: effect,
passive: passive,
reaction: reaction,
reaction-associated: if reaction { reaction-action-associated(effect, signals) } else { none },
family: family,
..signals,
))
}
records
}
#let all-school-actions = school-sources.pairs().map(pair => (
analyze-school-actions(pair.first(), pair.last())
)).flatten()
#let school-actions(class: none, tier: none, family: none, reaction: none) = all-school-actions.filter(item => (
(class == none or item.class == class) and
(tier == none or item.tier == tier) and
(family == none or item.family == family) and
(reaction == none or item.reaction == reaction)
))
#let action-family-counts = action-families.map(family => (
label: family, count: school-actions(family: family).len(),
)).filter(item => item.count > 0).sorted(key: item => -item.count)
#let reactions = school-actions(reaction: true)
#let associated-reactions = reactions.filter(item => item.reaction-associated)
#let unassociated-reactions = reactions.filter(item => not item.reaction-associated)
#let ambiguous-actions = school-actions(family: "Actif sans coût détecté")