222 lines
7.6 KiB
Plaintext
222 lines
7.6 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|é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
|
||
)
|
||
})
|