database_monsters #89

Merged
Dandaedre merged 9 commits from database_monsters into main 2026-07-16 17:32:49 +02:00
17 changed files with 1087 additions and 5 deletions

3
.gitmodules vendored
View File

@ -1,3 +1,4 @@
[submodule "ravenous_databases"]
path = ravenous_databases
url = git@git.dandaedre.com:Ravenous/ravenous_databases.git
# url = git@git.dandaedre.com:Ravenous/ravenous_databases.git
url = https://proxy.dandaedre.com/gitea/Ravenous/ravenous-tools.git

View File

@ -41,6 +41,7 @@ fast_class = {path = "./crates/fast_class"}
formatter = {path = "./crates/formatter"}
weaponry = {path = "./crates/weaponry"}
more_fields = {path = "./crates/more_fields"}
monsters = {path = "./crates/monsters"}
anyhow = "1.0.103"
toml = "1.1.3"
@ -55,3 +56,4 @@ glob = "0.3.3"
tokio = { version = "1.52.3", features = ["full"] }
dynfmt = { version = "0.1.5", features = ["curly"] }
pretty_assertions = "^1.4"
indexmap = "2.14.0"

View File

@ -8,7 +8,8 @@ use config::{
fast_tables::FastTableConfig,
formatter::FormatterConfig,
graph::GraphConfig,
make::{MakeTargets, VerboseLevel, HELP_BLOCK_SELECTION},
make::{HELP_BLOCK_SELECTION, MakeTargets, VerboseLevel},
monsters::{MonsterConfig, MonsterMarkup},
statsolver::StatConfig,
tablegen::{Craft, TableArgs},
};
@ -48,6 +49,8 @@ pub enum Commands {
Analysis(AnalysisConfig),
/// Better Generation
BetterGen(FastTableConfig),
/// Monster database handling
Monsters(MonsterConfig),
}
#[derive(Debug, Args)]
@ -74,6 +77,8 @@ pub struct Config {
pub classes: Classes,
/// Config for all the tables
pub craft: Craft,
/// Config for monster exporting
pub monster: MonsterMarkup,
}
#[derive(Deserialize)]

View File

@ -7,3 +7,5 @@ edition = "2024"
clap = {workspace = true}
serde = {workspace = true}
phf = {workspace = true}
indexmap = {workspace = true}
anyhow = {workspace = true}

View File

@ -12,5 +12,6 @@ pub mod fast_tables;
pub mod formatter;
pub mod graph;
pub mod make;
pub mod monsters;
pub mod statsolver;
pub mod tablegen;

View File

