ravenous_typst/setup/analysis/class_durations.typ

215 lines
5.0 KiB
Plaintext
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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