ravenous_typst/setup/analysis/class_actions.typ

222 lines
7.6 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",
"Coût hérité de l’évolution",
"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 source = lower(effect).replace("’", "'")
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 spends-actions = has-pattern(
source,
"(?:dépensez|dépenser|depensez|depenser).{0,16}(?:une|deux|trois|quatre|cinq|six|[0-9]+) actions?",
)
let specific = (
spends-actions
or has-pattern(
text,
"(?:depensez|depenser).{0,16}(?:une|deux|trois|quatre|cinq|six|[0-9]+) actions?|(?: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 )?prochainn?(?: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 inherited-evolution(level, effect) = {
let numeric-level = level.match(regex("^\\d+$"))
if numeric-level == none { false } else {
let source = lower(effect)
let inherits-wording = (
source.find(regex("aussi|également|egalement|à la place|a la place"))
!= none
)
int(numeric-level.text) >= 2 and inherits-wording
}
}
#let primary-action-family(passive, signals, inherited) = {
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 inherited {
"Coût hérité de l’évolution"
} 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 level = if columns.level < row.len() {
row.at(columns.level).trim()
} else { "" }
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 inherited = not passive and inherited-evolution(level, effect)
let family = primary-action-family(passive, signals, inherited)
records.push((
class: name,
display: class-display-names.at(name),
tier: current-tier,
level: level,
technique: first,
type: type-text,
effect: effect,
passive: passive,
reaction: reaction,
reaction-associated: if reaction {
reaction-action-associated(effect, signals)
} else { none },
family: family,
inherited-cost: inherited,
..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é")
#let ininterruptible-actions = all-school-actions.filter(item => (
item.effect.contains("@rl_ininterruptible")
))
// Suggestions only: immediacy inside a declared reaction is worth reviewing,
// but does not prove that the action should be ininterruptible.
#let ininterruptible-candidates = all-school-actions.filter(item => {
let source = lower(item.effect)
let mentions-immediacy = (
source.find(regex("immédiatement|immediatement")) != none
)
let spatial-immediacy = (
source.find(regex("situé[e]? immédiatement à")) != none
)
let unfinished = source.find(regex("wip")) != none
(
item.reaction
and not (item in ininterruptible-actions)
and mentions-immediacy
and not spatial-immediacy
and not unfinished
)
})