ravenous_typst/setup/models/creature.typ

712 lines
19 KiB
Plaintext

// Data-driven master-handbook creature sheet.
//
// The renderer deliberately accepts plain Typst dictionaries. This keeps the
// presentation independent from the database/export format that will replace
// the mock record later.
#import "../theme/variables.typ": theme
#import "../core/macros.typ" as macros
#import "../generation/glossary.typ": glossary
#import "@preview/glossarium:0.5.10": gls
#let regional-map = yaml("/data/config/regional_map.yaml").regions
#let subregion-owner = (:)
#for region in regional-map.keys() {
let region-config = regional-map.at(region)
for subregion in region-config.at("subregions", default: (:)).keys() {
subregion-owner.insert(subregion, region)
}
}
#let label-fill = (
ATK: rgb("#c95f5f"),
MVT: rgb("#658db5"),
DEF: rgb("#73a16f"),
PAS: rgb("#a9c89c"),
REV: rgb("#73a16f"),
CLM: rgb("#496b4a"),
TRA: rgb("#d79555"),
ASE: rgb("#c95f5f"),
STA: rgb("#f7f5ef"),
CMB: rgb("#c95f5f"),
FLR: rgb("#c95f5f"),
GRB: rgb("#c95f5f"),
MXU: rgb("#c95f5f"),
ADF: rgb("#c95f5f"),
BYP: rgb("#873b3b"),
TBU: rgb("#873b3b"),
TBZ: rgb("#873b3b"),
TSH: rgb("#873b3b"),
CLV: rgb("#c95f5f"),
AOE: rgb("#c95f5f"),
WID: rgb("#c95f5f"),
WIP: rgb("#873b3b"),
SZO: rgb("#f7f5ef"),
SIT: rgb("#f7f5ef"),
INC: rgb("#8d6799"),
RIN: rgb("#73a16f"),
AOP: rgb("#c95f5f"),
SPS: rgb("#873b3b"),
SRG: rgb("#8d6799"),
HRG: rgb("#8d6799"),
BAD: rgb("#d79555"),
BIS: rgb("#873b3b"),
)
#let present(value) = value != none and value != "" and value != ()
#let cell(value, size: none) = if size == none { [#value] } else {
text(size: size, value)
}
#let threshold(value) = [
$#value.base$
#text(weight: "light", size: 0.6em)[$(#value.modifier)$]
]
#let protection(value) = $#value.base [#value.armor]$
#let small-value(value) = text(weight: "light", size: 0.6em, $#value$)
#let resistance(value) = {
if value == "++" { $++$ } else if value == "+" { $+$ } else if value == "--" {
$--$
} else if value == "-" { $-$ } else { $$ }
}
#let element-icon(path, height: 0.75em, baseline: 1.1pt) = box(
height: height,
baseline: baseline,
inset: 0pt,
image(path),
)
#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))
// )
// }
eval(
value,
// short-references-to-calls(value),
mode: "markup",
scope: macros.bigscope, // + (db-gls-short: db-gls-short),
)
} else {
value
}
}
#let section-title(title) = block(
width: 100%,
above: 0.35em,
below: 0.35em,
inset: (x: 5pt, y: 3pt),
fill: theme.dark-gold,
text(fill: theme.parchment-light, weight: "bold", title),
)
#let creature-heading(creature, show-database-id: false) = {
heading(level: 2, creature.name)
let database-id = creature.at("id", default: none)
if show-database-id and database-id != none {
v(-0.75em)
align(right, text(
size: 5pt,
tracking: 0.04em,
fill: theme.muted-ink.lighten(18%),
)[DB ID · #database-id])
v(0.2em)
}
}
// Present bestiary artwork with the same double frame as class illustrations.
#let creature-artwork(path) = align(center)[
#block(
width: 8cm,
fill: theme.parchment-dark,
stroke: 0.8pt + theme.border,
inset: 0.3em,
)[
#block(
clip: true,
stroke: 0.5pt + theme.border,
)[
#image(path, width: 100%)
]
]
]
#let effect-pill(tags) = box(
inset: (x: 2.5pt, y: 1pt),
radius: 2.5pt,
fill: theme.parchment.lighten(55%),
stroke: 0.4pt + theme.border,
text(size: 0.88em)[
#for (index, tag) in tags.enumerate() {
if index > 0 { h(0.45em) }
rich-text("@" + tag.key + ":short")
[ ]
tag.value
}
],
)
#let attack-effects(attack) = {
let tags = attack.at("effect-tags", default: ())
if tags.len() > 0 {
effect-pill(tags)
h(0.4em)
}
rich-text(attack.effects)
}
#let target-pill(value) = {
let label = if not present(value) { "—" } else { str(value) }
let color = (
S: theme.attack-basic,
A: theme.attack-danger,
Z: theme.attack-area,
W: theme.attack-mixed,
).at(label, default: theme.muted-ink)
box(
inset: (x: 2.5pt, y: 0.75pt),
radius: 2.5pt,
fill: color.transparentize(78%),
stroke: 0.4pt + color,
text(size: 0.86em, weight: "bold", fill: color.darken(18%), label),
)
}
#let csv-values(value) = if not present(value) {
()
} else {
str(value).split(",").map(item => item.trim()).filter(present).dedup()
}
#let region-name(key) = {
let region = regional-map.at(key, default: (:))
region.at("name", default: key)
}
#let subregion-name(key) = {
let owner = subregion-owner.at(key, default: none)
if owner == none {
key
} else {
let region = regional-map.at(owner)
let subregions = region.at("subregions", default: (:))
let subregion = subregions.at(key, default: (:))
subregion.at("name", default: key)
}
}
#let creature-distribution(creature) = {
let regions = csv-values(creature.at("region", default: ""))
let subregions = csv-values(creature.at("subregion", default: ""))
let entries = ()
for region in regions {
let matches = subregions.filter(name => (
subregion-owner.at(name, default: none) == region
))
let subregion-list = if matches.len() > 0 {
[(#matches.map(subregion-name).join(", "))]
} else {
[]
}
entries.push([
#strong(region-name(region))#subregion-list
])
}
// Never discard imported data just because the map does not yet know how
// to associate it. Unmatched subregions remain visible as standalone names.
entries += subregions
.filter(name => subregion-owner.at(name, default: none) not in regions)
.map(name => [#subregion-name(name)])
entries.join([; ])
}
#let identity-table(creature, show-distribution: false) = {
let has-distribution = (
present(creature.at("region", default: ""))
or present(creature.at("subregion", default: ""))
)
let distribution-fields = if show-distribution {
(
(
if has-distribution {
(("Répartition", creature-distribution(creature)),)
} else { () }
)
+ (
if present(creature.at("locality", default: "")) {
(("Localité", creature.locality),)
} else {
()
}
)
)
} else {
()
}
let fields = (
("Dénomination", creature.denomination),
("Calamité", creature.calamity),
("Niveau de danger (HSE)", creature.danger-level),
("Habitat", creature.habitat),
..distribution-fields,
("Dysmorphisme", creature.dysmorphism),
("Couleurs", creature.colors),
("Réaction à l'homme", creature.human-reaction),
("Variantes", creature.variants),
("Taille", creature.size),
("Traces", creature.traces),
("Mœurs", creature.habits),
).filter(pair => present(pair.at(1)))
let rows = fields
.map(pair => (
table.cell(align: left, text(weight: "bold", pair.at(0))),
table.cell(align: left, rich-text(pair.at(1))),
))
.flatten()
table(
columns: 2,
column-gutter: 10pt,
inset: (x: 0pt, y: 4pt),
stroke: none,
..rows,
)
}
#let lore-and-rewards(creature) = {
section-title("Description")
text(size: 9pt, rich-text(creature.description))
v(0.35em)
section-title("Annotations")
text(size: 9pt, rich-text(creature.annotations))
v(0.35em)
section-title("Récompenses")
let reward-rows = creature
.rewards
.map(reward => (
reward.name,
reward.category,
rich-text(reward.cost),
rich-text(reward.effect),
))
.flatten()
text(
size: 8pt,
table(
columns: (0.9fr, 1fr, 0.75fr, 2.2fr),
inset: (x: 4pt, y: 3pt),
stroke: none,
table.header([*Nom*], [*Catégorie*], [*Coût*], [*Effet*]),
[Sang],
[Base / combat / dépeçage],
[],
[#creature.blood.base / #creature.blood.battle / #creature.blood.carve],
..reward-rows,
),
)
}
#let body-table(creature) = {
let configured-maluses = creature.stats.at("threshold-maluses", default: "")
let size-bonus = creature.stats.at("size-bonus-to-hit", default: none)
let signed(value) = if value >= 0 { "+" + str(value) } else { str(value) }
let threshold-maluses = (
("Ciblé(-2)",),
if size-bonus == none { () } else {
("Taille(" + signed(size-bonus) + ")",)
},
if present(configured-maluses) and str(configured-maluses).trim() != "" {
(str(configured-maluses).trim(),)
} else { () },
)
.flatten()
.join(", ")
let show-threshold-maluses = threshold-maluses != ""
let resistance-summary = creature.stats.at("resistances", default: "")
let show-resistances = (
resistance-summary != none
and str(resistance-summary).trim() != ""
)
let rows = creature
.body-parts
.map(part => (
text(size: 8pt, part.name),
threshold(part.p1.threshold),
protection(part.p1.protection),
small-value(part.p1.integrity),
small-value(part.p1.life),
threshold(part.p2.threshold),
protection(part.p2.protection),
small-value(part.p2.integrity),
small-value(part.p2.life),
))
.flatten()
table(
columns: (1.6fr, auto, auto, 1.7fr, 1.7fr, auto, auto, 1.7fr, 1.7fr),
rows: (1.5em, 1.5em)
+ (2.5em,) * creature.body-parts.len()
+ (auto, auto)
+ if show-resistances { (auto, auto) } else { () }
+ if show-threshold-maluses { (auto, auto) } else { () },
inset: (x: 4pt, y: 2pt),
align: (x, y) => if x == 0 and y > 1 {
left + horizon
} else if (x == 3 or x == 4 or x == 7 or x == 8) and y > 1 {
right + bottom
} else if y >= creature.body-parts.len() + 2 {
left + top
} else {
center + horizon
},
stroke: none,
table.vline(x: 5, start: 1, stroke: 0.5pt + theme.border),
table.header(
[],
table.cell(colspan: 4, align: center)[P1],
table.cell(colspan: 4, align: center)[P2],
[],
[Seuil],
[Prot],
[Intégrité],
[PV],
[Seuil],
[Prot],
[Intégrité],
[PV],
),
table.hline(stroke: 0.5pt + theme.border),
..rows,
table.hline(stroke: 0.5pt + theme.border),
table.cell(colspan: 9, inset: (top: 6pt, bottom: 3pt))[*Notes*],
table.cell(
colspan: 9,
inset: (top: 3pt, bottom: 6pt),
text(size: 8pt, rich-text(creature.master-notes)),
),
..if show-resistances {
(
table.cell(colspan: 9, inset: (top: 6pt, bottom: 3pt))[*Résistances*],
table.cell(
colspan: 9,
inset: (top: 3pt, bottom: 6pt),
text(size: 8pt, rich-text(resistance-summary)),
),
)
} else { () },
..if show-threshold-maluses {
(
table.cell(colspan: 9, inset: (top: 6pt, bottom: 3pt))[*Malus*],
table.cell(
colspan: 9,
inset: (top: 3pt, bottom: 6pt),
text(size: 8pt, str(threshold-maluses)),
),
)
} else { () },
table.hline(stroke: 0.5pt + theme.border),
)
}
#let resistance-table(creature) = {
let headers = (
[Res],
element-icon("/images/icons/slash.svg", height: 0.65em, baseline: 0.5pt),
element-icon("/images/icons/pierce.svg", height: 0.7em, baseline: 0.7pt),
element-icon(
"/images/icons/gavel-solid-full.svg",
height: 0.7em,
baseline: 0.5pt,
),
element-icon("/images/icons/sun-solid-full.svg"),
element-icon("/images/icons/fire-flame-curved-solid-full.svg"),
element-icon("/images/icons/mountain-solid-full.svg"),
element-icon("/images/icons/leaf-solid-full.svg"),
element-icon("/images/icons/water-solid-full.svg"),
element-icon("/images/icons/moon-solid-full.svg"),
element-icon("/images/icons/droplet-solid-full.svg", baseline: 0pt),
element-icon("/images/icons/wind-solid-full.svg"),
element-icon("/images/icons/icicles-solid-full.svg"),
element-icon("/images/icons/lightning-fill.svg"),
)
let rows = creature
.body-parts
.map(part => (
smallcaps(part.name),
..part.resistances.map(resistance),
))
.flatten()
[
#show table.cell: it => if it.y > 0 { text(size: 9pt, it) } else {
text(size: 12pt, it)
}
#table(
columns: (25%,) + (75% / 13,) * 13,
row-gutter: 1.5pt,
inset: (x: 2pt, y: 3.5pt),
align: (x, _) => if x == 0 { left + horizon } else { center + horizon },
stroke: none,
table.header(..headers),
table.hline(stroke: 0.5pt + theme.border),
..rows,
)
]
}
#let statistics-table(creature) = {
let s = creature.stats
let rows = ()
for (index, init) in creature.initiatives.enumerate() {
rows += (
cell(init.name),
cell(init.p1-value),
cell(init.p1-actions),
cell(init.p2-value),
cell(init.p2-actions),
)
if index == 0 {
rows += (
[],
cell(s.strength),
cell(s.perception),
cell(s.willpower),
cell(s.alteration-resistance),
cell(s.torque),
cell(s.awareness),
cell(s.fatigue),
[],
cell(s.movement.walk),
cell(s.movement.trot),
cell(s.movement.run),
cell(s.movement.flight),
[],
cell(s.transcendental-resistance),
cell(s.physical-bonus),
cell(s.elemental-bonus),
)
} else {
rows += ([],) * 17
}
}
[
#show table.cell: it => if it.y == 0 {
text(size: 12pt, it)
} else if it.y == 1 {
text(size: 7pt, align(center + bottom, rotate(-90deg, it, reflow: true)))
} else { text(size: 9pt, it) }
#align(center)[
#table(
columns: (100% / 22,) * 22,
inset: (x: 1.5pt, y: 3pt),
align: (x, y) => if y == 1 { right + horizon } else {
center + horizon
},
stroke: none,
table.header(
[], table.cell(colspan: 2)[P1], table.cell(colspan: 2)[P2], [],
table.cell(colspan: 7)[Stats],
[],
table.cell(colspan: 4)[Mouvement],
[],
table.cell(colspan: 3)[Extra],
table.hline(start: 1, end: 5, stroke: 0.5pt + theme.border),
table.hline(start: 6, end: 13, stroke: 0.5pt + theme.border),
table.hline(start: 14, end: 18, stroke: 0.5pt + theme.border),
table.hline(start: 19, end: 22, stroke: 0.5pt + theme.border),
[Initiative], [Valeur], [Action], [Valeur], [Actions], [],
[Force],
[Perception],
[Volonté],
[Rés. Alt.],
[Torque],
[Vigilance],
[Fatigue],
[],
[Marche],
[Trot],
[Course],
[Vol],
[],
[Rés. Trans.],
[Bon. Phy.],
[Bon. Élém.],
),
..rows,
)
]
]
}
#let attack-table(creature) = {
let contents = ()
for phase in creature.phases {
contents.push(table.cell(colspan: 13, fill: theme.dark-gold, text(
fill: white,
weight: "bold",
phase.name,
)))
for group in phase.groups {
// Colour belongs to the complete skill group, not to an individual row:
// multi-line attacks and their explanation therefore read as one unit.
let group-color-key = group.at(
"color",
default: group.attacks.first().type,
)
let group-color = if type(group-color-key) == color {
group-color-key
} else {
label-fill.at(group-color-key, default: white)
}
for attack in group.attacks {
contents += (
table.cell(fill: group-color)[],
rich-text(attack.name),
cell(attack.type),
rich-text(attack.timing),
target-pill(attack.target),
rich-text(attack.fatigue-cost),
rich-text(attack.action-cost),
rich-text(attack.element),
rich-text(attack.fatigue-damage),
rich-text(attack.damage),
attack-effects(attack),
cell(attack.parry),
cell(attack.dodge),
)
}
if present(group.description) {
contents += (
table.cell(fill: group-color)[],
table.cell(colspan: 12, inset: 4pt, text(size: 8pt, rich-text(
group.description,
))),
)
}
contents.push(table.hline(stroke: 0.35pt + theme.border.lighten(35%)))
}
}
table(
columns: (
0.5em,
7em,
3em,
5em,
1em,
2em,
2em,
1em,
2em,
4em,
1fr,
1em,
1em,
),
inset: (x: 1.5pt, y: 3pt),
align: (x, _) => if x == 1 or x == 10 { left } else { center },
stroke: none,
[],
[],
[],
[],
[],
table.cell(colspan: 2)[Coûts],
[],
table.cell(colspan: 2)[Dégâts],
[],
table.cell(colspan: 2)[Seuils],
table.header(
[],
[],
[Type],
[Timing],
[Ciblage],
[Fatigue],
[Action],
[Élément],
[Fatigue],
[Normaux],
[Effets],
[Parade],
[Esquive],
),
..contents,
)
}
#let render-master-creature(creature) = {
creature-heading(creature, show-database-id: true)
if present(creature.image) {
creature-artwork(creature.image)
identity-table(creature, show-distribution: true)
} else {
identity-table(creature, show-distribution: true)
}
v(1fr)
lore-and-rewards(creature)
pagebreak()
body-table(creature)
v(0.7em)
resistance-table(creature)
v(1fr)
statistics-table(creature)
if creature.phases.len() > 0 {
pagebreak()
[
#show table.cell: it => if it.y == 1 {
text(size: 6pt, align(center + bottom, rotate(
-90deg,
it,
reflow: true,
)))
} else { text(size: 7.5pt, it) }
#attack-table(creature)
]
}
pagebreak()
section-title("Plan de combat")
block(inset: 8pt, text(size: 9pt, rich-text(creature.battle-plan)))
if present(creature.intent-graph) {
v(1em)
section-title("Graphique d'intentions")
block(inset: 8pt, creature.intent-graph)
}
pagebreak()
}
// Public bestiary entry: only the introductory creature sheet is exposed.
#let render-player-creature(creature) = {
creature-heading(creature)
if present(creature.image) {
creature-artwork(creature.image)
identity-table(creature)
} else {
identity-table(creature)
}
v(1fr)
lore-and-rewards(creature)
pagebreak()
}