@ -0,0 +1,152 @@
// Workspace: config
// File: config/src/monsters.rs
//! The inner config for monster module
//!
#![allow(dead_code)]
use anyhow::Result;
use clap::{Args, ValueEnum};
use indexmap::IndexMap;
use serde::{Deserialize, Deserializer};
#[derive(Args, Debug, Clone)]
/// The configuration struct for the Graph
pub struct MonsterConfig {
/// Special target
pub target: MonsterTarget,
/// Database to load from
#[arg(short, long, default_value = "./ravenous_databases/monsters.db")]
pub database: String,
/// Clean all the artefacts (including generated images)
#[arg(short, long)]
pub all: bool,
}
#[derive(ValueEnum, Debug, Clone)]
/// The action to execute
pub enum MonsterTarget {
/// Clean the generated monsters directory
Clean,
/// Generate the monster list
Export,
/// Show useful data
Show,
}
/// Configuration data for generating a monster sheet.
///
/// The values are plain LaTeX fragments stored in the `[monster]` section of a `.toml`
#[allow(dead_code)]
#[derive(Deserialize)]
pub struct MonsterMarkup {
/// Header of the page (image + basic attributes).
pub intro: String,
/// Body‑parts section header.
pub body_parts_intro: String,
/// One row of the body‑parts table.
pub body_parts_row: String,
/// Body‑parts table footer.
pub body_parts_end: String,
/// Rewards section header (the table that lists each reward).
pub rewards_row: String,
/// Rewards table footer.
pub rewards_end: String,
/// Resists section header.
pub resists_intro: String,
/// The blood reward template.
pub blood_reward: String,
/// One line of the resistances table.
pub resists_row: String,
/// Resists table footer.
pub resists_end: String,
/// Stats section (movement, initiative, etc.).
pub stats: String,
/// The row of initiatives (turn 2 onwards)
pub init_rows: String,
/// The end of the initiatives
pub init_end: String,
/// Header of the attacks section.
pub attacks_intro: String,
/// Footer of the attacks section.
pub attacks_end: String,
/// Row used for each attack’s data (IDs, types, damage, etc.).
pub phase_row: String,
/// The color of the attack row
pub attack_color: String,
/// Before attack
pub attack_before_repeat: String,
/// Row that lists repeatable attacks.
pub attack_repeatable_row: String,
/// Row that contains additional information for an attack.
pub attack_info_row: String,
/// The intent table & Battle plan
pub intent_table: String,
/// Color map
#[serde(deserialize_with = "parse_monster_color")]
pub color_table: MonsterColor,
/// Default color
pub default_color: String,
}
/// Ghetto color import
pub struct MonsterColor {
/// Inner color
pub inner: IndexMap<String, String>,
}
impl std::ops::Deref for MonsterColor {
type Target = IndexMap<String, String>;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
/// Parse the monster colors from a toml
fn parse_monster_color<'de, D>(deserializer: D) -> Result<MonsterColor, D::Error>
where
D: Deserializer<'de>,
{
let color = String::deserialize(deserializer)?;
Ok(MonsterColor {
inner: color
.lines()
.filter_map(|line| {
let line = line.trim();
if line.is_empty() {
return None;
}
// Split at the first ':' only.
let mut parts = line.splitn(2, ':');
let key = parts.next()?.trim().to_string();
let value = parts.next().map(|v| v.trim()).ok_or(()).ok()?;
Some((key, value.to_owned()))
})
.collect(),
})
}

View File

@ -31,7 +31,7 @@ pub struct TableArgs {
pub filenames: Vec<String>,
}
// This config is can contain unconstructed code for compatibility purposes
// This config can contain unconstructed code for compatibility purposes
#[allow(dead_code)]
#[derive(Deserialize)]
/// The Craft configs

View File

@ -12,8 +12,8 @@ serde = {workspace = true}
toml = {workspace = true}
tokio = {workspace = true}
dynfmt = {workspace = true}
indexmap = {workspace = true}
indicatif = { version = "0.18.6", features = ["rayon"] }
logos = "0.16.1"
indexmap = "2.14.0"
console = "0.16.4"

View File

@ -0,0 +1,21 @@
[package]
name = "monsters"
edition = "2024"
version.workspace = true
[dependencies]
config = {workspace = true}
cli_parser = {workspace = true}
more_fields = {workspace = true}
anyhow = {workspace = true}
indexmap = {workspace = true}
serde = {workspace = true}
rusqlite = { version = "0.40.1" } # , features = ["bundled"]
serde_rusqlite = "0.43.0"
strum = { version = "0.28.0", features = ["derive"] }
handlebars = "6.4.3"
[dev-dependencies]
regex = {workspace = true}
pretty_assertions = {workspace = true}
clap = {workspace = true}

View File

@ -0,0 +1,43 @@
//! # Monsters Module
//!
//! The `monsters` crate orchestrates the processing of *ravenous* monster data.
//!
//! It can:
//! * **Parse** raw monster definitions into ergonomic Rust structs.
//! * Perform **balancing** calculations to keep encounters fair.
//! * **Show** concise, human‑readable summaries in the terminal.
//! * **Export** processed data as LaTeX/TeX for printing or further editing.
//!
//! All functionality is exposed through a single entry point:
//! [`monsters_dispatch`]. The dispatcher interprets command‑line arguments
//! (`MonsterConfig`) and delegates to the appropriate sub‑routine (clean, export or show).
//!
use crate::monster_export::generate_monsters_tex;
use anyhow::Context;
mod monster_database;
mod monster_export;
pub mod monster_structs;
use anyhow::Result;
use cli_parser::Config;
use config::monsters::MonsterConfig;
use rusqlite::Connection;
/// Dispatches the chosen monster action.
pub fn monsters_dispatch(args: &MonsterConfig, config: &Config) -> Result<()> {
// use config::monsters::MonsterTarget;
let connection =
Connection::open(&args.database).context(format!("Opening database {}", args.database))?;
generate_monsters_tex(args, config, connection)?;
// templates
// match args.target {
// MonsterTarget::Clean => todo!("implement cleaning logic"),
// MonsterTarget::Export => todo!("implement export logic"),
// MonsterTarget::Show => todo!("implement show logic"),
// }
Ok(())
}

View File

@ -0,0 +1,122 @@
#![allow(dead_code)]
use crate::monster_structs::{self, CreatureReward};
use crate::monster_structs::{
CreatureBodyPart, CreatureData, CreatureListAttacks, CreatureStats, FullMonster,
MonsterSingleAttack,
};
use anyhow::{Context, anyhow};
use rusqlite::Connection;
use serde::de::DeserializeOwned;
/// Deserialise a table row (or rows) into the given type and add a nice context message.
macro_rules! fetch_from {
($ty:ty, $connection:expr,$name:expr, $table:expr, $cols_opt:expr) => {{
// `connection` and `creature.name` must be in scope when the macro is expanded
generic_deserialize::<$ty>(
&$connection,
$table,
Some(&format!("creature_id={}", $name.id)),
$cols_opt,
)
.context(format!("Fetching {} from {}", $table, $name.name))?
}};
}
pub(crate) fn fetch_all_data(connection: Connection) -> Result<Vec<FullMonster>, anyhow::Error> {
let list_creatures =
generic_deserialize::<CreatureData>(&connection, "creature", None, Some("id"))?;
let mut finished_creatures = Vec::new();
for creature in list_creatures.iter() {
// println!("Working on {}@{}", creature.id, creature.name);
let creature_attacks = fetch_from!(
MonsterSingleAttack,
connection,
creature,
"creature_abilities",
Some("phase, attack_group")
);
let creature_resistances = fetch_from!(
CreatureBodyPart,
connection,
creature,
"creature_body_parts",
Some("body_part_name")
);
let creature_stats =
fetch_from!(CreatureStats, connection, creature, "creature_stats", None);
if creature_stats.len() != 1 {
return Err(anyhow!(
"The stat line for the creature {} should be exactly one found {}",
creature.name,
creature_stats.len()
));
};
let creature_stats = creature_stats.first().unwrap().clone();
let creature_rewards = fetch_from!(
CreatureReward,
connection,
creature,
"creature_rewards",
None
);
finished_creatures.push(FullMonster {
id: creature.id,
name: creature.name.clone(),
stats: creature_stats,
attacks: CreatureListAttacks {
attacks: creature_attacks,
},
body_parts: monster_structs::CreatureListBodyParts {
body_parts: creature_resistances,
},
data: creature.clone(),
rewards: monster_structs::CreatureListRewards {
rewards: creature_rewards,
},
});
}
Ok(finished_creatures)
}
/// A generic Deserialisation from a database
fn generic_deserialize<T: more_fields::FieldsAsSlice + DeserializeOwned>(
connection: &Connection,
table_name: &str,
filter: Option<&str>,
sort: Option<&str>,
) -> Result<Vec<T>, anyhow::Error> {
let info = format!(
"Querying data on {} with {} WHERE {:?} ORDER BY {:?}",
table_name,
std::any::type_name::<T>(),
filter,
sort,
);
let generate_select_query = generate_select_query::<T>(table_name, filter, sort);
// println!("{}", generate_select_query);
let mut r = connection.prepare(&generate_select_query).context(info)?;
let rows = r.query([])?;
let r = serde_rusqlite::from_rows::<T>(rows).collect::<Result<Vec<T>, serde_rusqlite::Error>>();
r.context("No")
}
fn generate_select_query<T: more_fields::FieldsAsSlice>(
table_name: &str,
filter: Option<&str>,
sort: Option<&str>,
) -> String {
format!(
"SELECT {} FROM {}{}{};",
T::attributes_slice()
.iter()
.map(|(k, _v)| k.to_owned())
.collect::<Vec<_>>()
.join(","),
table_name,
filter.map_or_else(String::default, |j| " WHERE ".to_string() + j),
sort.map_or_else(String::default, |j| " ORDER BY ".to_string() + j)
)
}

View File

@ -0,0 +1,210 @@
//! Monster export module
use anyhow::{Context, Result};
use cli_parser::Config;
use config::monsters::MonsterConfig;
use handlebars::Handlebars;
use indexmap::IndexMap;
use rusqlite::Connection;
use serde::Serialize;
use std::fmt::Write;
use crate::{
monster_database::fetch_all_data,
monster_structs::{
MonsterAllAttacks, MonsterFullAttack, MonsterRepetableInitRow, MonsterSingleAttack,
},
};
/// Load a template from a struct field into a `templates` collection.
///
/// $templates – the variable that holds the template collection
/// $cfg_path – any path (e.g. `config`, `self.cfg`, …) that points to a
/// struct containing the field we want
/// $name – the identifier of the field / template name
macro_rules! template_load {
($templates:ident, $cfg_path:expr, $name:ident) => {{
$templates
.register_template_string(
stringify!($name), // "intro"
&$cfg_path.$name, // &config.monster.intro
)
.context(concat!("Registering ", stringify!($name), " template"))? // ? propagates errors
}};
}
pub trait ToTex {
fn export_to_tex(self) -> String;
}
fn load_templates(config: &Config) -> Result<Handlebars<'_>> {
let mut templates = Handlebars::new();
template_load!(templates, &config.monster, intro);
template_load!(templates, &config.monster, body_parts_row);
template_load!(templates, &config.monster, body_parts_end);
template_load!(templates, &config.monster, blood_reward);
template_load!(templates, &config.monster, rewards_row);
template_load!(templates, &config.monster, init_rows);
template_load!(templates, &config.monster, resists_row);
template_load!(templates, &config.monster, stats);
template_load!(templates, &config.monster, phase_row);
template_load!(templates, &config.monster, attack_color);
template_load!(templates, &config.monster, attack_repeatable_row);
template_load!(templates, &config.monster, attack_info_row);
template_load!(templates, &config.monster, intent_table);
Ok(templates)
}
// TODO: Create a method on the struct instead of this inane bs
/// Export a tex with the given config and arguments
pub fn generate_monsters_tex(
args: &MonsterConfig,
config: &Config,
connection: Connection,
) -> std::result::Result<(), anyhow::Error> {
let all_monsters = fetch_all_data(connection)?;
let templates = load_templates(config)?;
let mut out = String::new();
let creature = &all_monsters[0];
write!(out, "{}", templates.render("intro", &creature.data)?)?;
write!(
out,
"{}",
templates.render("blood_reward", &creature.stats)?
)?;
for reward in creature.rewards.rewards.iter() {
write!(out, "{}", templates.render("rewards_row", reward)?)?;
}
write!(out, "{}", &config.monster.rewards_end)?;
write!(out, "{}", &config.monster.body_parts_intro)?;
for part in creature.body_parts.body_parts.iter() {
write!(out, "{}", templates.render("body_parts_row", part)?)?;
}
write!(
out,
"{}",
templates.render("body_parts_end", &creature.data)?
)?;
// TODO: Maybe add modularity and not print empty resists
write!(out, "{}", &config.monster.resists_intro)?;
for part in creature.body_parts.body_parts.iter() {
write!(out, "{}", templates.render("resists_row", part)?)?;
}
write!(out, "{}", &config.monster.resists_end)?;
write!(out, "{}", &config.monster.stats)?;
write!(out, "{}", templates.render("stats", &creature.stats)?)?;
for init in MonsterRepetableInitRow::vec_from(
&creature.stats.p1_init,
&creature.stats.p2_init,
&creature.stats.p1_actions,
&creature.stats.p2_actions,
)
.iter()
.skip(1)
{
write!(out, "{}", templates.render("init_rows", init)?)?;
}
let all_attacks = MonsterAllAttacks::from_retrieved_data(&creature.attacks.attacks);
println!("{:#?}", all_attacks);
all_attacks.to_tex(&templates, config)?;
write!(out, "{}", &config.monster.attacks_intro)?;
write!(out, "{}", &config.monster.attacks_end)?;
write!(out, "{}", templates.render("intent_table", &creature.data)?)?;
// println!("{}", out);
Ok(())
}
impl MonsterAllAttacks {
pub fn from_retrieved_data(original_data: &[MonsterSingleAttack]) -> MonsterAllAttacks {
let mut initial_phases: IndexMap<&String, Vec<&MonsterSingleAttack>> = IndexMap::new();
let mut phases: IndexMap<String, Vec<MonsterFullAttack>> = IndexMap::new();
// Intermediate split with hashmaps
for atk in original_data {
if let Some(values) = initial_phases.get_mut(&atk.phase) {
values.push(atk);
} else {
initial_phases.insert(&atk.phase, vec![atk]);
}
}
for (phase, phase_atks) in initial_phases.iter() {
let mut grouped_attacks: IndexMap<&Option<String>, Vec<&MonsterSingleAttack>> =
IndexMap::new();
let phase_name = phase.to_string();
phases.insert(phase_name.clone(), Vec::new());
for &atk in phase_atks {
if let Some(values) = grouped_attacks.get_mut(&atk.attack_group) {
values.push(atk);
} else {
grouped_attacks.insert(&atk.attack_group, vec![atk]);
}
}
for (group, atk) in grouped_attacks {
if group.is_some() {
let group_attack = MonsterFullAttack {
attacklist: atk.iter().map(|&v| v.clone()).collect(),
color: atk.first().unwrap().short_name.clone(),
description: atk.first().unwrap().effects.clone(),
};
phases.get_mut(&phase_name).unwrap().push(group_attack);
} else {
for single_atk in atk {
phases
.get_mut(&phase_name)
.unwrap()
.push(MonsterFullAttack {
attacklist: vec![single_atk.clone()],
color: single_atk.short_name.clone(),
description: single_atk.effects.clone(),
});
}
};
}
}
Self { phases }
}
}
#[derive(Serialize)]
struct Coloring<'a> {
color: &'a str,
}
impl MonsterAllAttacks {
pub fn to_tex(&self, templates: &Handlebars<'_>, config: &Config) -> Result<String> {
let mut out = String::new();
for (phase, list_full_attacks) in &self.phases {
// Print phase name
write!(out, "{}", templates.render("phase_row", phase)?)?;
for attack in list_full_attacks {
write!(out, "{}", config.monster.attack_before_repeat)?;
for sub_attack in &attack.attacklist {
let color = Coloring {
color: config
.monster
.color_table
.inner
.get(&attack.color)
.unwrap_or(&config.monster.default_color),
};
write!(out, "{}", templates.render("attack_color", &color)?)?;
write!(
out,
"{}",
templates.render("attack_repeatable_row", sub_attack)?
)?;
}
write!(
out,
"{}",
templates.render("attack_info_row", &list_full_attacks[0])?
)?;
}
// Print all attacks in that phase
println!("{}", out);
}
Ok(out)
}
}

