diff --git a/data/config/balance_report.yaml b/data/config/balance_report.yaml index b8f8f22..3761eef 100644 --- a/data/config/balance_report.yaml +++ b/data/config/balance_report.yaml @@ -42,6 +42,7 @@ chapters: - classes.overview - classes.tiers - classes.categories + - classes.durations - classes.alterations - classes.details - origins.summary diff --git a/data/config/build.yaml b/data/config/build.yaml index 4f4265a..aa3016a 100644 --- a/data/config/build.yaml +++ b/data/config/build.yaml @@ -39,6 +39,14 @@ schools: protecteur: PRO sangremage: SGM +crafts: + trigrams: + alchimie: ALC + brasserie: BRA + forge: FOR + restauration: RES + pieges: PIE + # Chapter IDs are defined in main.typ. Presets only list what they hide, so new # chapters remain visible by default and a custom exclusion stays easy to audit. presets: diff --git a/setup/analysis/class_cost_report.typ b/setup/analysis/class_cost_report.typ index 9d78bc7..b739b5f 100644 --- a/setup/analysis/class_cost_report.typ +++ b/setup/analysis/class_cost_report.typ @@ -6,6 +6,7 @@ #import "../build_config.typ": school-tiers, school-trigram #import "class_alteration_report.typ": school-alteration-report #import "class_category_report.typ": school-category-report +#import "class_duration_report.typ": school-duration-report #import "report_config.typ": chapter-enabled #let cost-series(metrics) = ( @@ -242,6 +243,7 @@ if chapter-enabled("classes.overview") { portfolio-overview(classes: classes) } if chapter-enabled("classes.tiers") { cross-class-tier-report(classes: classes) } if chapter-enabled("classes.categories") { school-category-report() } + if chapter-enabled("classes.durations") { school-duration-report() } if chapter-enabled("classes.alterations") { school-alteration-report() } if chapter-enabled("classes.details") { for (_, class-data) in classes { class-cost-section(class-data) } diff --git a/setup/analysis/class_duration_report.typ b/setup/analysis/class_duration_report.typ new file mode 100644 index 0000000..8c7df79 --- /dev/null +++ b/setup/analysis/class_duration_report.typ @@ -0,0 +1,90 @@ +// Presentation of automatically detected temporal wording in school effects. +#import "@preview/primaviz:0.6.0": bar-chart, horizontal-bar-chart +#import "class_durations.typ": * +#import "report_style.typ": chart-theme, metric-card, report-theme +#import "../generation/radar_graphs.typ": school-sources +#import "../build_config.typ": school-tiers, school-trigram +#import "../theme/tables.typ" as tables + +#let school-duration-report() = { + pagebreak() + heading(level: 2)[Classes — Durées des techniques] + + grid( + columns: (1fr,) * 4, + column-gutter: 8pt, + metric-card("Mentions temporelles", all-school-durations.len()), + metric-card("Techniques", duration-technique-count), + metric-card("Classes", duration-class-count), + metric-card("Formulations", duration-formulation-count, note: [segments distincts]), + ) + + [Le détecteur recherche des échéances explicites, des durées en tours, des + conditions de maintien, des prochaines occurrences et des récurrences par + tour. Il centralise les formulations détectées sans leur attribuer de valeur + d’équilibrage.] + + heading(level: 3)[Répartition des formulations] + horizontal-bar-chart( + (labels: duration-counts.map(item => item.label), values: duration-counts.map(item => item.count)), + width: 100%, height: calc.max(175pt, duration-counts.len() * 18pt), show-values: true, theme: chart-theme, + ) + + heading(level: 3)[Mentions par tier] + bar-chart( + ( + labels: school-tiers.map(tier => "T" + str(tier)), + values: school-tiers.map(tier => school-durations(tier: tier).len()), + ), + width: 100%, height: 145pt, show-values: true, theme: chart-theme, + ) + + pagebreak(weak: true) + heading(level: 3)[Familles temporelles par classe] + let matrix = () + for kind in duration-counts.map(item => item.label) { + matrix.push(kind) + for name in school-sources.keys() { + let count = school-durations(class: name, kind: kind).len() + let shade = if count == 0 { report-theme.parchment-light } else { + report-theme.chart-2.transparentize(calc.max(16%, 82% - count * 8%)) + } + matrix.push(table.cell(fill: shade)[#count]) + } + matrix.push(str(school-durations(kind: kind).len())) + } + tables.set-table-style( + table( + columns: (1.45fr,) + (0.55fr,) * school-sources.len() + (0.5fr,), + align: (left,) + (center,) * school-sources.len() + (right,), + table.header( + [Famille], + ..school-sources.keys().map(name => [#school-trigram(name)]), + [Total], + ), + ..matrix, + ), + table-theme: "steingrund", + text-size: 6.5pt, + ) + + heading(level: 3)[Registre centralisé des durées] + let rows = all-school-durations.sorted(key: item => ( + item.kind + "/" + item.display + "/" + str(item.tier) + "/" + item.technique + )).map(item => ( + item.kind, + school-trigram(item.class), + "T" + str(item.tier), + item.technique, + item.excerpt, + )) + tables.set-table-style( + table( + columns: (1.05fr, 0.38fr, 0.35fr, 1.35fr, 2.55fr), + table.header([Famille], [Classe], [Tier], [Technique], [Formulation détectée]), + ..rows.flatten(), + ), + table-theme: "steingrund", + text-size: 6.3pt, + ) +} diff --git a/setup/analysis/class_durations.typ b/setup/analysis/class_durations.typ new file mode 100644 index 0000000..3c249b1 --- /dev/null +++ b/setup/analysis/class_durations.typ @@ -0,0 +1,105 @@ +// Heuristic inventory of temporal wording in 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 duration-kinds = ( + "Fin du tour", + "Début du prochain tour", + "Fin du prochain tour", + "Combat", + "Nombre de tours", + "Conditionnelle", + "Prochaine occurrence", + "Récurrence par tour", + "Autre échéance", +) + +#let duration-kind(text) = { + let value = 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") + if value.match(regex("(?:jusqu'au |jusqu'a la |au |a la )?debut (?:de |du )?(?:votre )?(?:prochain tour|tour prochain)")) != none { + "Début du prochain tour" + } else if value.match(regex("(?:jusqu'au |jusqu'a la |au |a la )?fin (?:de |du )?(?:votre )?(?:prochain tour|tour prochain)")) != none { + "Fin du prochain tour" + } else if value.match(regex("(?:jusqu'au |jusqu'a la |au |a la )?fin (?:de )?(?:ce |du |votre )tour|reste (?:de ce |du |de votre )tour")) != none { + "Fin du tour" + } else if value.match(regex("(?:jusqu'au |jusqu'a la |au |a la )?(?:fin du combat|fin de ce combat)")) != none { + "Combat" + } else if value.match(regex("(?:pendant|durant|pour|dure(?:nt)?|duree de|d'ici|jusqu'a) .{0,28}?(?:tour|round)s?")) != none { + "Nombre de tours" + } else if value.match(regex("(?:tant que|aussi longtemps|jusqu'a ce que|jusqu'a atteindre)")) != none { + "Conditionnelle" + } else if value.match(regex("(?:prochain(?:e)?|suivant(?:e)?) (?:action|attaque|test|jet|déplacement|degat|dégât|technique|réussite)")) != none { + "Prochaine occurrence" + } else if value.match(regex("(?:a chaque tour|au debut de chaque tour|a la fin de chaque tour|une fois par tour|par tour)")) != none { + "Récurrence par tour" + } else if value.match(regex("jusqu'a (?:[0-9]|un |une |deux |trois |quatre |cinq |six |sept |huit |neuf )")) != none { + none + } else if value.match(regex("(?:jusqu'a|au debut du tour|a la fin du tour|debut du tour suivant|fin du tour suivant|prochain tour|tour prochain)")) != none { + "Autre échéance" + } else { + none + } +} + +#let analyze-school-durations(name, source) = { + let rows = csv(source, delimiter: "\t") + let records = () + let current-tier = none + let effect-column = 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" { + effect-column = row.position(cell => cell.trim() == "Effet") + continue + } + if first == "" or current-tier == none or effect-column == none or not tier-is-enabled(current-tier) { continue } + if effect-column >= row.len() { continue } + let effect = row.at(effect-column).trim() + let clauses = effect.split(regex("[.;]\\s+")).map(value => value.trim()).filter(value => value != "") + for clause in clauses { + let kind = duration-kind(clause) + if kind != none { + records.push(( + class: name, + display: class-display-names.at(name), + tier: current-tier, + technique: first, + kind: kind, + excerpt: clause, + effect: effect, + )) + } + } + } + records +} + +#let all-school-durations = school-sources.pairs().map(pair => ( + analyze-school-durations(pair.first(), pair.last()) +)).flatten() + +#let school-durations(class: none, tier: none, kind: none) = all-school-durations.filter(item => ( + (class == none or item.class == class) and + (tier == none or item.tier == tier) and + (kind == none or item.kind == kind) +)) + +#let duration-counts = duration-kinds.map(kind => ( + label: kind, + count: school-durations(kind: kind).len(), +)).filter(item => item.count > 0).sorted(key: item => -item.count) + +#let duration-technique-count = all-school-durations.map(item => ( + item.class + "/" + str(item.tier) + "/" + item.technique +)).dedup().len() +#let duration-class-count = all-school-durations.map(item => item.class).dedup().len() +#let duration-formulation-count = all-school-durations.map(item => lower(item.excerpt)).dedup().len() diff --git a/setup/analysis/craft_report.typ b/setup/analysis/craft_report.typ index cc597c2..bb4c824 100644 --- a/setup/analysis/craft_report.typ +++ b/setup/analysis/craft_report.typ @@ -3,7 +3,7 @@ #import "craft_metrics.typ": * #import "report_style.typ": chart-theme, metric-card, report-theme, rounded #import "../theme/tables.typ" as tables -#import "../build_config.typ": craft-tiers +#import "../build_config.typ": craft-tiers, craft-trigram #import "weapon_report.typ": weapon-analysis-report #import "weapon_breakpoint_report.typ": weapon-breakpoint-report #import "weapon_armor_report.typ": weapon-armor-report @@ -143,7 +143,7 @@ table( columns: (1.4fr,) + (0.78fr,) * craft-order.len(), align: (left,) + (right,) * craft-order.len(), - table.header([Famille], ..craft-order), + table.header([Famille], ..craft-order.map(craft-trigram)), ..craft-rows, ), table-theme: "steingrund", diff --git a/setup/build_config.typ b/setup/build_config.typ index bd011f4..c881152 100644 --- a/setup/build_config.typ +++ b/setup/build_config.typ @@ -4,6 +4,7 @@ #let raw-build-config = config.build #let presets = config.presets #let school-trigrams = config.schools.trigrams +#let craft-trigrams = config.crafts.trigrams // `--input preset=...` is the lightweight entry point for alternate editions. #let selected-preset = sys.inputs.at("preset", default: raw-build-config.preset) @@ -47,6 +48,22 @@ school-trigrams.at(canonical) } +#let craft-trigram(name) = { + let normalized = lower(name).replace("_", "-").replace(" ", "-") + let canonical = ( + alchemy: "alchimie", + brewery: "brasserie", + brewry: "brasserie", + restoration: "restauration", + traps: "pieges", + pièges: "pieges", + ).at(normalized, default: normalized) + if canonical not in craft-trigrams { + panic("Unknown craft trigram: " + name) + } + craft-trigrams.at(canonical) +} + #assert(max-tier-exclusive > 1, message: "build.max_tier_exclusive must be greater than 1") #assert( school-trigrams.values().all(value => value.match(regex("^[A-Z]{3}$")) != none), @@ -57,3 +74,12 @@ school-trigrams.len(), message: "schools.trigrams values must be unique", ) +#assert( + craft-trigrams.values().all(value => value.match(regex("^[A-Z]{3}$")) != none), + message: "Every crafts.trigrams value must contain exactly three uppercase letters", +) +#assert.eq( + craft-trigrams.values().dedup().len(), + craft-trigrams.len(), + message: "crafts.trigrams values must be unique", +)