Temporal analysis
Build Successful The Ravenous rulebook and balance report were built successfully.
Ravenous/ravenous_typst/pipeline/head This commit looks good Details

This commit is contained in:
Dandaedre 2026-08-21 20:25:42 +02:00
parent 822e06dc3b
commit d00187afd1
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
7 changed files with 234 additions and 2 deletions

View File

@ -42,6 +42,7 @@ chapters:
- classes.overview
- classes.tiers
- classes.categories
- classes.durations
- classes.alterations
- classes.details
- origins.summary

View File

@ -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:

View File

@ -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) }

View File

@ -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,
)
}

View File

@ -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()

View File

@ -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",

View File

@ -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",
)