// 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é") #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 })