ravenous-tools/weaponry/examples/first_import.rs

201 lines
10 KiB
Rust

// Workspace: weaponry
// File: examples/typical_wl_recipe.rs
//! Example of a typical workload
//!
use logos::Logos;
use more_fields::FieldsAsSlice;
use serde::Serialize;
use serde_rusqlite::to_params_named;
use weaponry::interfaces::RecipeDatabase;
use weaponry::weaponry_structs::equipement_impl_database::EquipementDatabase;
use weaponry::weaponry_structs::equipement_structs::{DatabaseEquipementStats, InnerEquipementStats};
use weaponry::weaponry_structs::{DamageMod, DamageType, PhysicalDamageType, WeaponMetaCategory};
#[derive(Logos, Debug, PartialEq)]
enum ModeParser {
#[regex(r"\[\[\w+\]\]", |lex| std::convert::TryInto::<PhysicalDamageType>::try_into(&lex.slice()[2..lex.slice().len()-2]).unwrap())]
Tertiary(PhysicalDamageType),
#[regex(r"\[\w+\]", |lex| std::convert::TryInto::<PhysicalDamageType>::try_into(&lex.slice()[1..lex.slice().len()-1]).unwrap())]
Secondary(PhysicalDamageType),
#[regex(r"\w+", |lex| std::convert::TryInto::<PhysicalDamageType>::try_into(lex.slice()).unwrap())]
Primary(PhysicalDamageType),
}
// let b = DamageMod::Primary()
const BASE_FORME: &[&str] = &[
// "% Nom & Type & Dé & + & RM & AB & Pr & In & T2 & T1 & Md & Esq. & Par. & Vit. & Disc. & Spc. & Diff ",
// "Name & Type & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & mode & 9 & 10 & 11 & 12 & 3reload, & ddlvl{13} ",
"Griffes & Tranchantes & 2 & 1 & 4 & 1 & 1 & 2 & 3 & 6 & slash & 2 & 0 & 3 & 1 & - & ddlvl{1} ",
"Hast & Hast & 4 & 1 & 2 & 1 & 4 & 3 & 10 & 18 & pierce, [slash] & -1 & -3 & 1 & 0 & - & ddlvl{1} ",
"Épée & Tranchantes & 3 & 1 & 3 & 1 & 3 & 4 & 12 & 15 & slash, [pierce] & 0 & 1 & 0 & 0 & - & ddlvl{1} ",
"Marteau & Contondantes & 5 & 1 & 1 & 1 & 4 & 3 & 11 & 18 & blunt & -1 & -1 & 0 & -2 & - & ddlvl{1} ",
"Hache & Tranchantes & 4 & 2 & 1 & 3 & 4 & 3 & 9 & 14 & slash & 0 & -1 & 1 & 0 & - & ddlvl{1} ",
"Arbalète & Distance & 4 & 1 & 3 & 0 & 3 & 1 & 8 & 16 & pierce & -1 & -1 & 0 & -1 & 2reload, Gls{parmure} 2, 80m & ddlvl{1} ",
"Arc & Distance & 3 & 1 & 4 & 0 & 2 & 1 & - & 7 & pierce & 0 & 0 & 0 & 0 & 1reload, Gls{parmure} 2, 120m & ddlvl{1} ",
"Boucliers & Boucliers & 1 & 1 & 2 & 0 & 3 & 2 & 6 & 8 & blunt & -2 & 0 & -1 & -2 & - & ddlvl{1} ",
"Armures & Armures & & & & & 3 & 2 & 10 & - & blunt & -1 & 0 & 0 & -1 & - & ddlvl{1} ",
// "% Explosive & Exotiques & 3 & 1 & 3 & 1 & 2 & 2 & 20 & 10 & slash & 0 & 0 & 0 & 0 & - & ddlvl{5} ",
// "% Flexible & Exotiques & 3 & 1 & 3 & 1 & 2 & 2 & 20 & 10 & slash & 0 & 0 & 0 & 0 & - & ddlvl{2} ",
// "% Exotique & Exotiques & 3 & 1 & 3 & 1 & 2 & 2 & 20 & 10 & slash & 0 & 0 & 0 & 0 & - & ddlvl{3} ",
];
fn main() {
let mut global_index = 0;
let b = load_base(&mut global_index);
// println!("{b:?}"); // Equipements
let db = EquipementDatabase::new("./databases/weapons.db").unwrap();
db.initialize_empty_table::<DatabaseEquipementStats>("Equipements").unwrap();
db.conn.execute("DELETE FROM Equipements", []).unwrap();
println!("Added {global_index} ids to the new database");
b.iter().for_each(|v| database_shnn(&db, v));
let v = db.serialize_vec_from_table::<DatabaseEquipementStats>("Equipements", None);
// println!("Initial deserialisation in DatabaseEquipementStats: {:?}", v);
println!("First entry: {:?}", v.as_ref().unwrap()[0]);
// Final deserialisation
let final_s = v.unwrap().into_iter().map(InnerEquipementStats::try_from).collect::<Vec<_>>();
let v = final_s
.iter()
.scan(0, |status, eq| {
if eq.is_ok() {
*status = 1;
} else {
*status = 0;
}
Some(*status)
})
.sum::<i32>();
println!("Final data {:#?}", final_s);
println!("Succeded in parsing {:#?} over {}", v, global_index);
}
#[allow(dead_code)]
#[derive(Default)]
struct FoundFields {
reload: Option<u8>,
range: Option<u8>,
parmor: Option<u8>,
}
fn parse_special_field(fields: &str) -> FoundFields {
// "Arbalète & Distance & 4 & 1 & 3 0 & 3 & 1 & 8 & 16 & pierce & -1 & -1 & 0 & -1 & 2reload, Gls{parmure} 2, 80m & ddlvl{1} ",
let re = regex::Regex::new(r"((?<reload>\d)reload)?(, )?(Gls\{parmure\} (?<parmure>\d))?(, )?((?<range>\d+)m)?").unwrap();
re.captures(fields).map_or(FoundFields::default(), |f| FoundFields {
reload: f.name("reload").map(|n| n.as_str().parse().unwrap()),
range: f.name("range").map(|v| v.as_str().parse().unwrap()),
parmor: f.name("parmor").map(|v| v.as_str().parse().unwrap()),
})
}
#[allow(dead_code)]
fn database_shnn<T: Serialize>(db: &EquipementDatabase, row: T) {
// let mut row = DatabaseEquipementStats::random_new();
let sql = &format!(
"INSERT INTO Equipements ({}) VALUES ({})",
DatabaseEquipementStats::attributes_slice()
.iter()
// .filter_map(|(k, _v)| (*k != "id").then_some(*k))
.map(|(k, _v)| *k)
.collect::<Vec<_>>()
.join(", "),
DatabaseEquipementStats::attributes_slice()
.iter()
// .filter_map(|(k, _v)| (*k != "id").then_some(":".to_string() + *k))
.map(|(k, _v)| ":".to_string() + *k)
.collect::<Vec<_>>()
.join(", ")
);
// println!("Database Request {}", sql);
let r = db.conn.execute(sql, to_params_named(&row).unwrap().to_slice().as_slice());
match r {
Ok(_r) => {
// println!("Loaded {:?} entries into the database", _r);
}
Err(e) => println!("Error: {} while processing entry", e),
};
}
fn load_base(index: &mut u8) -> Vec<DatabaseEquipementStats> {
// data_eg.id = fastrand::u8(1..u8::MAX);
// data_eg.damage_type = serde_json::to_string(&Some(DamageType(vec![DamageMod::Primary(
// PhysicalDamageType::Blunt,
// )])))
// .unwrap();
// data_eg.category = serde_json::to_string(&Some(WeaponCategory::Dagger)).unwrap();
// data_eg.target = serde_json::to_string(&Some(WeaponCategory::Dagger)).unwrap();
// data_eg.special =
// serde_json::to_string(&SpecialCategory(vec!["noo".to_string(), "boo".to_string()]))
// .unwrap();
// data_eg.reload_cost = serde_json::to_string(&Some(12)).unwrap();
BASE_FORME
.iter()
.map(|row| {
let fields = row.split("&").map(|field| field.trim()).collect::<Vec<_>>();
let FoundFields { reload, range, parmor } = parse_special_field(fields[15]);
*index += 1;
// "% Nom & Type & Dé & + & RM & AB & Pr & In & T2 & T1 & Md & Esq. & Par. & Vit. & Disc. & Spc. & Diff ",
// 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & 13 & 14 & 15
DatabaseEquipementStats {
id: *index,
meta_category: "Forme".into(),
name: fields[0].to_string(),
category: serde_json::to_string(&parse_to_type(fields[1]).unwrap()).unwrap(),
rarity: 0,
cost: 0,
precision: 0,
difficulty: fields[16].parse().unwrap_or_default(), // NOT PARSED YET
// tier: ,
damage: fields[2].parse().unwrap_or_default(),
p_damage: fields[3].parse().unwrap_or_default(),
rmax: fields[4].parse().unwrap_or_default(),
armor_break: fields[5].parse().unwrap_or_default(),
protection: fields[6].parse().unwrap_or_default(),
integrity: fields[7].parse().unwrap_or_default(),
torque_two_handed: fields[8].parse().unwrap_or_default(),
torque_one_handed: fields[9].parse().unwrap_or_default(), // The or default is a problem
damage_type: serde_json::to_string(&parse_to_damagetype(fields[10])).unwrap(),
dodge: fields[11].parse().unwrap_or_default(),
parry: fields[12].parse().unwrap_or_default(),
speed: fields[13].parse().unwrap_or_default(),
stealth: fields[14].parse().unwrap_or_default(),
reload_cost: serde_json::to_string(&reload).unwrap(),
range: range.unwrap_or_default(),
armor_pierce: parmor.unwrap_or_default(),
// meta_category: parse_to_type(fields[1]),
// target: fields[5].parse().unwrap(), // Armors ?
..Default::default()
}
})
.collect::<Vec<_>>()
}
fn parse_to_damagetype(fields: &str) -> DamageType {
DamageType(fields.split(",").map(|v| ModeParser::lexer(v.trim()).next().unwrap().unwrap().into()).collect::<Vec<_>>())
}
impl From<ModeParser> for DamageMod {
fn from(value: ModeParser) -> Self {
match value {
ModeParser::Primary(v) => DamageMod::Primary(v),
ModeParser::Secondary(v) => DamageMod::Secondary(v),
ModeParser::Tertiary(v) => DamageMod::Tertiary(v),
}
}
}
fn parse_to_type(text: &str) -> Option<WeaponMetaCategory> {
match text {
"Hast" => Some(WeaponMetaCategory::Staves),
"Tranchantes" => Some(WeaponMetaCategory::Slash),
"Contondantes" => Some(WeaponMetaCategory::Blunt),
"Distance" => Some(WeaponMetaCategory::Ranged),
"Boucliers" => Some(WeaponMetaCategory::Shields),
"Armures" => Some(WeaponMetaCategory::Armor),
"Exotiques" => Some(WeaponMetaCategory::Exotic),
_ => None,
}
}