roguelike-game/src/raws/rawmaster.rs

658 lines
20 KiB
Rust
Raw Normal View History

2021-12-23 13:07:50 -05:00
use std::collections::{HashMap, HashSet};
2021-12-23 11:38:37 -05:00
use ::regex::Regex;
2022-01-10 10:28:04 -05:00
use ::rltk::{RandomNumberGenerator, RGB};
2021-12-24 10:38:44 -05:00
use ::specs::prelude::*;
2022-01-04 11:11:38 -05:00
use ::specs::saveload::{MarkedBuilder, SimpleMarker};
2021-12-23 11:38:37 -05:00
use crate::components::*;
use crate::gamesystem::{mana_at_level, npc_hp};
2021-12-23 13:07:50 -05:00
use crate::random_table::RandomTable;
2022-01-11 14:16:23 -05:00
use crate::raws::{Raws, Reaction};
2021-12-23 11:38:37 -05:00
pub fn parse_dice_string(dice: &str) -> (i32, i32, i32) {
lazy_static! {
static ref DICE_RE: Regex = Regex::new(r"(\d+)d(\d+)([\+\-]\d+)?").unwrap();
}
let mut n_dice = 1;
let mut die_type = 4;
let mut die_bonus = 0;
2022-01-04 11:11:38 -05:00
for cap in DICE_RE.captures_iter(dice) {
if let Some(group) = cap.get(1) {
n_dice = group.as_str().parse::<i32>().expect("Not a digit");
}
if let Some(group) = cap.get(2) {
die_type = group.as_str().parse::<i32>().expect("Not a digit");
}
if let Some(group) = cap.get(3) {
die_bonus = group.as_str().parse::<i32>().expect("Not a digit");
}
}
(n_dice, die_type, die_bonus)
}
2021-12-23 11:38:37 -05:00
pub enum SpawnType {
AtPosition { x: i32, y: i32 },
2022-01-04 11:11:38 -05:00
Equipped { by: Entity },
Carried { by: Entity },
2021-12-23 11:38:37 -05:00
}
pub struct RawMaster {
raws: Raws,
item_index: HashMap<String, usize>,
mob_index: HashMap<String, usize>,
prop_index: HashMap<String, usize>,
2022-01-05 09:42:36 -05:00
loot_index: HashMap<String, usize>,
2022-01-11 14:16:23 -05:00
faction_index: HashMap<String, HashMap<String, Reaction>>,
2021-12-23 11:38:37 -05:00
}
impl RawMaster {
pub fn empty() -> RawMaster {
RawMaster {
raws: Raws {
items: Vec::new(),
mobs: Vec::new(),
props: Vec::new(),
2021-12-23 13:07:50 -05:00
spawn_table: Vec::new(),
2022-01-05 09:42:36 -05:00
loot_tables: Vec::new(),
2022-01-11 14:16:23 -05:00
faction_table: Vec::new(),
},
2021-12-23 11:38:37 -05:00
item_index: HashMap::new(),
mob_index: HashMap::new(),
prop_index: HashMap::new(),
2022-01-05 09:42:36 -05:00
loot_index: HashMap::new(),
2022-01-11 14:16:23 -05:00
faction_index: HashMap::new(),
2021-12-23 11:38:37 -05:00
}
}
pub fn load(&mut self, raws: Raws) {
self.raws = raws;
self.item_index = HashMap::new();
2021-12-23 13:07:50 -05:00
let mut used_names: HashSet<String> = HashSet::new();
2021-12-23 11:38:37 -05:00
for (i, item) in self.raws.items.iter().enumerate() {
2021-12-23 13:07:50 -05:00
if used_names.contains(&item.name) {
rltk::console::log(format!(
"WARNING - duplicate item name in raws [{}]",
item.name
));
}
2021-12-23 11:38:37 -05:00
self.item_index.insert(item.name.clone(), i);
2021-12-23 13:07:50 -05:00
used_names.insert(item.name.clone());
2021-12-23 11:38:37 -05:00
}
for (i, mob) in self.raws.mobs.iter().enumerate() {
2021-12-23 13:07:50 -05:00
if used_names.contains(&mob.name) {
rltk::console::log(format!(
"WARNING - duplicate mob name in raws [{}]",
mob.name
));
}
self.mob_index.insert(mob.name.clone(), i);
2021-12-23 13:07:50 -05:00
used_names.insert(mob.name.clone());
}
for (i, prop) in self.raws.props.iter().enumerate() {
2021-12-23 13:07:50 -05:00
if used_names.contains(&prop.name) {
rltk::console::log(format!(
"WARNING - duplicate prop name in raws [{}]",
prop.name
));
}
self.prop_index.insert(prop.name.clone(), i);
2021-12-23 13:07:50 -05:00
used_names.insert(prop.name.clone());
}
for spawn in self.raws.spawn_table.iter() {
if !used_names.contains(&spawn.name) {
rltk::console::log(format!(
"WARNING - Spawn tables references unspecified entity {}",
spawn.name
));
}
}
2022-01-05 09:42:36 -05:00
for (i, loot) in self.raws.loot_tables.iter().enumerate() {
self.loot_index.insert(loot.name.clone(), i);
}
2022-01-11 14:16:23 -05:00
for faction in self.raws.faction_table.iter() {
let mut reactions: HashMap<String, Reaction> = HashMap::new();
for other in faction.responses.iter() {
reactions.insert(
other.0.clone(),
match other.1.as_str() {
"ignore" => Reaction::Ignore,
"flee" => Reaction::Flee,
_ => Reaction::Attack,
},
);
}
self.faction_index.insert(faction.name.clone(), reactions);
}
}
}
2022-01-11 14:16:23 -05:00
#[inline(always)]
pub fn faction_reaction(my_faction: &str, their_faction: &str, raws: &RawMaster) -> Reaction {
if raws.faction_index.contains_key(my_faction) {
let mf = &raws.faction_index[my_faction];
return if mf.contains_key(their_faction) {
mf[their_faction]
} else if mf.contains_key("Default") {
mf["Default"]
} else {
Reaction::Ignore
};
}
Reaction::Ignore
}
2022-01-04 11:11:38 -05:00
fn find_slot_for_equippable_item(tag: &str, raws: &RawMaster) -> EquipmentSlot {
if !raws.item_index.contains_key(tag) {
panic!("Trying to equip an unknown item: {}", tag);
}
let item_index = raws.item_index[tag];
let item = &raws.raws.items[item_index];
if item.weapon.is_some() {
return EquipmentSlot::Melee;
} else if let Some(wearable) = &item.wearable {
return string_to_slot(&wearable.slot);
}
panic!("Trying to equip {}, but it has not slot tag", tag);
}
2022-01-13 11:29:20 -05:00
pub fn get_vendor_items(categories: &[String], raws: &RawMaster) -> Vec<(String, f32)> {
let mut result = Vec::new();
for item in raws.raws.items.iter() {
if let Some(cat) = &item.vendor_category {
if categories.contains(cat) && item.base_value.is_some() {
result.push((item.name.clone(), item.base_value.unwrap()))
}
}
}
result
}
2022-01-04 11:11:38 -05:00
fn spawn_position<'a>(
pos: SpawnType,
new_entity: EntityBuilder<'a>,
tag: &str,
raws: &RawMaster,
) -> EntityBuilder<'a> {
let eb = new_entity;
// Spawn in the specified location
match pos {
2022-01-04 11:11:38 -05:00
SpawnType::AtPosition { x, y } => eb.with(Position { x, y }),
SpawnType::Carried { by } => eb.with(InBackpack { owner: by }),
SpawnType::Equipped { by } => {
let slot = find_slot_for_equippable_item(tag, raws);
eb.with(Equipped { owner: by, slot })
}
}
}
fn get_renderable_component(
renderable: &super::item_structs::Renderable,
) -> crate::components::Renderable {
crate::components::Renderable {
glyph: rltk::to_cp437(renderable.glyph.chars().next().unwrap()),
fg: RGB::from_hex(&renderable.fg).expect("Invalid color"),
bg: RGB::from_hex(&renderable.bg).expect("Invalid color"),
render_order: renderable.order,
2021-12-23 11:38:37 -05:00
}
}
2022-01-04 11:11:38 -05:00
pub fn string_to_slot(slot: &str) -> EquipmentSlot {
match slot {
"Shield" => EquipmentSlot::Shield,
"Head" => EquipmentSlot::Head,
"Torso" => EquipmentSlot::Torso,
"Legs" => EquipmentSlot::Legs,
"Feet" => EquipmentSlot::Feet,
"Hands" => EquipmentSlot::Hands,
"Melee" => EquipmentSlot::Melee,
_ => {
rltk::console::log(format!("Warning: unknown equipment slot type [{}]", slot));
EquipmentSlot::Melee
}
}
}
2021-12-23 11:38:37 -05:00
pub fn spawn_named_item(
raws: &RawMaster,
2022-01-04 11:11:38 -05:00
ecs: &mut World,
2021-12-23 11:38:37 -05:00
key: &str,
pos: SpawnType,
) -> Option<Entity> {
if raws.item_index.contains_key(key) {
let item_template = &raws.raws.items[raws.item_index[key]];
2022-01-04 11:11:38 -05:00
let mut eb = ecs.create_entity().marked::<SimpleMarker<SerializeMe>>();
2021-12-23 11:38:37 -05:00
// Spawn in the specified location
2022-01-04 11:11:38 -05:00
eb = spawn_position(pos, eb, key, raws);
2021-12-23 11:38:37 -05:00
// Renderable
if let Some(renderable) = &item_template.renderable {
eb = eb.with(get_renderable_component(renderable));
2021-12-23 11:38:37 -05:00
}
eb = eb.with(Name::from(&item_template.name));
2022-01-13 10:14:13 -05:00
eb = eb.with(Item {
initiative_penalty: item_template.initiative_penalty.unwrap_or(0.),
weight_lbs: item_template.weight_lbs.unwrap_or(0.),
base_value: item_template.base_value.unwrap_or(0.),
});
2021-12-23 11:38:37 -05:00
if let Some(consumable) = &item_template.consumable {
eb = eb.with(Consumable {});
for effect in consumable.effects.iter() {
let effect_name = effect.0.as_str();
match effect_name {
"provides_healing" => {
eb = eb.with(ProvidesHealing {
heal_amount: effect.1.parse::<i32>().unwrap(),
})
}
"ranged" => {
eb = eb.with(Ranged {
range: effect.1.parse::<i32>().unwrap(),
})
}
"damage" => {
eb = eb.with(InflictsDamage {
damage: effect.1.parse::<i32>().unwrap(),
})
}
"area_of_effect" => {
eb = eb.with(AreaOfEffect {
radius: effect.1.parse::<i32>().unwrap(),
})
}
"confusion" => {
eb = eb.with(Confusion {
turns: effect.1.parse::<i32>().unwrap(),
})
}
"magic_mapping" => eb = eb.with(MagicMapper {}),
"town_portal" => eb = eb.with(TownPortal {}),
"food" => eb = eb.with(ProvidesFood {}),
2021-12-23 11:38:37 -05:00
_ => {
rltk::console::log(format!(
"Warning: consumable effect {} not implemented.",
effect_name
));
}
}
}
}
if let Some(weapon) = &item_template.weapon {
eb = eb.with(Equippable {
slot: EquipmentSlot::Melee,
});
2022-01-04 11:11:38 -05:00
let (n_dice, die_type, bonus) = parse_dice_string(&weapon.base_damage);
let mut wpn = MeleeWeapon {
attribute: WeaponAttribute::Might,
damage_n_dice: n_dice,
damage_die_type: die_type,
damage_bonus: bonus,
hit_bonus: weapon.hit_bonus,
};
wpn.attribute = match weapon.attribute.as_str() {
"Quickness" => WeaponAttribute::Quickness,
_ => WeaponAttribute::Might,
};
eb = eb.with(wpn);
}
2022-01-04 11:11:38 -05:00
if let Some(wearable) = &item_template.wearable {
let slot = string_to_slot(&wearable.slot);
eb = eb.with(Equippable { slot });
eb = eb.with(Wearable {
slot,
armor_class: wearable.armor_class,
});
}
2022-01-19 09:40:21 -05:00
if let Some(magic) = &item_template.magic {
let class = match magic.class.as_str() {
"rare" => MagicItemClass::Rare,
"legendary" => MagicItemClass::Legendary,
_ => MagicItemClass::Common,
};
eb = eb.with(MagicItem { class })
}
2021-12-23 11:38:37 -05:00
return Some(eb.build());
}
None
}
pub fn spawn_named_mob(
raws: &RawMaster,
2022-01-04 11:11:38 -05:00
ecs: &mut World,
key: &str,
pos: SpawnType,
) -> Option<Entity> {
if raws.mob_index.contains_key(key) {
let mob_template = &raws.raws.mobs[raws.mob_index[key]];
2022-01-04 11:11:38 -05:00
let mut eb = ecs.create_entity().marked::<SimpleMarker<SerializeMe>>();
// Spawn in the specified location
2022-01-04 11:11:38 -05:00
eb = spawn_position(pos, eb, key, raws);
2022-01-11 09:28:45 -05:00
// Initiative of 2
eb = eb.with(Initiative { current: 2 });
// Renderable
if let Some(renderable) = &mob_template.renderable {
eb = eb.with(get_renderable_component(renderable));
}
eb = eb.with(Name::from(&mob_template.name));
2022-01-11 14:16:23 -05:00
eb = match mob_template.movement.as_ref() {
"random" => eb.with(MoveMode {
mode: Movement::Random,
}),
"random_waypoint" => eb.with(MoveMode {
mode: Movement::RandomWaypoint { path: None },
}),
2022-01-11 14:16:23 -05:00
_ => eb.with(MoveMode {
mode: Movement::Static,
}),
};
2022-01-03 10:49:12 -05:00
// Quips
if let Some(quips) = &mob_template.quips {
eb = eb.with(Quips {
available: quips.clone(),
});
}
2022-01-04 11:11:38 -05:00
if mob_template.blocks_tile {
eb = eb.with(BlocksTile {});
}
let mut mob_fitness = 11;
let mut mob_int = 11;
2022-01-03 15:21:12 -05:00
let mut attr = Attributes {
might: Attribute::new(11),
fitness: Attribute::new(11),
quickness: Attribute::new(11),
intelligence: Attribute::new(11),
};
if let Some(might) = mob_template.attributes.might {
attr.might = Attribute::new(might);
}
if let Some(fitness) = mob_template.attributes.fitness {
attr.fitness = Attribute::new(fitness);
mob_fitness = fitness;
2022-01-03 15:21:12 -05:00
}
if let Some(quickness) = mob_template.attributes.quickness {
attr.quickness = Attribute::new(quickness);
}
if let Some(intelligence) = mob_template.attributes.intelligence {
attr.intelligence = Attribute::new(intelligence);
mob_int = intelligence;
2022-01-03 15:21:12 -05:00
}
eb = eb.with(attr);
let mob_level = if mob_template.level.is_some() {
mob_template.level.unwrap()
} else {
1
};
let mob_hp = npc_hp(mob_fitness, mob_level);
let mob_mana = mana_at_level(mob_int, mob_level);
let pools = Pools {
level: mob_level,
xp: 0,
2022-01-13 10:14:13 -05:00
hit_points: Pool::new(mob_hp),
mana: Pool::new(mob_mana),
total_weight: 0.,
total_initiative_penalty: 0.,
2022-01-13 10:42:02 -05:00
gold: if let Some(gold) = &mob_template.gold {
let mut rng = RandomNumberGenerator::new();
2022-01-13 11:29:20 -05:00
let (n, d, b) = parse_dice_string(gold);
2022-01-13 10:42:02 -05:00
(rng.roll_dice(n, d) + b) as f32
} else {
0.0
},
god_mode: false,
};
eb = eb.with(pools);
let mut skills = Skills::new(1);
if let Some(mobskills) = &mob_template.skills {
for sk in mobskills.iter() {
match sk.0.as_str() {
"Melee" => {
skills.skills.insert(Skill::Melee, *sk.1);
}
"Defense" => {
skills.skills.insert(Skill::Defense, *sk.1);
}
"Magic" => {
skills.skills.insert(Skill::Magic, *sk.1);
}
_ => {
::rltk::console::log(format!("Unknown skill referenced [{}]", sk.0));
}
}
}
}
eb = eb.with(skills);
eb = eb.with(Viewshed {
visible_tiles: Vec::new(),
range: mob_template.vision_range,
dirty: true,
});
if let Some(na) = &mob_template.natural {
let mut nature = NaturalAttackDefense {
armor_class: na.armor_class,
attacks: Vec::new(),
};
if let Some(attacks) = &na.attacks {
for nattack in attacks.iter() {
let (n, d, b) = parse_dice_string(&nattack.damage);
let attack = NaturalAttack {
name: nattack.name.clone(),
hit_bonus: nattack.hit_bonus,
damage_n_dice: n,
damage_die_type: d,
damage_bonus: b,
};
nature.attacks.push(attack);
}
}
eb = eb.with(nature);
}
2022-01-05 09:42:36 -05:00
if let Some(loot) = &mob_template.loot_table {
eb = eb.with(LootTable {
table: loot.clone(),
});
}
2022-01-10 10:28:04 -05:00
if let Some(light) = &mob_template.light {
eb = eb.with(LightSource {
range: light.range,
color: RGB::from_hex(&light.color).expect("Invalid color"),
2022-01-10 10:28:04 -05:00
});
}
2022-01-11 14:16:23 -05:00
if let Some(faction) = &mob_template.faction {
eb = eb.with(Faction::from(faction));
} else {
eb = eb.with(Faction::from("Mindless"));
}
2022-01-13 11:29:20 -05:00
if let Some(vendor) = &mob_template.vendor {
eb = eb.with(Vendor {
categories: vendor.clone(),
})
}
2022-01-04 11:11:38 -05:00
let new_mob = eb.build();
2022-01-13 11:29:20 -05:00
// Are they wielding anything?
2022-01-04 11:11:38 -05:00
if let Some(wielding) = &mob_template.equipped {
for tag in wielding.iter() {
spawn_named_entity(raws, ecs, tag, SpawnType::Equipped { by: new_mob });
}
}
return Some(new_mob);
}
None
}
pub fn spawn_named_prop(
raws: &RawMaster,
2022-01-04 11:11:38 -05:00
ecs: &mut World,
key: &str,
pos: SpawnType,
) -> Option<Entity> {
if raws.prop_index.contains_key(key) {
let prop_template = &raws.raws.props[raws.prop_index[key]];
2022-01-04 11:11:38 -05:00
let mut eb = ecs.create_entity().marked::<SimpleMarker<SerializeMe>>();
// Spawn in the specified location
2022-01-04 11:11:38 -05:00
eb = spawn_position(pos, eb, key, raws);
// Renderable
if let Some(renderable) = &prop_template.renderable {
eb = eb.with(get_renderable_component(renderable));
}
eb = eb.with(Name::from(&prop_template.name));
if let Some(hidden) = prop_template.hidden {
if hidden {
eb = eb.with(Hidden {})
}
}
if let Some(blocks_tile) = prop_template.blocks_tile {
if blocks_tile {
eb = eb.with(BlocksTile {})
}
}
if let Some(blocks_visibility) = prop_template.blocks_visibility {
if blocks_visibility {
eb = eb.with(BlocksVisibility {})
}
}
if let Some(door_open) = prop_template.door_open {
eb = eb.with(Door { open: door_open });
}
if let Some(entry_trigger) = &prop_template.entry_trigger {
eb = eb.with(EntryTrigger {});
for effect in entry_trigger.effects.iter() {
match effect.0.as_str() {
"damage" => {
eb = eb.with(InflictsDamage {
damage: effect.1.parse::<i32>().unwrap(),
});
}
"single_activation" => eb = eb.with(SingleActivation {}),
_ => {}
}
}
}
if let Some(light) = &prop_template.light {
eb = eb
.with(LightSource {
range: light.range,
color: RGB::from_hex(&light.color).expect("Invalid color"),
})
.with(Viewshed {
range: light.range,
dirty: true,
visible_tiles: Vec::new(),
});
}
return Some(eb.build());
}
None
}
pub fn spawn_named_entity(
raws: &RawMaster,
2022-01-04 11:11:38 -05:00
ecs: &mut World,
key: &str,
pos: SpawnType,
) -> Option<Entity> {
if raws.item_index.contains_key(key) {
2022-01-04 11:11:38 -05:00
return spawn_named_item(raws, ecs, key, pos);
} else if raws.mob_index.contains_key(key) {
2022-01-04 11:11:38 -05:00
return spawn_named_mob(raws, ecs, key, pos);
} else if raws.prop_index.contains_key(key) {
2022-01-04 11:11:38 -05:00
return spawn_named_prop(raws, ecs, key, pos);
}
None
}
2021-12-23 13:07:50 -05:00
pub fn get_spawn_table_for_depth(raws: &RawMaster, depth: i32) -> RandomTable {
use super::SpawnTableEntry;
let available_options: Vec<&SpawnTableEntry> = raws
.raws
.spawn_table
.iter()
.filter(|a| depth >= a.min_depth && depth <= a.max_depth)
.collect();
let mut rt = RandomTable::new();
for e in available_options.iter() {
let mut weight = e.weight;
if e.add_map_depth_to_weight.is_some() {
weight += depth;
}
rt = rt.add(e.name.clone(), weight);
}
rt
}
pub fn get_item_drop(
raws: &RawMaster,
rng: &mut RandomNumberGenerator,
table: &str,
) -> Option<String> {
if raws.loot_index.contains_key(table) {
let mut rt = RandomTable::new();
let available_options = &raws.raws.loot_tables[raws.loot_index[table]];
for item in available_options.drops.iter() {
rt = rt.add(item.name.clone(), item.weight);
}
return Some(rt.roll(rng));
}
None
}