161 lines
7.2 KiB
Plaintext
161 lines
7.2 KiB
Plaintext
// 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|à 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
|
||
})
|