ravenous_typst/setup/generation/creature-data.typ

296 lines
10 KiB
Plaintext

// Pure-Typst creature database importer.
//
// SQLite is read directly from the project through typsqlite. Every source row
// remains available under `raw`; the renderer-facing fields are derived here so
// database access, relational composition, and presentation stay independent.
#import "@preview/typsqlite:0.1.0": sqlite
#import "../core/creature-timing.typ": initiative
#let db = sqlite(read("/data/src/db/monsters.db", encoding: none))
#let _records(sql) = {
let result = (db.query)(sql)
result.rows.map(row => {
let record = (:)
for (column, value) in result.columns.zip(row) {
record.insert(column, value)
}
record
})
}
// Public raw tables. These intentionally use SELECT * so newly used columns do
// not disappear during normalization and balancing targets remain accessible.
#let creature-rows = _records("SELECT * FROM creature ORDER BY sort_id, id")
#let reward-rows = _records("SELECT * FROM creature_rewards ORDER BY creature_id, reward_id")
#let stats-rows = _records("SELECT * FROM creature_stats ORDER BY creature_id, stats_id")
#let body-part-rows = _records("SELECT * FROM creature_body_parts ORDER BY creature_id, body_part_id")
#let ability-rows = _records(
"SELECT * FROM creature_abilities "
+ "ORDER BY creature_id, "
+ "CASE TRIM(COALESCE(phase, '')) "
+ "WHEN '' THEN 0 WHEN 'Always' THEN 1 WHEN 'Phase1' THEN 2 "
+ "WHEN 'Phase2' THEN 3 WHEN 'Phase3' THEN 4 ELSE 5 END, "
+ "phase, CASE WHEN attack_group IS NULL OR attack_group = '' THEN attack_id ELSE 0 END, "
+ "attack_group, COALESCE(ordering, 2147483647), attack_id",
)
#let balancing-rows = _records("SELECT * FROM creature_balancing ORDER BY creature_id, balancing_id")
#let player-balancing-rows = _records("SELECT * FROM player_balancing ORDER BY player_balancing_id")
#let raw-tables = (
creature: creature-rows,
rewards: reward-rows,
stats: stats-rows,
body-parts: body-part-rows,
abilities: ability-rows,
balancing: balancing-rows,
player-balancing: player-balancing-rows,
)
#let _present(value) = value != none and value != ""
#let _text(value) = if value == none { "" } else { str(value) }
#let _trim(value) = _text(value).trim()
#let _for(rows, creature-id) = rows.filter(row => row.creature_id == creature-id)
#let _first(rows, fallback: none) = if rows.len() == 0 { fallback } else { rows.first() }
#let _first-present(values, fallback: "") = {
let found = values.filter(value => _present(value) and _trim(value) != "")
if found.len() == 0 { fallback } else { found.first() }
}
#let _image-paths = (
"1": "arangar.jpg",
"2": "yajjpnir.jpg",
"3": "mjonn_des_brumes.jpg",
"4": "mjonn_des_brumes_alpha.jpg",
"5": "baloth_joueur.jpg",
"6": "oorgroonth_mou.jpg",
"7": "ormarkiste_penible.jpg",
"8": "Urgaei Givrecornes.jpg",
"9": "abjernide_arroseur.jpg",
"10": "atkeolajakis_noble.jpg",
"11": "askoride_fangeux.jpg",
"12": "arpaneris_commun.jpg",
"13": "jetethl_ah_herault_des_temps_perdus.jpg",
"14": "eleris_crepusculaire.jpg",
"15": "gravan_crapaud.jpg",
"16": "ekrasil_irefeu.jpg",
"17": "kioenkkol.png",
"18": "margrenth_condamne.jpg",
"19": "yynngren_inseparables.jpg",
"20": "nmatithiel_justicar_des_temps_perdus.jpg",
"21": "tarrasque.png",
)
#let _image(core) = {
let filename = _image-paths.at(str(core.id), default: "nodata.png")
"/images/bestiary/" + filename
}
#let _csv(value) = _text(value).split(",").map(it => it.trim()).filter(_present)
#let _initiatives(stats) = {
let p1-values = _csv(stats.p1_init)
let p2-values = _csv(stats.p2_init)
let p1-actions = _csv(stats.p1_actions)
let p2-actions = _csv(stats.p2_actions)
let count = calc.max(p1-values.len(), p2-values.len(), p1-actions.len(), p2-actions.len())
range(count).map(index => (
name: initiative(index + 1),
p1-value: p1-values.at(index, default: ""),
p1-actions: p1-actions.at(index, default: ""),
p2-value: p2-values.at(index, default: ""),
p2-actions: p2-actions.at(index, default: ""),
))
}
#let _part(row, stats) = (
name: row.body_part_name,
p1: (
threshold: (
base: row.threshold_p1,
modifier: [#(row.threshold_p1 - 8) + #stats.size_bonus_to_hit],
),
protection: (base: stats.strength + row.protection_p1, armor: row.protection_p1),
integrity: row.integrity_p1,
life: row.life_points_p1,
),
p2: (
threshold: (
base: row.threshold_p2,
modifier: [#(row.threshold_p2 - 8) + #stats.size_bonus_to_hit],
),
protection: (base: stats.strength + row.protection_p2, armor: row.protection_p2),
integrity: row.integrity_p2,
life: row.life_points_p2,
),
resistances: (
_text(row.slash), _text(row.piercing), _text(row.blunt),
_text(row.celestial), _text(row.fire), _text(row.earth), _text(row.wood),
_text(row.magma), _text(row.abyssal), _text(row.water), _text(row.wind),
_text(row.ice), _text(row.thunder),
),
raw: row,
)
#let _ability(row) = {
let damage = (_text(row.damage_regular), _text(row.success)).filter(_present).join(" ")
let effect-tags = (
if row.armor_break != none {
((key: "rl_arbreak", value: str(row.armor_break)),)
} else { () },
if row.antimaterial != none {
((key: "rl_am", value: str(row.antimaterial)),)
} else { () },
if row.armor_pierce != none {
((key: "rl_armor_pierce", value: str(row.armor_pierce)),)
} else { () },
).flatten()
(
name: row.name,
short-name: row.short_name,
type: row.attack_type,
timing: _text(row.prerequisites),
target: _text(row.targetting),
fatigue-cost: _text(row.cost_fatigue),
action-cost: _text(row.cost_action),
element: _text(row.element),
fatigue-damage: _text(row.damage_fatigue),
damage: damage,
effect-tags: effect-tags,
effects: _text(row.effects),
parry: _text(row.threshold_parry),
dodge: _text(row.threshold_dodge),
repositionning: _text(row.threshold_repositionning),
raw: row,
)
}
#let _phases(rows) = {
let phase-names = ()
for row in rows {
let phase = if _trim(row.phase) == "" { "Général" } else { _trim(row.phase) }
if phase not in phase-names { phase-names.push(phase) }
}
phase-names.map(phase-name => {
let phase-rows = rows.filter(row => {
let candidate = if _trim(row.phase) == "" { "Général" } else { _trim(row.phase) }
candidate == phase-name
})
let group-keys = ()
for row in phase-rows {
// Null groups are deliberately unique: only an explicit DB group joins
// multiple sub-attacks.
let key = if _trim(row.attack_group) == "" {
"attack:" + str(row.attack_id)
} else {
"group:" + _trim(row.attack_group)
}
if key not in group-keys { group-keys.push(key) }
}
let groups = group-keys.map(key => {
let grouped = phase-rows.filter(row => {
let candidate = if _trim(row.attack_group) == "" {
"attack:" + str(row.attack_id)
} else {
"group:" + _trim(row.attack_group)
}
candidate == key
})
(
key: key,
color: grouped.first().attack_type,
description: _text(_first-present(grouped.map(row => row.description_all))),
attacks: grouped.map(_ability),
raw: grouped,
)
})
(name: phase-name, groups: groups, raw: phase-rows)
})
}
#let build-creature(core) = {
let stats-source = _first(_for(stats-rows, core.id))
assert(stats-source != none, message: "Missing creature_stats row for creature " + str(core.id))
let rewards-source = _for(reward-rows, core.id)
let parts-source = _for(body-part-rows, core.id)
let abilities-source = _for(ability-rows, core.id)
let balancing-source = _for(balancing-rows, core.id)
(
id: core.id,
sort-id: core.sort_id,
name: core.name,
denomination: _text(core.denomination),
name-translation: _text(core.name_translation),
calamity: core.calamity,
danger-level: _text(core.danger_level).replace(".", ","),
image: _image(core),
habitat: _text(core.habitat),
region: _text(core.region),
subregion: _text(core.subregion),
locality: _text(core.locality),
dysmorphism: _text(core.dysmorphism),
colors: _text(core.colors),
human-reaction: _text(core.default_human_reaction),
variants: _text(core.variants),
size: _text(core.size),
traces: _text(core.traces),
habits: _text(core.habits),
description: _text(core.description),
annotations: _text(core.annotations),
master-notes: _text(core.annotations_master),
battle-plan: _text(core.battle_plan),
intent-graph: _text(core.intent_graph),
show-to-players: core.show_to_players,
show-to-master: core.show_to_master,
blood: (
base: stats-source.blood_base,
battle: stats-source.blood_battle,
carve: stats-source.blood_carve,
),
rewards: rewards-source.map(row => (
name: _text(row.name), category: _text(row.category),
cost: _text(row.cost), effect: _text(row.effect), raw: row,
)),
body-parts: parts-source.map(row => _part(row, stats-source)),
initiatives: _initiatives(stats-source),
stats: (
strength: stats-source.strength,
perception: stats-source.perception,
willpower: stats-source.willpower,
alteration-resistance: stats-source.alteration_resistance,
resistances: _text(stats-source.resistances),
torque: stats-source.torque,
awareness: stats-source.awareness,
fatigue: stats-source.fatigue,
movement: (
walk: stats-source.mvt_walk, trot: stats-source.mvt_trot,
run: stats-source.mvt_run, flight: stats-source.mvt_flight,
),
transcendental-resistance: stats-source.resistance_transcendentale,
physical-bonus: stats-source.physical_bonus_dmg,
elemental-bonus: stats-source.elemental_bonus_dmg,
size-bonus-to-hit: stats-source.size_bonus_to_hit,
threshold-maluses: _text(stats-source.threshold_maluses),
raw: stats-source,
),
phases: _phases(abilities-source),
raw: (
creature: core,
rewards: rewards-source,
stats: stats-source,
body-parts: parts-source,
abilities: abilities-source,
balancing: balancing-source,
),
)
}
#let creatures = creature-rows.map(build-creature)
#let master-creatures = creatures.filter(creature => creature.show-to-master == 1)
#let player-creatures = creatures.filter(creature => creature.show-to-players == 1)
#let creature-by-id(id) = _first(creatures.filter(creature => creature.id == id))