View File

@ -0,0 +1,372 @@
//! # Monster Structures
//!
//! The `monster_structs` module defines the data model that represents a monster
//! as it is loaded from the database. All structs are intentionally kept
//!
//! ## Overview
//! ```text
//! FullMonster → MonsterStats
//! ↘ MonsterAttacks → Vec<MonsterSingleAttack>
//! ↗ MonsterResistances → Vec<MonsterSingleResistance>
//! ```
//!
#![allow(dead_code)]
use indexmap::IndexMap;
use more_fields::FieldsAsSlice;
use serde::{Deserialize, Serialize};
/// A monster ready for consumption by other modules.
pub struct FullMonster {
/// Unique identifier, derived when the monster is instantiated.
pub id: i64,
/// Monster’s name.
pub name: String,
/// Serialized generic data directly copied from the database table.
pub data: CreatureData,
/// Collection of attacks, wrapped in a helper that exposes useful functions.
pub attacks: CreatureListAttacks,
/// Collection of resistances, wrapped in a helper for convenient iteration.
pub body_parts: CreatureListBodyParts,
/// Collection of all the rewards, wraped in a helper for iteration.
pub rewards: CreatureListRewards,
/// Serialized stats directly copied from the database table.
pub stats: CreatureStats,
}
/// One row from the `creature` table.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, FieldsAsSlice)]
pub struct CreatureData {
/// Primary key – auto‑incremented by SQLite.
#[INTEGER]
pub id: i64, // INTEGER primary key
/// Text columns – stored as plain UTF‑8 text in SQLite.
#[TEXT]
pub name: String,
/// The calamity type of the creature
#[TEXT]
pub calamity: String,
/// The image describing the creature
#[TEXT]
pub image: String,
/// The HSE danger level
#[INTEGER]
pub danger_level: i64,
/// Type of habitat
#[TEXT]
pub habitat: String,
/// Wether a dismorphism exists
#[TEXT]
pub dysmorphism: String,
/// Generic color describing the creature
#[TEXT]
pub colors: String,
/// Default reaction to human presence
#[TEXT]
pub default_human_reaction: String,
/// Known variants
#[TEXT]
pub variants: String,
/// General habits
#[TEXT]
pub habits: String,
/// Generic creature description
#[TEXT]
pub description: String,
/// Annotations
#[TEXT]
pub annotations: String,
/// Annotations GM
#[TEXT]
pub annotations_master: Option<String>,
/// The battle plan of the creature
#[TEXT]
pub battle_plan: String,
/// The graph of intents (image)
#[TEXT]
pub intent_graph: String,
}
/// A helper wrapper around all rewards
pub struct CreatureListRewards {
pub rewards: Vec<CreatureReward>,
}
/// One row from the `rewards` table.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, FieldsAsSlice)]
pub struct CreatureReward {
/// The id of the creature that owns the reward (FOREIGN KEY to `creature_data.id`).
#[INTEGER]
pub creature_id: i64,
/// Full name of the reward.
#[TEXT]
pub name: String,
/// Category of the ability
#[TEXT]
pub category: String,
/// Effect of the ability
pub effect: String,
}
/// A helper wrapper around all attacks belonging to a monster.
///
/// The inner vector holds individual attack rows (`MonsterSingleAttack`);
/// helper methods on this struct (not shown here) can split or aggregate
/// these rows into more ergonomic data structures.
pub struct CreatureListAttacks {
/// All attack rows for the monster, as read from the database.
pub attacks: Vec<MonsterSingleAttack>,
}
/// A helper wrapper around all resistances belonging to a monster.
///
/// The inner vector contains `MonsterSingleResistance` entries; methods
/// on this struct can provide iterators or lookup functions that are
/// easier to consume than raw rows.
pub struct CreatureListBodyParts {
/// All resistance rows for the monster, as read from the database.
pub body_parts: Vec<CreatureBodyPart>,
}
/// Represents a single attack entry as deserialized from the database.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, FieldsAsSlice)]
pub struct MonsterSingleAttack {
/// The id of the creature that owns the ability (FOREIGN KEY to `creature_data.id`).
#[INTEGER]
pub creature_id: i64,
/// Full name of the ability.
#[TEXT]
pub name: String,
/// Short trigram used in combat logs, etc.
#[TEXT]
pub short_name: String,
/// Which phase(s) of a turn can the ability be used
#[TEXT]
pub phase: String,
/// Attack grouping, for multiple entries in one attack
#[INTEGER]
pub attack_group: Option<String>,
/// Ability “type” as a trigram
#[TEXT]
pub attack_type: String,
/// How the ability targets opponents (e.g. “single”, “area” …).
#[TEXT]
pub targetting: Option<String>,
/// Fatigue cost for activating the ability.
#[INTEGER]
pub cost_fatigue: Option<String>,
/// Action‑point cost (used in systems where actions and fatigue are separate).
#[INTEGER]
pub cost_action: Option<String>,
/// Element or school that powers the ability.
#[TEXT]
pub element: Option<String>,
/// Damage dealt as a *fatigue* penalty (i.e. non‑instant death).
#[INTEGER]
pub damage_fatigue: Option<String>,
/// Regular textual description
#[TEXT]
pub damage_regular: Option<String>,
/// All “effects” that happen when the ability resolves.
/// The string format is up‑to‑you – many people store JSON or a custom DSL here.
#[TEXT]
pub effects: String,
/// Minimum parry rating required to avoid the ability’s effect.
#[INTEGER]
pub threshold_parry: Option<i64>,
/// Minimum dodge rating required to avoid the ability’s effect.
#[INTEGER]
pub threshold_dodge: Option<i64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, FieldsAsSlice)]
/// All different body parts and their different resists
pub struct CreatureBodyPart {
#[INTEGER]
pub creature_id: i64,
#[TEXT]
pub body_part_name: String,
#[INTEGER]
pub threshold_p1: Option<i64>,
#[INTEGER]
pub threshold_p2: Option<i64>,
#[INTEGER]
pub protection_p1: Option<i64>,
#[INTEGER]
pub protection_p2: Option<i64>,
#[INTEGER]
pub integrity_p1: Option<i64>,
#[INTEGER]
pub integrity_p2: Option<i64>,
#[INTEGER]
pub life_points_p1: Option<i64>,
#[INTEGER]
pub life_points_p2: Option<i64>,
#[TEXT]
pub slash: Option<String>,
#[TEXT]
pub blunt: Option<String>,
#[TEXT]
pub piercing: Option<String>,
#[TEXT]
pub celestial: Option<String>,
#[TEXT]
pub fire: Option<String>,
#[TEXT]
pub magma: Option<String>,
#[TEXT]
pub earth: Option<String>,
#[TEXT]
pub wood: Option<String>,
#[TEXT]
pub abyssal: Option<String>,
#[TEXT]
pub wind: Option<String>,
#[TEXT]
pub water: Option<String>,
#[TEXT]
pub ice: Option<String>,
#[TEXT]
pub thunder: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, FieldsAsSlice)]
/// All creature stats
pub struct CreatureStats {
#[INTEGER]
pub creature_id: i64,
#[TEXT]
pub p1_init: MonsterInitString,
#[TEXT]
pub p2_init: MonsterInitString,
#[TEXT]
pub p1_actions: MonsterInitString,
#[TEXT]
pub p2_actions: MonsterInitString,
#[INTEGER]
pub strength: i64,
#[INTEGER]
pub perception: i64,
#[INTEGER]
pub willpower: i64,
#[INTEGER]
pub alteration_resistance: i64,
#[INTEGER]
pub torque: i64,
#[INTEGER]
pub awareness: i64,
#[INTEGER]
pub fatigue: i64,
#[INTEGER]
pub mvt_walk: i64,
#[INTEGER]
pub mvt_trot: i64,
#[INTEGER]
pub mvt_run: i64,
#[INTEGER]
pub mvt_flight: Option<i64>,
#[INTEGER]
pub blood_base: i64,
#[INTEGER]
pub blood_battle: i64,
#[INTEGER]
pub blood_carve: i64,
}
// ----------- HERE BE WARCRIMES -------------
#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
#[serde(transparent)]
/// A custom string used to avoid work
pub struct MonsterInitString {
inner: String,
}
/// A monster init row (entire)
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct MonsterRepetableInitRow {
pub turn: usize,
pub p1_value: String,
pub p1_actions: String,
pub p2_value: String,
pub p2_actions: String,
}
impl MonsterRepetableInitRow {
pub fn vec_from(
p1_vals: &MonsterInitString,
p2_vals: &MonsterInitString,
p1_acts: &MonsterInitString,
p2_acts: &MonsterInitString,
) -> Vec<Self> {
let p1_vals = MonsterRepetableInitValue::from(p1_vals);
let p2_vals = MonsterRepetableInitValue::from(p2_vals);
let p1_acts = MonsterRepetableInitValue::from(p1_acts);
let p2_acts = MonsterRepetableInitValue::from(p2_acts);
p1_acts
.inner
.iter()
.zip(p2_acts.inner.iter())
.zip(p1_vals.inner.iter())
.zip(p2_vals.inner.iter())
.enumerate()
.map(|(turn, (((p1_actions, p2_actions), p1_value), p2_value))| {
MonsterRepetableInitRow {
p1_value: p1_value.clone(),
p1_actions: p1_actions.clone(),
p2_value: p2_value.clone(),
p2_actions: p2_actions.clone(),
turn: turn + 1,
}
})
.collect::<Vec<Self>>()
}
}
#[derive(Debug, Clone)]
/// A repeteable init string
pub struct MonsterRepetableInitValue {
inner: Vec<String>,
}
impl From<&MonsterInitString> for MonsterRepetableInitValue {
fn from(value: &MonsterInitString) -> Self {
Self {
inner: value.inner.split(',').map(|s| s.to_string()).collect(),
}
}
}
impl Serialize for MonsterInitString {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let mut c = self.inner.split(',');
serializer.collect_str(
c.next()
.unwrap_or_else(|| panic!("Trying to split {} by ','", self.inner)),
)
}
}
/// The full list of all monster attacks
///
/// Split by phasing
#[derive(Debug)]
pub struct MonsterAllAttacks {
pub phases: IndexMap<String, Vec<MonsterFullAttack>>,
}
/// A single attack, grouping all sub attacks
/// Also extract extra info to allow easier insertions
#[derive(Serialize, Deserialize, Debug)]
pub struct MonsterFullAttack {
pub attacklist: Vec<MonsterSingleAttack>,
pub color: String,
pub description: String,
}

