// Heuristic elemental metrics extracted from the craft TSV portfolio. #import "../build_config.typ": craft-tiers, tier-is-enabled #let craft-sources = ( ( craft: "Alchimie", label: "Réagents", source: "/data/src/craft/alchemy_reagents.tsv", name: "Réagents", tier: "@ar_tier", effects: ("Effet (Principal)",), ), ( craft: "Alchimie", label: "Solvants", source: "/data/src/craft/alchemy_solvants.tsv", name: "Solvants", tier: "@ar_tier", effects: ("Effet",), ), ( craft: "Alchimie", label: "Transmutations", source: "/data/src/craft/alchemy_transmutations.tsv", name: "Transmutation", tier: "@ar_tier", effects: ("Effet",), ), ( craft: "Brasserie", label: "Ferments", source: "/data/src/craft/brewry_ferments.tsv", name: "Ferment", tier: "@ar_tier", effects: (), ), ( craft: "Brasserie", label: "Finitions", source: "/data/src/craft/brewry_finishing.tsv", name: "Ferment", tier: "@ar_tier", effects: ("Effet",), ), ( craft: "Brasserie", label: "Effets principaux", source: "/data/src/craft/brewry_main_effects.tsv", name: "Nom", tier: "@ar_tier", effects: ("Effet",), ), ( craft: "Brasserie", label: "Méthodes", source: "/data/src/craft/brewry_methods.tsv", name: "Méthode", tier: none, effects: (), ), ( craft: "Brasserie", label: "Effets secondaires", source: "/data/src/craft/brewry_secondary_effects.tsv", name: "Nom", tier: "@ar_tier", effects: ("Effet",), ), ( craft: "Forge", label: "Finitions", source: "/data/src/craft/forge_finishing.tsv", delimiter: "\t", name: "Nom de la finition", tier: "@ar_tier:short", effects: ("Effet",), ), ( craft: "Forge", label: "Matériaux", source: "/data/src/craft/forge_materials.tsv", delimiter: "\t", name: "Matériau", tier: "@ar_tier:short", effects: ("Effets sur les Armes", "Effet sur les Armures et Boucliers"), ), ( craft: "Restauration", label: "Ingrédients", source: "/data/src/craft/restoration_main.tsv", name: "Ingrédient", tier: "@ar_tier", effects: ("Effet",), ), ( craft: "Restauration", label: "Assaisonnements", source: "/data/src/craft/restoration_seasoning.tsv", name: "Nom", tier: "@ar_tier", effects: ("Effet",), ), ( craft: "Restauration", label: "Accompagnements", source: "/data/src/craft/restoration_sides.tsv", name: "Accompagnement", tier: "@ar_tier", effects: ("Effet",), ), ( craft: "Pièges", label: "Pièges", source: "/data/src/craft/traps.tsv", name: "Type", tier: "@ar_tier:short", effects: ("Effet",), ), ) #let craft-order = ("Alchimie", "Brasserie", "Forge", "Restauration", "Pièges") #let context-order = ("Dégâts", "Résistance", "Accès", "Autre") #let element-definitions = ( (key: "fire", label: "Feu"), (key: "ice", label: "Glace"), (key: "lightning", label: "Foudre"), (key: "water", label: "Eau"), (key: "wind", label: "Vent"), (key: "earth", label: "Terre"), (key: "wood", label: "Bois"), (key: "magma", label: "Magma"), (key: "celestial", label: "Céleste"), (key: "abyssal", label: "Abyssal"), (key: "slash", label: "Tranchant"), (key: "pierce", label: "Perçant"), (key: "blunt", label: "Contondant"), (key: "physical", label: "Physique gén."), (key: "elementary", label: "Élémentaire gén."), (key: "neutral", label: "Neutre"), (key: "pure", label: "Pur"), ) #let effect-context(text) = { let lowered = lower(text) if "@el_acces" in lowered or "accès à l'élément" in lowered { "Accès" } else if "résist" in lowered or "resist" in lowered { "Résistance" } else if ( "dégât" in lowered or "dégat" in lowered or "degat" in lowered or "#change(\"damage\"" in lowered or "#change(\"physical_damage\"" in lowered or "#change(\"elemental_damage\"" in lowered ) { "Dégâts" } else { "Autre" } } #let configured-craft-rows(definition) = csv( definition.source, delimiter: definition.at( "delimiter", default: if definition.source.ends-with(".tsv") { "\t" } else { "," }, ), row-type: dictionary, ).filter(row => { if definition.tier == none { true } else { let raw = row.at(definition.tier, default: "") let found = raw.match(regex("-?\d+")) found == none or tier-is-enabled(int(found.text)) } }) #let clause-elements(clause) = { let lowered = lower(clause) let found = element-definitions.filter(element => ( "@el_" + element.key in lowered )) if found.len() == 0 and "physique" in lowered { found.push(element-definitions.find(element => element.key == "physical")) } if found.len() == 0 and "élémentaire" in lowered { found.push(element-definitions.find(element => ( element.key == "elementary" ))) } found } #let analyze-craft-source(definition) = { let rows = configured-craft-rows(definition) let mentions = () for row in rows { for effect-key in definition.effects { let effect = row.at(effect-key, default: "") for semicolon-clause in effect.split(";") { for clause in semicolon-clause.split(".") { let cleaned = clause.trim() for element in clause-elements(cleaned) { mentions.push(( craft: definition.craft, dataset: definition.label, item: row.at(definition.name, default: "—"), tier: if definition.tier == none { none } else { row.at(definition.tier, default: none) }, element: element.label, key: element.key, role: effect-context(cleaned), raw: cleaned, )) } } } } } (definition: definition, entries: rows.len(), mentions: mentions) } #let all-craft-data = craft-sources.map(analyze-craft-source) #let all-craft-mentions = all-craft-data.map(data => data.mentions).flatten() #let field-number(row, keys) = { for key in keys { let raw = row.at(key, default: none) if raw != none { let found = raw.match(regex("-?\\d+")) if found != none { return int(found.text) } } } none } // Exhaustive macro inventory. Unlike the semantic heuristics below, this // deliberately retains every @rl_* and @ca_* reference, including unknown // future macros, plus the elemental-access macro used as a mechanic. #let rule-reference-labels = ( el_acces: "Accès élémentaire", rl_am: "Antimatériel", rl_arbreak: "Brise-armure", rl_tear: "Arracher", rl_fatigue: "Fatigue", rl_toxin_jauge: "Jauge de toxine", rl_armor_pierce: "Perce-armure", rl_protection: "Protection", rl_rmax: "R.Max", rl_satiete: "Satiété", rl_transcendence_threshold: "Seuil de transcendance", ca_torque: "Torque", ca_secondary: "Caractéristiques secondaires", ) #let analyze-rule-references(definition) = { let records = () for row in configured-craft-rows(definition) { let tier = if definition.tier == none { none } else { let found = row.at(definition.tier, default: "").match(regex("-?\\d+")) if found == none { none } else { int(found.text) } } let constraints = ( cost: field-number(row, ("@ar_cst", "@ar_cst:short", "Coût")), level: field-number(row, ("@ar_lvl", "@ar_lvl:short")), toxicity: field-number(row, ("@ar_tox", "Toxicité")), endurance: field-number(row, ("@ar_end", "@ar_end:short")), ) for (field, value) in row { let raw = str(value) let searchable = lower(field + " " + raw) for reference in searchable.matches(regex("@(rl|ca|el)_([a-z_]+)")) { let family = reference.captures.at(0) let key = reference.captures.at(1) let macro = family + "_" + key if family != "el" or key == "acces" { records.push(( craft: definition.craft, dataset: definition.label, item: row.at(definition.name, default: "—"), tier: tier, family: family, key: key, macro: macro, label: rule-reference-labels.at(macro, default: "@" + macro), field: field, raw: raw, ..constraints, )) } } let structured-references = ( rmax: (family: "rl", key: "rmax"), armor_break: (family: "rl", key: "arbreak"), armor_pierce: (family: "rl", key: "parmure"), protection: (family: "rl", key: "protection"), torque: (family: "ca", key: "torque"), ) for change in searchable.matches(regex("#change\\(\"([a-z_]+)\"")) { let kind = change.captures.first() if kind in structured-references { let reference = structured-references.at(kind) let macro = reference.family + "_" + reference.key records.push(( craft: definition.craft, dataset: definition.label, item: row.at(definition.name, default: "—"), tier: tier, family: reference.family, key: reference.key, macro: macro, label: rule-reference-labels.at(macro, default: "@" + macro), field: field, raw: raw, ..constraints, )) } } } } records } #let all-craft-rule-references = ( craft-sources.map(analyze-rule-references).flatten() ) #let rule-reference-counts = { let macros = all-craft-rule-references.map(item => item.macro).dedup() macros .map(macro => { let records = all-craft-rule-references.filter(item => ( item.macro == macro )) let tiers = records .map(item => item.tier) .filter(value => value != none) .sorted() ( macro: macro, label: records.first().label, family: records.first().family, count: records.len(), crafts: records.map(item => item.craft).dedup().sorted(), first-tier: if tiers.len() == 0 { none } else { tiers.first() }, last-tier: if tiers.len() == 0 { none } else { tiers.last() }, ) }) .sorted(key: item => -item.count) } #let craft-entry-count(craft: none) = ( all-craft-data .filter(data => craft == none or data.definition.craft == craft) .map(data => data.entries) .sum() ) #let selected-mentions( craft: none, role: none, element: none, tier: none, ) = all-craft-mentions.filter(mention => ( (craft == none or mention.craft == craft) and (role == none or mention.role == role) and (element == none or mention.element == element) and (tier == none or mention.tier == str(tier)) )) #let element-counts(role: none) = ( element-definitions .map(element => ( label: element.label, count: selected-mentions(role: role, element: element.label).len(), )) .filter(item => item.count > 0) ) #let tier-counts(role: none) = craft-tiers.map(tier => ( tier: tier, count: selected-mentions(role: role, tier: tier).len(), )) #let ranked-elements(role) = element-counts(role: role).sorted(key: item => { -item.count }) #let coverage-gap(from-role, against-role) = ( element-counts(role: from-role) .filter(item => ( selected-mentions(role: against-role, element: item.label).len() == 0 )) .map(item => item.label) ) #let ranked-crafts(role) = ( craft-order .map(craft => ( label: craft, count: selected-mentions(craft: craft, role: role).len(), )) .sorted(key: item => -item.count) ) #let ranked-tiers(role) = tier-counts(role: role).sorted(key: item => { -item.count }) #let ranked-craft-breadth = ( craft-order .map(craft => ( label: craft, count: element-definitions .filter(element => ( selected-mentions(craft: craft, element: element.label).len() > 0 )) .len(), )) .sorted(key: item => -item.count) ) #let versatile-elements = ( element-definitions .map(element => { let damage = selected-mentions( role: "Dégâts", element: element.label, ).len() let resistance = selected-mentions( role: "Résistance", element: element.label, ).len() ( label: element.label, damage: damage, resistance: resistance, overlap: calc.min(damage, resistance), total: damage + resistance, ) }) .filter(item => item.overlap > 0) .sorted( key: item => -(item.overlap * 1000 + item.total), ) ) // Secondary heuristic axis: effect families and their balancing constraints. #let mechanic-order = ( "Actions", "Fatigue", "Caractéristiques", "PV", "R.Max", "Torque", "Accès élémentaire", "Altérations", "Marques", "Réserve active", ) #let mark-types = ("poison", "saignement", "regeneration", "corrosif") #let clause-mechanics(clause) = { let lowered = lower(clause) let categories = () let alterations = lowered.matches(regex("@al_([a-z_]+)")) let is-marks = "marque" in lowered and alterations.len() > 0 if "action" in lowered { categories.push((category: "Actions", subtype: none)) } if "fatigue" in lowered { categories.push((category: "Fatigue", subtype: none)) } if ( "dés de la réserve active" in lowered or "dés de la reserve active" in lowered ) { categories.push((category: "Réserve active", subtype: none)) } if ( "pv" in lowered or "point de vie" in lowered or "points de vie" in lowered ) { categories.push((category: "PV", subtype: none)) } let stat-gain = lowered.match( regex( "(?:@ca_)?(?:force|agilité|agilite|chance|intelligence|perception|psyché|psyche|charisme|volonté|volonte)\\s*[+-]\\s*\\d+", ), ) if stat-gain != none { categories.push((category: "Caractéristiques", subtype: none)) } for alteration in alterations { let subtype = alteration.captures.first() if is-marks and subtype in mark-types { categories.push((category: "Marques", subtype: subtype)) } else { categories.push((category: "Altérations", subtype: subtype)) } } categories } #let analyze-craft-mechanics(definition) = { let rows = configured-craft-rows(definition) let records = () for row in rows { let constraints = ( tier: field-number(row, ("@ar_tier", "@ar_tier:short")), cost: field-number(row, ("@ar_cst", "@ar_cst:short", "Coût")), level: field-number(row, ("@ar_lvl", "@ar_lvl:short")), toxicity: field-number(row, ("@ar_tox", "Toxicité")), endurance: field-number(row, ("@ar_end", "@ar_end:short")), ) for effect-key in definition.effects { let effect = row.at(effect-key, default: "") for semicolon-clause in effect.split(";") { for clause in semicolon-clause.split(".") { let cleaned = clause.trim() for mechanic in clause-mechanics(cleaned) { records.push(( craft: definition.craft, dataset: definition.label, item: row.at(definition.name, default: "—"), category: mechanic.category, subtype: mechanic.subtype, raw: cleaned, ..constraints, )) } } } } } records } #let promoted-rule-mechanics = ( ( (macro: "rl_rmax", category: "R.Max"), (macro: "ca_torque", category: "Torque"), (macro: "el_acces", category: "Accès élémentaire"), ) .map(definition => all-craft-rule-references .filter(reference => ( reference.macro == definition.macro )) .map(reference => ( craft: reference.craft, dataset: reference.dataset, item: reference.item, category: definition.category, subtype: none, raw: reference.raw, tier: reference.tier, cost: reference.cost, level: reference.level, toxicity: reference.toxicity, endurance: reference.endurance, ))) .flatten() ) #let all-craft-mechanics = ( craft-sources.map(analyze-craft-mechanics).flatten() + promoted-rule-mechanics ) #let selected-mechanics( category: none, subtype: none, tier: none, ) = all-craft-mechanics.filter(item => ( (category == none or item.category == category) and (subtype == none or item.subtype == subtype) and (tier == none or item.tier == tier) )) #let mechanic-counts = ( mechanic-order .map(category => ( label: category, count: selected-mechanics(category: category).len(), )) .sorted(key: item => -item.count) ) #let mechanic-tier-counts(category) = craft-tiers.map(tier => ( tier: tier, count: selected-mechanics(category: category, tier: tier).len(), )) #let average-present(records, key) = { let values = records .map(record => record.at(key)) .filter(value => value != none) if values.len() == 0 { none } else { calc.round(values.sum() / values.len(), digits: 1) } } #let range-present(records, key) = { let values = records .map(record => record.at(key)) .filter(value => value != none) .sorted() if values.len() == 0 { none } else { (min: values.first(), max: values.last(), count: values.len()) } } #let mechanic-profile(category) = { let records = selected-mechanics(category: category) let tiers = mechanic-tier-counts(category) let present = tiers.filter(item => item.count > 0) let peak = present.sorted(key: item => -item.count).first() let changes = craft-tiers .slice(1) .map(tier => ( tier: tier, increase: tiers.at(tier).count - tiers.at(tier - 1).count, )) .sorted(key: item => -item.increase) ( category: category, count: records.len(), first-tier: present.first().tier, peak-tier: peak.tier, peak-count: peak.count, breakpoint-tier: changes.first().tier, breakpoint-increase: changes.first().increase, cost: average-present(records, "cost"), level: average-present(records, "level"), toxicity: average-present(records, "toxicity"), endurance: average-present(records, "endurance"), ) } #let mechanic-profiles = mechanic-order.map(mechanic-profile) #let subtype-counts(category) = { let counts = (:) for record in selected-mechanics(category: category) { if record.subtype != none { counts.insert(record.subtype, counts.at(record.subtype, default: 0) + 1) } } counts .pairs() .map(pair => (label: pair.first(), count: pair.last())) .sorted(key: item => -item.count) } #let subtype-profile(category, subtype) = { let records = selected-mechanics(category: category, subtype: subtype) let tiers = craft-tiers.map(tier => ( tier: tier, count: records.filter(item => item.tier == tier).len(), )) let present = tiers.filter(item => item.count > 0) let peak = present.sorted(key: item => -item.count).first() ( subtype: subtype, count: records.len(), first-tier: present.first().tier, peak-tier: peak.tier, cost: average-present(records, "cost"), level: average-present(records, "level"), toxicity: average-present(records, "toxicity"), ) }