Master reporting
This commit is contained in:
parent
30c7869a01
commit
3b67a92077
|
|
@ -6,6 +6,7 @@
|
|||
render-common-reward-report,
|
||||
)
|
||||
#import "/setup/analysis/creature_durability_report.typ": render-durability-report
|
||||
#import "/setup/analysis/creature_reward_report.typ": render-creature-reward-analysis
|
||||
|
||||
#let report-config = yaml("/data/config/balance_report_master.yaml")
|
||||
#let enabled-chapters = report-config.chapters
|
||||
|
|
@ -61,5 +62,6 @@
|
|||
|
||||
#if chapter-enabled("creatures.common.profile") { render-common-profile-report() }
|
||||
#if chapter-enabled("creatures.common.rewards") { render-common-reward-report() }
|
||||
#if chapter-enabled("creatures.rewards.analysis") { render-creature-reward-analysis() }
|
||||
#if chapter-enabled("creatures.common.regions") { render-common-region-report() }
|
||||
#if chapter-enabled("creatures.durability") { render-durability-report() }
|
||||
|
|
|
|||
|
|
@ -4,5 +4,6 @@
|
|||
chapters:
|
||||
- creatures.common.profile
|
||||
- creatures.common.rewards
|
||||
- creatures.rewards.analysis
|
||||
- creatures.common.regions
|
||||
- creatures.durability
|
||||
|
|
|
|||
|
|
@ -0,0 +1,206 @@
|
|||
// Structured reward constraints and heuristic effect coverage.
|
||||
#import "creature_common_metrics.typ": (
|
||||
average, common-creatures, counts, extent, hse-profiles,
|
||||
reward-entries, standard-deviation,
|
||||
)
|
||||
#import "craft_metrics.typ": clause-elements, clause-mechanics
|
||||
|
||||
#let numeric-marker(text, key) = {
|
||||
let found = text.match(regex("@" + key + ":short\\s+(-?\\d+)"))
|
||||
if found == none { none } else { int(found.captures.first()) }
|
||||
}
|
||||
#let effect-clauses(text) = text.split(";").map(part => (
|
||||
part.split(".").map(clause => clause.trim()).filter(clause => clause != "")
|
||||
)).flatten()
|
||||
|
||||
#let reward-effect-families(text) = {
|
||||
let lowered = lower(text)
|
||||
let families = effect-clauses(text).map(clause => (
|
||||
clause-mechanics(clause).map(item => item.category)
|
||||
)).flatten()
|
||||
if "résist" in lowered or "resist" in lowered { families.push("Résistances") }
|
||||
if "esquive" in lowered or "parade" in lowered { families.push("Défense") }
|
||||
if "torque" in lowered { families.push("Caractéristiques") }
|
||||
if "recette" in lowered { families.push("Modification de recette") }
|
||||
if "rage" in lowered { families.push("Altérations") }
|
||||
if families.len() == 0 { families.push("Autre") }
|
||||
families.dedup()
|
||||
}
|
||||
|
||||
#let reward-effect-records-for(reward) = {
|
||||
let records = ()
|
||||
for clause in effect-clauses(reward.effect) {
|
||||
let families = reward-effect-families(clause)
|
||||
for family in families {
|
||||
records.push((
|
||||
reward: reward.name,
|
||||
creature: reward.creature,
|
||||
difficulty: reward.difficulty,
|
||||
family: family,
|
||||
clause: clause,
|
||||
))
|
||||
}
|
||||
}
|
||||
records
|
||||
}
|
||||
|
||||
#let analyzed-rewards = reward-entries.map(reward => {
|
||||
let creature = common-creatures.find(item => item.id == reward.creature-id)
|
||||
let constraints = (
|
||||
tier: numeric-marker(reward.cost, "ar_tier"),
|
||||
cost: numeric-marker(reward.cost, "ar_cst"),
|
||||
level: numeric-marker(reward.cost, "ar_lvl"),
|
||||
endurance: numeric-marker(reward.cost, "ar_end"),
|
||||
)
|
||||
let elements = effect-clauses(reward.effect).map(clause => (
|
||||
clause-elements(clause).map(element => (
|
||||
key: element.key,
|
||||
label: element.label,
|
||||
role: if "résist" in lower(clause) or "resist" in lower(clause) {
|
||||
"Résistance"
|
||||
} else if "dégât" in lower(clause) or "dégat" in lower(clause) or "degat" in lower(clause) {
|
||||
"Dégâts"
|
||||
} else { "Autre" },
|
||||
raw: clause,
|
||||
))
|
||||
)).flatten()
|
||||
(
|
||||
id: reward.creature-id,
|
||||
reward-id: reward-entries.position(item => item == reward),
|
||||
creature: reward.creature,
|
||||
difficulty: creature.profile-hse,
|
||||
region: reward.region,
|
||||
name: reward.name,
|
||||
category: reward.category,
|
||||
family: reward.family,
|
||||
cost-raw: reward.cost,
|
||||
effect: reward.effect,
|
||||
constraints: constraints,
|
||||
effects: reward-effect-families(reward.effect),
|
||||
elements: elements,
|
||||
)
|
||||
})
|
||||
|
||||
#let constraint-fields = (
|
||||
(key: "tier", label: "Tier"),
|
||||
(key: "cost", label: "Coût"),
|
||||
(key: "level", label: "Niveau"),
|
||||
(key: "endurance", label: "Finition"),
|
||||
)
|
||||
#let reward-constraint-value(reward, key) = reward.constraints.at(key)
|
||||
#let reward-constraint-summaries = constraint-fields.map(field => {
|
||||
let observations = analyzed-rewards.map(reward => (
|
||||
reward: reward,
|
||||
value: reward-constraint-value(reward, field.key),
|
||||
)).filter(item => item.value != none)
|
||||
let values = observations.map(item => item.value)
|
||||
let limits = extent(values)
|
||||
let mean = average(values)
|
||||
let deviation = standard-deviation(values)
|
||||
let enriched = observations.map(item => item + (
|
||||
z: if deviation == none or deviation == 0 { 0 } else { (item.value - mean) / deviation },
|
||||
))
|
||||
(
|
||||
key: field.key,
|
||||
label: field.label,
|
||||
average: mean,
|
||||
deviation: deviation,
|
||||
min: limits.min,
|
||||
max: limits.max,
|
||||
low: enriched.filter(item => item.z <= -1.5).sorted(key: item => item.z),
|
||||
high: enriched.filter(item => item.z >= 1.5).sorted(key: item => -item.z),
|
||||
)
|
||||
})
|
||||
|
||||
#let reward-constraints-by-difficulty = hse-profiles.map(difficulty => {
|
||||
let rewards = analyzed-rewards.filter(item => item.difficulty == difficulty)
|
||||
(
|
||||
difficulty: difficulty,
|
||||
count: rewards.len(),
|
||||
tier: average(rewards.map(item => item.constraints.tier)),
|
||||
cost: average(rewards.map(item => item.constraints.cost)),
|
||||
level: average(rewards.map(item => item.constraints.level)),
|
||||
endurance: average(rewards.map(item => item.constraints.endurance)),
|
||||
)
|
||||
})
|
||||
|
||||
#let effect-family-order = (
|
||||
"Résistances", "Caractéristiques", "Actions", "Défense", "Altérations",
|
||||
"Marques", "Modification de recette", "PV", "Fatigue", "Autre",
|
||||
)
|
||||
#let reward-effect-family-counts = effect-family-order.map(family => (
|
||||
label: family,
|
||||
count: analyzed-rewards.filter(reward => family in reward.effects).len(),
|
||||
)).filter(item => item.count > 0).sorted(key: item => -item.count)
|
||||
#let reward-effect-count(family, difficulty: none) = analyzed-rewards.filter(reward => (
|
||||
family in reward.effects and (difficulty == none or reward.difficulty == difficulty)
|
||||
)).len()
|
||||
|
||||
#let reward-element-mentions = analyzed-rewards.map(reward => reward.elements.map(element => (
|
||||
reward: reward,
|
||||
difficulty: reward.difficulty,
|
||||
..element,
|
||||
))).flatten()
|
||||
#let reward-element-counts = counts(reward-element-mentions.map(item => item.label))
|
||||
#let reward-resistance-elements = counts(reward-element-mentions.filter(item => (
|
||||
item.role == "Résistance"
|
||||
)).map(item => item.label))
|
||||
#let rewards-with-resistance = analyzed-rewards.filter(item => "Résistances" in item.effects)
|
||||
#let rewards-with-elements = analyzed-rewards.filter(item => item.elements.len() > 0)
|
||||
#let rewards-with-actions = analyzed-rewards.filter(item => "Actions" in item.effects)
|
||||
#let unclassified-rewards = analyzed-rewards.filter(item => item.effects == ("Autre",))
|
||||
|
||||
// One record per classified clause and family. This keeps the actual effect
|
||||
// visible and naturally scales when new rewards or categories are introduced.
|
||||
#let reward-effect-records = analyzed-rewards.map(reward-effect-records-for).flatten()
|
||||
#let reward-effect-record-count(family) = reward-effect-records.filter(item => (
|
||||
item.family == family
|
||||
)).len()
|
||||
|
||||
// Blood yield is a separate, universally available reward axis on creatures.
|
||||
#let yield-fields = (
|
||||
(key: "blood-base", label: "Base"),
|
||||
(key: "blood-battle", label: "Combat"),
|
||||
(key: "blood-carve", label: "Dépeçage"),
|
||||
)
|
||||
#let creature-yields = common-creatures.map(creature => (
|
||||
creature: creature.name,
|
||||
difficulty: creature.profile-hse,
|
||||
base: creature.blood-base,
|
||||
battle: creature.blood-battle,
|
||||
carve: creature.blood-carve,
|
||||
))
|
||||
#let yield-value(item, key) = if key == "blood-base" { item.base } else if key == "blood-battle" {
|
||||
item.battle
|
||||
} else { item.carve }
|
||||
#let yield-summary(field, entries: creature-yields) = {
|
||||
let values = entries.map(item => yield-value(item, field.key))
|
||||
let limits = extent(values)
|
||||
(
|
||||
key: field.key,
|
||||
label: field.label,
|
||||
average: average(values),
|
||||
min: limits.min,
|
||||
max: limits.max,
|
||||
deviation: standard-deviation(values),
|
||||
)
|
||||
}
|
||||
#let yield-summaries = yield-fields.map(yield-summary)
|
||||
#let yields-by-difficulty = hse-profiles.map(difficulty => {
|
||||
let entries = creature-yields.filter(item => item.difficulty == difficulty)
|
||||
(
|
||||
difficulty: difficulty,
|
||||
count: entries.len(),
|
||||
base: average(entries.map(item => item.base)),
|
||||
battle: average(entries.map(item => item.battle)),
|
||||
carve: average(entries.map(item => item.carve)),
|
||||
)
|
||||
})
|
||||
#let identical-yield-profiles = creature-yields.filter(item => (
|
||||
item.base == item.battle and item.battle == item.carve
|
||||
))
|
||||
#let equal-battle-carve = creature-yields.filter(item => item.battle == item.carve)
|
||||
#let yield-profile-counts = counts(creature-yields.map(item => (
|
||||
str(item.base) + " / " + str(item.battle) + " / " + str(item.carve)
|
||||
)))
|
||||
#let dominant-yield-profile = yield-profile-counts.sorted(key: item => -item.count).first()
|
||||
|
|
@ -0,0 +1,257 @@
|
|||
// Master report for creature reward constraints and effect coverage.
|
||||
#import "@preview/primaviz:0.6.0": grouped-bar-chart, horizontal-bar-chart
|
||||
#import "creature_reward_metrics.typ": *
|
||||
#import "creature_common_report.typ": compact-profile, dash
|
||||
#import "report_style.typ": chart-theme, metric-card, report-theme, rounded
|
||||
#import "../theme/tables.typ" as tables
|
||||
|
||||
#let reward-pill(item, high: true) = box(
|
||||
inset: (x: 4pt, y: 1.5pt), radius: 4pt,
|
||||
fill: (if high { report-theme.chart-2 } else { report-theme.chart-1 }).transparentize(72%),
|
||||
stroke: 0.4pt + (if high { report-theme.chart-2 } else { report-theme.chart-1 }),
|
||||
text(size: 6.3pt)[#item.reward.name · #item.value],
|
||||
)
|
||||
#let reward-outliers(items, high: true) = if items.len() == 0 { [—] } else {
|
||||
items.map(item => reward-pill(item, high: high)).join(h(3pt))
|
||||
}
|
||||
#let share(part, total) = if total == 0 { "0%" } else {
|
||||
str(calc.round(part / total * 100)) + "%"
|
||||
}
|
||||
|
||||
#let render-creature-reward-analysis() = {
|
||||
pagebreak()
|
||||
heading(level: 2)[Récompenses — Contraintes et effets]
|
||||
|
||||
grid(
|
||||
columns: (1fr,) * 4, column-gutter: 8pt,
|
||||
metric-card("Récompenses", analyzed-rewards.len()),
|
||||
metric-card("Avec résistance", rewards-with-resistance.len(), note: [#share(rewards-with-resistance.len(), analyzed-rewards.len()) du portefeuille]),
|
||||
metric-card("Avec élément", rewards-with-elements.len()),
|
||||
metric-card("Avec actions", rewards-with-actions.len()),
|
||||
)
|
||||
|
||||
[L’analyse reprend les axes de l’artisanat : contraintes d’accès, familles
|
||||
mécaniques, éléments et rôle des mentions. Une récompense peut appartenir à
|
||||
plusieurs familles; les totaux d’effets ne sont donc pas mutuellement
|
||||
exclusifs. Les écarts sont descriptifs sur seulement 11 entrées. Les
|
||||
graphiques agrègent des axes stables et les inventaires détaillés utilisent
|
||||
des tables paginantes, afin de rester lisibles lorsque le catalogue
|
||||
s’agrandira.]
|
||||
|
||||
heading(level: 3)[Contraintes moyennes par difficulté]
|
||||
grouped-bar-chart(
|
||||
(
|
||||
labels: reward-constraints-by-difficulty.map(item => compact-profile(item.difficulty)),
|
||||
series: constraint-fields.map(field => (
|
||||
name: field.label,
|
||||
values: reward-constraints-by-difficulty.map(item => item.at(field.key)),
|
||||
)),
|
||||
),
|
||||
width: 100%, height: 190pt, y-label: [Valeur moyenne], theme: chart-theme,
|
||||
)
|
||||
let difficulty-rows = reward-constraints-by-difficulty.map(item => (
|
||||
compact-profile(item.difficulty), str(item.count),
|
||||
dash(item.tier), dash(item.cost), dash(item.level), dash(item.endurance),
|
||||
))
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (1fr, 0.5fr, 0.75fr, 0.75fr, 0.75fr, 0.75fr),
|
||||
align: (left,) + (right,) * 5,
|
||||
table.header([Difficulté], [N], [Tier], [Coût], [Niveau], [Finition]),
|
||||
..difficulty-rows.flatten(),
|
||||
),
|
||||
table-theme: "steingrund", text-size: 7.2pt,
|
||||
)
|
||||
|
||||
heading(level: 3)[Distribution et valeurs atypiques]
|
||||
let constraint-rows = reward-constraint-summaries.map(item => (
|
||||
item.label, dash(item.average), str(item.min) + "–" + str(item.max),
|
||||
dash(item.deviation, digits: 2),
|
||||
reward-outliers(item.low, high: false), reward-outliers(item.high),
|
||||
))
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (0.75fr, 0.6fr, 0.6fr, 0.65fr, 1.7fr, 1.7fr),
|
||||
align: (left, right, right, right, left, left),
|
||||
table.header([Contrainte], [Moyenne], [Étendue], [Écart-type], [Atypiques basses], [Atypiques hautes]),
|
||||
..constraint-rows.flatten(),
|
||||
),
|
||||
table-theme: "steingrund", text-size: 6.8pt,
|
||||
)
|
||||
|
||||
heading(level: 3)[Inventaire des contraintes]
|
||||
let inventory-rows = analyzed-rewards.map(item => (
|
||||
item.creature, item.name, compact-profile(item.difficulty), item.family,
|
||||
dash(item.constraints.tier), dash(item.constraints.cost),
|
||||
dash(item.constraints.level), dash(item.constraints.endurance),
|
||||
))
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (1.05fr, 1.4fr, 0.7fr, 0.8fr) + (0.48fr,) * 4,
|
||||
align: (left, left, left, left) + (right,) * 4,
|
||||
table.header([Créature], [Récompense], [Difficulté], [Famille], [Tier], [Coût], [Niv.], [Fin.]),
|
||||
..inventory-rows.flatten(),
|
||||
),
|
||||
table-theme: "steingrund", text-size: 6.4pt,
|
||||
)
|
||||
|
||||
pagebreak(weak: true)
|
||||
heading(level: 3)[Ce qui est donné aux joueurs]
|
||||
grid(
|
||||
columns: (1fr, 1fr), column-gutter: 12pt,
|
||||
horizontal-bar-chart(
|
||||
(labels: reward-effect-family-counts.map(item => item.label), values: reward-effect-family-counts.map(item => item.count)),
|
||||
width: 100%, height: calc.max(175pt, reward-effect-family-counts.len() * 20pt),
|
||||
title: [Familles mécaniques], show-values: true, theme: chart-theme,
|
||||
),
|
||||
horizontal-bar-chart(
|
||||
(labels: reward-element-counts.map(item => item.label), values: reward-element-counts.map(item => item.count)),
|
||||
width: 100%, height: calc.max(145pt, reward-element-counts.len() * 24pt),
|
||||
title: [Mentions élémentaires], show-values: true, theme: chart-theme,
|
||||
),
|
||||
)
|
||||
|
||||
heading(level: 3)[Familles d’effets par difficulté]
|
||||
let family-matrix = ()
|
||||
for family in reward-effect-family-counts.map(item => item.label) {
|
||||
family-matrix.push(family)
|
||||
for difficulty in hse-profiles {
|
||||
family-matrix.push(str(reward-effect-count(family, difficulty: difficulty)))
|
||||
}
|
||||
family-matrix.push(str(reward-effect-count(family)))
|
||||
}
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (1.45fr,) + (0.7fr,) * hse-profiles.len() + (0.6fr,),
|
||||
align: (left,) + (center,) * (hse-profiles.len() + 1),
|
||||
table.header([Effet], ..hse-profiles.map(compact-profile), [Total]),
|
||||
..family-matrix,
|
||||
),
|
||||
table-theme: "steingrund", text-size: 7pt,
|
||||
)
|
||||
|
||||
heading(level: 3)[Effets extraits par catégorie]
|
||||
[Chaque ligne conserve la clause qui a déclenché la catégorie. Un même effet
|
||||
peut donc apparaître dans plusieurs catégories lorsqu’il combine plusieurs
|
||||
mécaniques.]
|
||||
let categorized-effect-rows = reward-effect-records.sorted(key: item => (
|
||||
item.family + item.creature + item.reward
|
||||
)).map(item => (
|
||||
item.family, item.creature, item.reward,
|
||||
compact-profile(item.difficulty), item.clause,
|
||||
))
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (0.9fr, 0.9fr, 1.15fr, 0.65fr, 2.7fr),
|
||||
table.header([Catégorie], [Créature], [Récompense], [Difficulté], [Effet extrait]),
|
||||
..categorized-effect-rows.flatten(),
|
||||
),
|
||||
table-theme: "steingrund", text-size: 6.25pt,
|
||||
)
|
||||
|
||||
heading(level: 3)[Résistances et concentration élémentaire]
|
||||
[#rewards-with-resistance.len() récompenses sur #analyzed-rewards.len()
|
||||
accordent une résistance (#share(rewards-with-resistance.len(), analyzed-rewards.len())).
|
||||
Les mentions élémentaires détectées sont comptées ci-dessous; « Physique gén. »
|
||||
reste distinct des dix éléments afin de ne pas masquer sa portée plus large.]
|
||||
if reward-resistance-elements.len() == 0 {
|
||||
[Aucune résistance élémentaire détectée.]
|
||||
} else {
|
||||
let resistance-rows = reward-resistance-elements.map(item => (
|
||||
item.label, str(item.count), share(item.count, reward-element-mentions.len()),
|
||||
))
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (1.5fr, 0.7fr, 0.9fr), align: (left, right, right),
|
||||
table.header([Élément ou groupe], [Mentions], [Part des mentions]),
|
||||
..resistance-rows.flatten(),
|
||||
),
|
||||
table-theme: "steingrund", text-size: 7.2pt,
|
||||
)
|
||||
}
|
||||
|
||||
heading(level: 3)[Audit complet des effets]
|
||||
let effect-rows = analyzed-rewards.map(item => (
|
||||
item.creature, item.name, compact-profile(item.difficulty),
|
||||
item.effects.join(" · "),
|
||||
if item.elements.len() == 0 { [—] } else { item.elements.map(element => element.label).dedup().join(", ") },
|
||||
item.effect,
|
||||
))
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (0.9fr, 1.15fr, 0.65fr, 1.25fr, 0.85fr, 2.35fr),
|
||||
table.header([Créature], [Récompense], [Difficulté], [Familles], [Éléments], [Effet source]),
|
||||
..effect-rows.flatten(),
|
||||
),
|
||||
table-theme: "steingrund", text-size: 6.1pt,
|
||||
)
|
||||
|
||||
heading(level: 3)[Rendements Base, Combat et Dépeçage]
|
||||
[Ces valeurs viennent du profil global de chaque créature. Elles sont
|
||||
analysées séparément des objets précédents : elles décrivent la quantité
|
||||
disponible selon la source de prélèvement, sans supposer de conversion en
|
||||
puissance ou en valeur marchande.]
|
||||
|
||||
grid(
|
||||
columns: (1fr,) * 3, column-gutter: 8pt,
|
||||
metric-card("Profil dominant", dominant-yield-profile.label, note: [#dominant-yield-profile.count créatures]),
|
||||
metric-card("Combat = dépeçage", equal-battle-carve.len(), note: [sur #creature-yields.len() créatures]),
|
||||
metric-card("Profils distincts", yield-profile-counts.len()),
|
||||
)
|
||||
|
||||
grouped-bar-chart(
|
||||
(
|
||||
labels: yields-by-difficulty.map(item => compact-profile(item.difficulty)),
|
||||
series: (
|
||||
(name: "Base", values: yields-by-difficulty.map(item => item.base)),
|
||||
(name: "Combat", values: yields-by-difficulty.map(item => item.battle)),
|
||||
(name: "Dépeçage", values: yields-by-difficulty.map(item => item.carve)),
|
||||
),
|
||||
),
|
||||
width: 100%, height: 185pt, y-label: [Rendement moyen], theme: chart-theme,
|
||||
)
|
||||
|
||||
let yield-summary-rows = yield-summaries.map(item => (
|
||||
item.label, dash(item.average), str(item.min) + "–" + str(item.max),
|
||||
dash(item.deviation, digits: 2),
|
||||
))
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (1fr,) * 4, align: (left, right, right, right),
|
||||
table.header([Source], [Moyenne], [Étendue], [Écart-type]),
|
||||
..yield-summary-rows.flatten(),
|
||||
),
|
||||
table-theme: "steingrund", text-size: 7.2pt,
|
||||
)
|
||||
|
||||
heading(level: 3)[Rendement moyen par difficulté]
|
||||
let yield-difficulty-rows = yields-by-difficulty.map(item => (
|
||||
compact-profile(item.difficulty), str(item.count), dash(item.base),
|
||||
dash(item.battle), dash(item.carve),
|
||||
))
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (1.2fr, 0.55fr, 0.8fr, 0.8fr, 0.8fr),
|
||||
align: (left, right, right, right, right),
|
||||
table.header([Difficulté], [N], [Base], [Combat], [Dépeçage]),
|
||||
..yield-difficulty-rows.flatten(),
|
||||
),
|
||||
table-theme: "steingrund", text-size: 7.2pt,
|
||||
)
|
||||
|
||||
heading(level: 3)[Inventaire des rendements]
|
||||
let yield-rows = creature-yields.map(item => (
|
||||
item.creature, compact-profile(item.difficulty), str(item.base),
|
||||
str(item.battle), str(item.carve),
|
||||
if item.base == item.battle and item.battle == item.carve { [Identiques] } else { [Différenciés] },
|
||||
))
|
||||
tables.set-table-style(
|
||||
table(
|
||||
columns: (1.4fr, 0.9fr, 0.65fr, 0.65fr, 0.75fr, 0.9fr),
|
||||
align: (left, left, right, right, right, left),
|
||||
table.header([Créature], [Difficulté], [Base], [Combat], [Dépeçage], [Profil]),
|
||||
..yield-rows.flatten(),
|
||||
),
|
||||
table-theme: "steingrund", text-size: 6.8pt,
|
||||
)
|
||||
}
|
||||
|
|
@ -65,31 +65,32 @@
|
|||
#let rich-text(value) = {
|
||||
if type(value) == str {
|
||||
let entries = (:)
|
||||
for entry in glossary { entries.insert(entry.key, entry) }
|
||||
let db-gls-short(key) = {
|
||||
let entry = entries.at(key, default: none)
|
||||
if entry == none {
|
||||
"@" + key + ":short"
|
||||
} else {
|
||||
gls(key, display: entry.short)
|
||||
}
|
||||
}
|
||||
let short-references-to-calls(source) = {
|
||||
let found = source.match(regex("@([A-Za-z][A-Za-z0-9_]*):short"))
|
||||
if found == none { return source }
|
||||
let key = found.captures.first()
|
||||
(
|
||||
source.slice(0, found.start)
|
||||
+ "#db-gls-short(\""
|
||||
+ key
|
||||
+ "\")"
|
||||
+ short-references-to-calls(source.slice(found.end))
|
||||
)
|
||||
}
|
||||
// for entry in glossary { entries.insert(entry.key, entry) }
|
||||
// let db-gls-short(key) = {
|
||||
// let entry = entries.at(key, default: none)
|
||||
// if entry == none {
|
||||
// "@" + key + ":short"
|
||||
// } else {
|
||||
// gls(key, display: entry.short)
|
||||
// }
|
||||
// }
|
||||
// let short-references-to-calls(source) = {
|
||||
// let found = source.match(regex("@([A-Za-z][A-Za-z0-9_]*):short"))
|
||||
// if found == none { return source }
|
||||
// let key = found.captures.first()
|
||||
// (
|
||||
// source.slice(0, found.start)
|
||||
// + "#db-gls-short(\""
|
||||
// + key
|
||||
// + "\")"
|
||||
// + short-references-to-calls(source.slice(found.end))
|
||||
// )
|
||||
// }
|
||||
eval(
|
||||
short-references-to-calls(value),
|
||||
value,
|
||||
// short-references-to-calls(value),
|
||||
mode: "markup",
|
||||
scope: macros.bigscope + (db-gls-short: db-gls-short),
|
||||
scope: macros.bigscope, // + (db-gls-short: db-gls-short),
|
||||
)
|
||||
} else {
|
||||
value
|
||||
|
|
|
|||
Loading…
Reference in New Issue