View File

@ -17,6 +17,7 @@ clap = {workspace = true}
tokio = {workspace = true}
formatter = {workspace = true}
weaponry = {workspace = true}
monsters = {workspace = true}
[package.metadata.cargo-machete]
ignored = ["tokio"]

View File

@ -10,6 +10,7 @@ use fast_class::make_better_gen;
use formatter::format_file;
use graphs::make_graphs;
use make::make_pdf;
use monsters::monsters_dispatch;
use stats::stat_solver;
use tablegen::table_gen;
use weaponry::analysis::launch_analysis;
@ -37,6 +38,7 @@ fn main() -> Result<()> {
Commands::Format(args) => format_file(&args, &config),
Commands::Analysis(args) => Ok(launch_analysis(&args, &config)?), // Not using anyhow but a custom error
Commands::BetterGen(args) => make_better_gen(&args, &config),
Commands::Monsters(args) => monsters_dispatch(&args, &config),
}
}

View File

@ -146,3 +146,151 @@ end_long_side = ''' \hline
\end{longtblr}
\end{center}\end{landscape}'''
end_empty = ""
[monster]
intro = '''\begin{tblr}{
vspan=even, hspan=minimal,
colspec={X[-1] X[-1]},
cell{1}{1}={c=2}{c},
}
\includegraphics[height=5cm]{{image}} & \\
& \\
Nom & {{name}} \\
Dénomination & {{denomination}} \\
Calamité & {{calamity}} \\
Niveau de danger (HSE) & {{danger_level}} \\
& \\
Habitat & \SetCell{font=\footnotesize} {{habitat}} \\
Dysmorphisme & \SetCell{font=\footnotesize} {{dismorphism}} \\
Couleurs & \SetCell{font=\footnotesize} {{colors}} \\
Réaction à l'homme & \SetCell{font=\footnotesize} {{default_human_reaction}} \\
Variantes & \SetCell{font=\footnotesize} {{variants}}\\
Mœurs & \SetCell{font=\footnotesize} {{habits}} \\
\end{tblr}
\vfill
\begin{tblr}{
colspec={X[-1]},
hline{2,4,6},
row{2,4,6}={font=\footnotesize}
}
\textbf{Description} \\
{{description}} \\
\textbf{Annotations} \\
{{annotations}} \\
\textbf{Récompenses} \\
\end{tblr}
\begin{tblr}{
colspec={X[-1] X[-1,c] X[-1,j]},
vspan=even, hspan=minimal,
row{1-Z}={font=\footnotesize},
rows={m},
}
'''
blood_reward='''
\SetCell[c=2]{j} Sang (base, combat, dépeçage) & & {{blood_base}}, {{blood_battle}}, {{blood_carve}} \\
'''
rewards_row=''' {{name}} & {{category}} & {{effect}} \\
'''
rewards_end='''\end{tblr}
\vfill
'''
body_parts_intro='''
\begin{tblr}{
colspec={X[l,-1] X[-1] X[-1] X[] X[] X[-1] X[-1] X[] X[]},
rowspec={X[t] X[t,c] X[c,2em] X[c,2em] X[c,2em] X[c,2em] X[c,2em] X[c,2em] X[c,2em] X[c,2em] X[c,2em] X[j,5em]},
hspan=minimal,
cell{1}{2}={c=4}{c},
cell{1}{6}={c=4}{c},
row{2,12}={font=\footnotesize},
vline{6} = {2-11}{solid},
}
& P1 & & & & P2 & \\
& Seuil & Prot & Intégrité & PV & Seuil & Prot & Intégrité & PV\\
\hline
'''
body_parts_row='''\SetCell{font=\footnotesize} {{body_part_name}} & ${{threshold_p1}}$ & ${{protection_p1}}$ & \SetCell{r,f}\tiny${{integrity_p1}}$ & \SetCell{r,f}\tiny${{life_points_p1}}$ & ${{threshold_p2}}$ & ${{protection_p2}}$ & \SetCell{r,f}\tiny${{integrity_p2}}$ & \SetCell{r,f}\tiny${{life_points_p2}}$\\'''
body_parts_end= ''' \hline
\SetCell[c=9]{j,h} {\textbf{Notes} \\ {{annotations_master}}\\
\hline
\end{tblr}'''
resists_intro=''' \center{
\begin{tblr}{
colspec={Q[3.5em] Q[1.6em] Q[1.6em] Q[1.6em] Q[1.6em] Q[1.6em] Q[1.6em] Q[1.6em] Q[1.6em] Q[1.6em] Q[1.6em] Q[1.6em] Q[1.6em]},
rowspec={Q[c,f] Q[c,m] Q[c] Q[c] Q[c] Q[c] Q[c] Q[c] Q[c] Q[c] Q[c]},
row{3-11}={font=\tiny},
}
& & & & & & & \small{*} & & & & \small{*} & \small{*} & \\
\SetCell{c} Res & \slash & \pierce & \blunt & \symceleste & \symfire & \symearth & \symwood & \symmagma & \symabyss & \symwater & \symwind & \symice & \symthunder \\
\hline
'''
resists_row= ''' \SetCell{font=\footnotesize} {{name}} & ${{slash}}$ & ${{pierce}}$ & ${{blunt}}$ & ${{celestial}}$ & ${{fire}}$ & ${{earth}}$ & ${{wood}}$ & ${{magma}}$ & ${{celeste}}$ & ${{water}}$ & ${{wind}}$ & ${{ice}}$ & ${{thunder}}$ \\
'''
resists_end=' \end{tblr}'
stats='''\begin{tblr}{
colspec={c c c c c c c c c c c c c c c c c c c},
row{2}={font=\footnotesize},
row{3-6}={font=\tiny},
}
& \SetCell[c=2]{c} P1 & & \SetCell[c=2]{c} P2 & & & \SetCell[c=7]{c} Stats & & & & & & & & \SetCell[c=4]{c} Mouvement & & & & \\
\cline{2-3} \cline{4-5} \cline{7-13} \cline{15-18}
\rb{Initiative} & \rb{Valeur} & \rb{Actions} & \rb{Valeur} & \rb{Actions} & & \rb{Force} & \rb{Perception} & \rb{Volonté} & \rb{Res Alt} & \rb{Torque} & \rb{Vigilance} & \rb{Fatigue} & & \rb{Marche} & \rb{Trot} & \rb{Course} & \rb{Vol} \\
\SetCell{font=\footnotesize}$t_1$ & ${{p1_init}}$ & $4$A & ${{p2_init}}$ & $4$A & & ${{strength}}$ & ${{perception}}$ & ${{willpower}}$ & ${{alteration_resistance}}$ & ${{torque}}$ & ${{awareness}}$ & ${{fatigue}}$ & & ${{mvt_walk}}$ & ${{mvt_trot}}$ & ${{mvt_run}}$ & ${{mvt_flight}}$ \\
'''
init_rows='''
\SetCell{font=\footnotesize}$t_{{turn}}$ & ${{p1_value}}$ & {{pt1_actions}} & ${{p2_value}}$ & {{p2_actions}} \\
'''
init_end= '''
\end{tblr}
}
\vfill '''
attacks_intro= '''\scriptsize{
\begin{tblr}{
colspec={X[0.05] X[4,l] X[1,c] X[1,c] X[0.3,c] X[0.3,c] X[0.3,c] X[0.3,c] X[0.3,c] X[2,r] X[2,c] X[0.3,c] X[0.3,c]},
hspan=minimal,
colsep=2pt,
row{2}={font=\tiny},
}
& & & & & \SetCell[c=2]{c} Coûts & & & \SetCell[c=2]{c} Dégâts & & & \SetCell[c=2]{c} Seuils & \\
\cline{6-7} \cline{9-10} \cline{12-13}
& \SetCell{c} & {ID} & {Type} & \rb{Ciblage} & \rb{Fatigue} & \rb{Action} & \rb{Élément} & \rb{Fatigue} & \SetCell{c} \rb{Normaux} & {Effets} & \rb{Parade} & \rb{Esquive} \\
\SetHline{1-13}{solid}
'''
phase_row= '''
\SetHline{1}{0pt}
\SetCell[c=13]{white} {{phase_name}} & & & & & & & & & & \\
'''
attack_before_repeat=' \hline'
attack_color='\SetCell[r=2]{bg={{color}}}' # Very ugly hack, going to bed
attack_repeatable_row= ''' & {{name}} & {{short_name}} & {{atk_type}} & {{targetting}} & {{cost_fatigue}} & {{cost_action}} & {{element}} & {{damage_fatigue}} &{{damage_regular}} & {{effects}} & {{threshold_parry}} & {{threshold_dodge}} \\
'''
attack_info_row='''& \SetCell[c=12]{j} {{description}} & & & & & & & & & & \\
\hline
'''
attacks_end= ''' \end{tblr}
}
\vfill
\renewcommand{\rb}{\undefined}
'''
intent_table=''' \begin{tblr}{
colspec={X[7] X[3]},
rowspec={X[c] X[j,h,8cm]},
vline{2},
hline{2},
row{2}={font=\footnotesize},
}
Plan de combat & Graphique d'intentions \\
{{battle_plan}} & {{intent_graph}} \\
\end{tblr}
\vfill
'''
color_table='''
THB: \ravblue
TBD: \nocolor
'''
default_color='\blu'

@ -1 +1 @@
Subproject commit ee3b7ffd5fa4e3bfbcd13cb5d69b9c0e3e9b06e5
Subproject commit 211b22dbe327b66f0da9f5c5a780dd6ec00a88d8