// 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("#spend[", "depensez ") .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("#spend[", "dépensez ").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_neutral|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 ) })