diff --git a/raws/factions.json b/raws/factions.json index 75a2812..136f3dc 100644 --- a/raws/factions.json +++ b/raws/factions.json @@ -9,7 +9,7 @@ }, { "id": "neutral", - "responses": { "default": "ignore" } + "responses": { "default": "ignore", "hostile": "flee", "mindless": "flee", "carnivore": "flee" } }, { "id": "hostile", @@ -21,6 +21,6 @@ }, { "id": "carnivore", - "responses": { "default": "ignore", "herbivores": "attack", "player": "attack" } + "responses": { "default": "ignore", "herbivores": "attack", "player": "attack", "neutral": "attack" } } ] diff --git a/src/ai/bystander_ai_system.rs b/src/ai/bystander_ai_system.rs deleted file mode 100644 index d87e33d..0000000 --- a/src/ai/bystander_ai_system.rs +++ /dev/null @@ -1,63 +0,0 @@ -use crate::{Bystander, EntityMoved, Map, Position, TakingTurn, Viewshed}; -use specs::prelude::*; - -pub struct BystanderAI {} - -impl<'a> System<'a> for BystanderAI { - #[allow(clippy::type_complexity)] - type SystemData = ( - WriteExpect<'a, Map>, - Entities<'a>, - WriteStorage<'a, Viewshed>, - ReadStorage<'a, Bystander>, - WriteStorage<'a, Position>, - WriteStorage<'a, EntityMoved>, - WriteExpect<'a, rltk::RandomNumberGenerator>, - ReadStorage<'a, TakingTurn>, - ); - - fn run(&mut self, data: Self::SystemData) { - let (mut map, entities, mut viewshed, bystander, mut position, mut entity_moved, mut rng, turns) = data; - - for (entity, mut viewshed, _bystander, mut pos, _turn) in - (&entities, &mut viewshed, &bystander, &mut position, &turns).join() - { - if try_move_randomly(&mut pos, &mut rng, &mut map, &mut viewshed) { - entity_moved.insert(entity, EntityMoved {}).expect("Unable to insert marker"); - } - } - } -} - -pub fn try_move_randomly( - pos: &mut Position, - rng: &mut rltk::RandomNumberGenerator, - map: &mut Map, - viewshed: &mut Viewshed, -) -> bool { - // Try to move randomly - let mut x = pos.x; - let mut y = pos.y; - let move_roll = rng.roll_dice(1, 8); - match move_roll { - 1 => x -= 1, - 2 => x += 1, - 3 => y -= 1, - 4 => y += 1, - _ => {} - } - - if x > 0 && x < map.width - 1 && y > 0 && y < map.height - 1 { - let dest_idx = map.xy_idx(x, y); - if !map.blocked[dest_idx] { - let idx = map.xy_idx(pos.x, pos.y); - map.blocked[idx] = false; - pos.x = x; - pos.y = y; - map.blocked[dest_idx] = true; - viewshed.dirty = true; - return true; - } - } - return false; -} diff --git a/src/ai/chase_ai_system.rs b/src/ai/chase_ai_system.rs new file mode 100644 index 0000000..93f586f --- /dev/null +++ b/src/ai/chase_ai_system.rs @@ -0,0 +1,85 @@ +use crate::{Chasing, EntityMoved, Map, Position, TakingTurn, Telepath, Viewshed}; +use rltk::prelude::*; +use specs::prelude::*; +use std::collections::HashMap; + +// If the target is beyond this distance, they're no longer being detected, +// so stop following them. This is essentially a combined value of the sound +// the target might be making, noise, light, etc., anything they could do to +// be detected. As those constituent systems are developed, this value should +// be changed to being a result of some calculations between them. +const MAX_CHASE_DISTANCE: usize = 15; +pub struct ChaseAI {} + +impl<'a> System<'a> for ChaseAI { + #[allow(clippy::type_complexity)] + type SystemData = ( + WriteStorage<'a, TakingTurn>, + WriteStorage<'a, Chasing>, + WriteStorage<'a, Position>, + WriteExpect<'a, Map>, + WriteStorage<'a, Viewshed>, + WriteStorage<'a, Telepath>, + WriteStorage<'a, EntityMoved>, + Entities<'a>, + ); + + fn run(&mut self, data: Self::SystemData) { + let (mut turns, mut chasing, mut positions, mut map, mut viewsheds, mut telepaths, mut entity_moved, entities) = + data; + let mut targets: HashMap = HashMap::new(); + let mut end_chase: Vec = Vec::new(); + // For every chasing entity with a turn, look for a valid target position, + // and if found, store that position in a temporary HashMap. This gets around + // needing to read Position twice - that would cause borrowchecker issues. + // If there's no valid target found, remove the chasing component. + for (entity, _turn, chasing) in (&entities, &turns, &chasing).join() { + if let Some(target_pos) = positions.get(chasing.target) { + targets.insert(entity, (target_pos.x, target_pos.y)); + } else { + end_chase.push(entity); + } + } + for done in end_chase.iter() { + chasing.remove(*done); + } + end_chase.clear(); + // Iterate over everyone who is *still* chasing, and path to the target + // stored in the HashMap. If successful, follow the path. If not, remove + // the chasing component. + let mut turn_done: Vec = Vec::new(); + for (entity, _turn, mut pos, _chase, mut viewshed) in + (&entities, &turns, &mut positions, &chasing, &mut viewsheds).join() + { + turn_done.push(entity); + let target_pos = targets[&entity]; + let path = a_star_search( + map.xy_idx(pos.x, pos.y) as i32, + map.xy_idx(target_pos.0, target_pos.1) as i32, + &mut *map, + ); + if path.success && path.steps.len() > 1 && path.steps.len() < MAX_CHASE_DISTANCE { + let mut idx = map.xy_idx(pos.x, pos.y); + map.blocked[idx] = false; + pos.x = path.steps[1] as i32 % map.width; + pos.y = path.steps[1] as i32 / map.width; + entity_moved.insert(entity, EntityMoved {}).expect("Failed to insert EntityMoved"); + idx = map.xy_idx(pos.x, pos.y); + map.blocked[idx] = true; + viewshed.dirty = true; + if let Some(is_telepath) = telepaths.get_mut(entity) { + is_telepath.dirty = true; + } + turn_done.push(entity); + } else { + end_chase.push(entity); + } + } + for done in end_chase.iter() { + chasing.remove(*done); + } + for done in turn_done.iter() { + turns.remove(*done); + } + } +} diff --git a/src/ai/energy_system.rs b/src/ai/energy_system.rs index ef02d2d..13a5ad9 100644 --- a/src/ai/energy_system.rs +++ b/src/ai/energy_system.rs @@ -20,10 +20,23 @@ impl<'a> System<'a> for EnergySystem { WriteExpect<'a, RunState>, ReadExpect<'a, Entity>, ReadStorage<'a, Name>, + ReadExpect<'a, Point>, ); fn run(&mut self, data: Self::SystemData) { - let (clock, mut energies, burdens, positions, mut turns, entities, mut rng, mut runstate, player, names) = data; + let ( + clock, + mut energies, + burdens, + positions, + mut turns, + entities, + mut rng, + mut runstate, + player, + names, + player_pos, + ) = data; // If not ticking, do nothing. if *runstate != RunState::Ticking { return; @@ -44,7 +57,7 @@ impl<'a> System<'a> for EnergySystem { } } // EVERYTHING ELSE - for (entity, energy, _pos) in (&entities, &mut energies, &positions).join() { + for (entity, energy, pos) in (&entities, &mut energies, &positions).join() { let burden_modifier = if let Some(burden) = burdens.get(entity) { match burden.level { BurdenLevel::Burdened => 0.75, @@ -76,17 +89,25 @@ impl<'a> System<'a> for EnergySystem { // has enough energy, they take a turn and decrement their energy // by TURN_COST. If the current entity is the player, await input. if energy.current >= TURN_COST { - turns.insert(entity, TakingTurn {}).expect("Unable to insert turn."); - energy.current -= TURN_COST; - if LOG_TICKS { - let name = if let Some(name) = names.get(entity) { &name.name } else { "Unknown entity" }; - console::log(format!( - "ENERGY SYSTEM: {} granted a turn. [leftover energy: {}].", - name, energy.current - )); - } + let mut my_turn = true; if entity == *player { *runstate = RunState::AwaitingInput; + } else { + let distance = rltk::DistanceAlg::Pythagoras.distance2d(*player_pos, Point::new(pos.x, pos.y)); + if distance > 20.0 { + my_turn = false; + } + } + if my_turn { + turns.insert(entity, TakingTurn {}).expect("Unable to insert turn."); + energy.current -= TURN_COST; + if LOG_TICKS { + let name = if let Some(name) = names.get(entity) { &name.name } else { "Unknown entity" }; + console::log(format!( + "ENERGY SYSTEM: {} granted a turn. [leftover energy: {}].", + name, energy.current + )); + } } } } diff --git a/src/ai/flee_ai_system.rs b/src/ai/flee_ai_system.rs new file mode 100644 index 0000000..21813cf --- /dev/null +++ b/src/ai/flee_ai_system.rs @@ -0,0 +1,59 @@ +use crate::{EntityMoved, Map, Position, TakingTurn, Telepath, Viewshed, WantsToFlee}; +use rltk::prelude::*; +use specs::prelude::*; + +pub struct FleeAI {} + +impl<'a> System<'a> for FleeAI { + #[allow(clippy::type_complexity)] + type SystemData = ( + WriteStorage<'a, TakingTurn>, + WriteStorage<'a, WantsToFlee>, + WriteStorage<'a, Position>, + WriteExpect<'a, Map>, + WriteStorage<'a, Viewshed>, + WriteStorage<'a, Telepath>, + WriteStorage<'a, EntityMoved>, + Entities<'a>, + ); + + fn run(&mut self, data: Self::SystemData) { + let ( + mut turns, + mut wants_to_flee, + mut positions, + mut map, + mut viewsheds, + mut telepaths, + mut entity_moved, + entities, + ) = data; + let mut turn_done: Vec = Vec::new(); + for (entity, _turn, mut pos, fleeing, mut viewshed) in + (&entities, &turns, &mut positions, &wants_to_flee, &mut viewsheds).join() + { + turn_done.push(entity); + let my_idx = map.xy_idx(pos.x, pos.y); + map.populate_blocked(); + let flee_map = DijkstraMap::new(map.width as usize, map.height as usize, &fleeing.indices, &*map, 100.0); + let flee_target = DijkstraMap::find_highest_exit(&flee_map, my_idx, &*map); + if let Some(flee_target) = flee_target { + if !map.blocked[flee_target as usize] { + map.blocked[my_idx] = false; + map.blocked[flee_target as usize] = true; + viewshed.dirty = true; + if let Some(is_telepath) = telepaths.get_mut(entity) { + is_telepath.dirty = true; + } + pos.x = flee_target as i32 % map.width; + pos.y = flee_target as i32 / map.width; + entity_moved.insert(entity, EntityMoved {}).expect("Unable to insert EntityMoved"); + } + } + } + wants_to_flee.clear(); + for done in turn_done.iter() { + turns.remove(*done); + } + } +} diff --git a/src/ai/mod.rs b/src/ai/mod.rs index 8703344..a2f72e1 100644 --- a/src/ai/mod.rs +++ b/src/ai/mod.rs @@ -8,13 +8,13 @@ mod regen_system; pub use regen_system::RegenSystem; mod encumbrance_system; pub use encumbrance_system::{EncumbranceSystem, CARRY_CAPACITY_PER_STRENGTH}; -mod bystander_ai_system; -pub use bystander_ai_system::BystanderAI; -mod monster_ai_system; -pub use monster_ai_system::MonsterAI; mod adjacent_ai_system; pub use adjacent_ai_system::AdjacentAI; mod visible_ai_system; pub use visible_ai_system::VisibleAI; mod approach_ai_system; pub use approach_ai_system::ApproachAI; +mod chase_ai_system; +pub use chase_ai_system::ChaseAI; +mod flee_ai_system; +pub use flee_ai_system::FleeAI; diff --git a/src/ai/monster_ai_system.rs b/src/ai/monster_ai_system.rs deleted file mode 100644 index dbf6829..0000000 --- a/src/ai/monster_ai_system.rs +++ /dev/null @@ -1,70 +0,0 @@ -use super::bystander_ai_system::try_move_randomly; -use crate::{EntityMoved, Map, Monster, Position, TakingTurn, Viewshed, WantsToMelee}; -use rltk::Point; -use specs::prelude::*; - -pub struct MonsterAI {} - -impl<'a> System<'a> for MonsterAI { - #[allow(clippy::type_complexity)] - type SystemData = ( - WriteExpect<'a, Map>, - WriteExpect<'a, rltk::RandomNumberGenerator>, - ReadExpect<'a, Point>, - ReadExpect<'a, Entity>, - Entities<'a>, - WriteStorage<'a, Viewshed>, - ReadStorage<'a, Monster>, - WriteStorage<'a, Position>, - WriteStorage<'a, WantsToMelee>, - WriteStorage<'a, EntityMoved>, - ReadStorage<'a, TakingTurn>, - ); - - fn run(&mut self, data: Self::SystemData) { - let ( - mut map, - mut rng, - player_pos, - player_entity, - entities, - mut viewshed, - monster, - mut position, - mut wants_to_melee, - mut entity_moved, - turns, - ) = data; - - for (entity, mut viewshed, _monster, mut pos, _turn) in - (&entities, &mut viewshed, &monster, &mut position, &turns).join() - { - let distance = rltk::DistanceAlg::Pythagoras.distance2d(Point::new(pos.x, pos.y), *player_pos); - if distance < 1.5 { - wants_to_melee - .insert(entity, WantsToMelee { target: *player_entity }) - .expect("Unable to insert attack."); - } else if viewshed.visible_tiles.contains(&*player_pos) { - // If the player is visible, but the path is obstructed, this will currently search - // the entire map (i.e. Will do a huge ASTAR to find an alternate route), and the - // mob will follow that path until it leaves vision, then lose sight of the player - // and stop. - let path = rltk::a_star_search(map.xy_idx(pos.x, pos.y), map.xy_idx(player_pos.x, player_pos.y), &*map); - if path.success && path.steps.len() > 1 { - let mut idx = map.xy_idx(pos.x, pos.y); - map.blocked[idx] = false; - pos.x = (path.steps[1] as i32) % map.width; - pos.y = (path.steps[1] as i32) / map.width; - idx = map.xy_idx(pos.x, pos.y); - map.blocked[idx] = true; - viewshed.dirty = true; - entity_moved.insert(entity, EntityMoved {}).expect("Unable to insert marker"); - } - } else { - if try_move_randomly(&mut pos, &mut rng, &mut map, &mut viewshed) { - entity_moved.insert(entity, EntityMoved {}).expect("Unable to insert marker"); - } - } - } - } -} diff --git a/src/ai/visible_ai_system.rs b/src/ai/visible_ai_system.rs index 720d74e..5f83e83 100644 --- a/src/ai/visible_ai_system.rs +++ b/src/ai/visible_ai_system.rs @@ -1,5 +1,5 @@ use crate::{ - raws::Reaction, Faction, Map, Mind, Position, TakingTurn, Telepath, Viewshed, WantsToApproach, WantsToFlee, + raws::Reaction, Chasing, Faction, Map, Mind, Position, TakingTurn, Telepath, Viewshed, WantsToApproach, WantsToFlee, }; use specs::prelude::*; use std::collections::HashSet; @@ -20,6 +20,7 @@ impl<'a> System<'a> for VisibleAI { ReadStorage<'a, Viewshed>, ReadStorage<'a, Telepath>, ReadStorage<'a, Mind>, + WriteStorage<'a, Chasing>, ); fn run(&mut self, data: Self::SystemData) { @@ -35,6 +36,7 @@ impl<'a> System<'a> for VisibleAI { viewsheds, telepaths, minds, + mut chasing, ) = data; for (entity, _turn, faction, pos, viewshed) in (&entities, &turns, &factions, &positions, &viewsheds).join() { @@ -42,7 +44,7 @@ impl<'a> System<'a> for VisibleAI { continue; } let this_idx = map.xy_idx(pos.x, pos.y); - let mut reactions: Vec<(usize, Reaction)> = Vec::new(); + let mut reactions: Vec<(usize, Reaction, Entity)> = Vec::new(); let mut flee: Vec = Vec::new(); let mut idxs: HashSet = HashSet::new(); for visible_tile in viewshed.visible_tiles.iter() { @@ -70,6 +72,7 @@ impl<'a> System<'a> for VisibleAI { wants_to_approach .insert(entity, WantsToApproach { idx: reaction.0 as i32 }) .expect("Error inserting WantsToApproach"); + chasing.insert(entity, Chasing { target: reaction.2 }).expect("Unable to insert Chasing"); done = true; } Reaction::Flee => { @@ -90,7 +93,7 @@ fn evaluate( map: &Map, factions: &ReadStorage, this_faction: &str, - reactions: &mut Vec<(usize, Reaction)>, + reactions: &mut Vec<(usize, Reaction, Entity)>, minds: Option<&ReadStorage>, ) { for other_entity in map.tile_content[idx].iter() { @@ -105,6 +108,7 @@ fn evaluate( reactions.push(( idx, crate::raws::faction_reaction(this_faction, &faction.name, &crate::raws::RAWS.lock().unwrap()), + *other_entity, )); } } diff --git a/src/components.rs b/src/components.rs index 7406808..d7f3c3f 100644 --- a/src/components.rs +++ b/src/components.rs @@ -54,9 +54,6 @@ pub struct Faction { #[derive(Component, Debug, Serialize, Deserialize, Clone)] pub struct Prop {} -#[derive(Component, Debug, Serialize, Deserialize, Clone)] -pub struct Monster {} - #[derive(Component, Debug, Serialize, Deserialize, Clone)] pub struct LootTable { pub table: String, @@ -75,9 +72,6 @@ pub struct Clock {} #[derive(Component, Debug, Serialize, Deserialize, Clone)] pub struct TakingTurn {} -#[derive(Component, Debug, Serialize, Deserialize, Clone)] -pub struct Bystander {} - #[derive(Component, Debug, Serialize, Deserialize, Clone)] pub struct Quips { pub available: Vec, @@ -383,6 +377,11 @@ pub struct WantsToFlee { pub indices: Vec, // Dijkstra } +#[derive(Component, Debug, ConvertSaveload, Clone)] +pub struct Chasing { + pub target: Entity, +} + #[derive(Component, Debug, Serialize, Deserialize, Clone)] pub struct Consumable {} diff --git a/src/main.rs b/src/main.rs index 8a605a2..4de5d62 100644 --- a/src/main.rs +++ b/src/main.rs @@ -96,11 +96,6 @@ impl State { let mut encumbrance_system = ai::EncumbranceSystem {}; let mut turn_status_system = ai::TurnStatusSystem {}; let mut quip_system = ai::QuipSystem {}; - let mut adjacent_ai = ai::AdjacentAI {}; - let mut visible_ai = ai::VisibleAI {}; - let mut approach_ai = ai::ApproachAI {}; - let mut mob = ai::MonsterAI {}; - let mut bystanders = ai::BystanderAI {}; let mut trigger_system = trigger_system::TriggerSystem {}; let mut melee_system = MeleeCombatSystem {}; let mut damage_system = DamageSystem {}; @@ -119,11 +114,7 @@ impl State { energy.run_now(&self.ecs); turn_status_system.run_now(&self.ecs); quip_system.run_now(&self.ecs); - adjacent_ai.run_now(&self.ecs); - visible_ai.run_now(&self.ecs); - approach_ai.run_now(&self.ecs); - mob.run_now(&self.ecs); - bystanders.run_now(&self.ecs); + self.run_ai(); trigger_system.run_now(&self.ecs); inventory_system.run_now(&self.ecs); item_use_system.run_now(&self.ecs); @@ -138,6 +129,19 @@ impl State { self.ecs.maintain(); } + fn run_ai(&mut self) { + let mut adjacent_ai = ai::AdjacentAI {}; + let mut visible_ai = ai::VisibleAI {}; + let mut approach_ai = ai::ApproachAI {}; + let mut flee_ai = ai::FleeAI {}; + let mut chase_ai = ai::ChaseAI {}; + adjacent_ai.run_now(&self.ecs); + visible_ai.run_now(&self.ecs); + approach_ai.run_now(&self.ecs); + flee_ai.run_now(&self.ecs); + chase_ai.run_now(&self.ecs); + } + fn run_map_index(&mut self) { let mut mapindex = MapIndexingSystem {}; mapindex.run_now(&self.ecs); @@ -523,10 +527,9 @@ fn main() -> rltk::BError { gs.ecs.register::(); gs.ecs.register::(); gs.ecs.register::(); + gs.ecs.register::(); gs.ecs.register::(); gs.ecs.register::(); - gs.ecs.register::(); - gs.ecs.register::(); gs.ecs.register::(); gs.ecs.register::(); gs.ecs.register::(); diff --git a/src/player.rs b/src/player.rs index 5d8da5b..017f5b4 100644 --- a/src/player.rs +++ b/src/player.rs @@ -1,6 +1,6 @@ use super::{ - gamelog, gui::get_item_display_name, Attributes, BlocksTile, BlocksVisibility, Bystander, Door, EntityMoved, - Hidden, HungerClock, HungerState, Item, Map, Monster, Name, ParticleBuilder, Player, Pools, Position, Renderable, + gamelog, gui::get_item_display_name, raws::Reaction, Attributes, BlocksTile, BlocksVisibility, Door, EntityMoved, + Faction, Hidden, HungerClock, HungerState, Item, Map, Name, ParticleBuilder, Player, Pools, Position, Renderable, RunState, State, SufferDamage, Telepath, TileType, Viewshed, WantsToMelee, WantsToPickupItem, }; use rltk::{Point, RandomNumberGenerator, Rltk, VirtualKeyCode}; @@ -275,7 +275,7 @@ pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> bool { let mut viewsheds = ecs.write_storage::(); let mut telepaths = ecs.write_storage::(); let mut entity_moved = ecs.write_storage::(); - let friendlies = ecs.read_storage::(); + let factions = ecs.read_storage::(); let pools = ecs.read_storage::(); let map = ecs.fetch::(); @@ -296,8 +296,17 @@ pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> bool { let destination_idx = map.xy_idx(pos.x + delta_x, pos.y + delta_y); for potential_target in map.tile_content[destination_idx].iter() { - let friendly = friendlies.get(*potential_target); - if friendly.is_some() { + let mut hostile = true; + if pools.get(*potential_target).is_some() { + if let Some(faction) = factions.get(*potential_target) { + let reaction = + crate::raws::faction_reaction(&faction.name, "player", &crate::raws::RAWS.lock().unwrap()); + if reaction != Reaction::Attack { + hostile = false; + } + } + } + if !hostile { swap_entities.push((*potential_target, pos.x, pos.y)); pos.x = min(map.width - 1, max(0, pos.x + delta_x)); pos.y = min(map.height - 1, max(0, pos.y + delta_y)); @@ -523,23 +532,27 @@ pub fn try_previous_level(ecs: &mut World) -> bool { fn skip_turn(ecs: &mut World) -> bool { let player_entity = ecs.fetch::(); let mut viewsheds = ecs.write_storage::(); - let monsters = ecs.read_storage::(); let worldmap_resource = ecs.fetch::(); let hunger_clocks = ecs.read_storage::(); // Default to being able to heal by waiting. let mut can_heal = true; + let factions = ecs.read_storage::(); // Check viewshed for monsters nearby. If we can see a monster, we can't heal. let viewshed = viewsheds.get_mut(*player_entity).unwrap(); for tile in viewshed.visible_tiles.iter() { let idx = worldmap_resource.xy_idx(tile.x, tile.y); for entity_id in worldmap_resource.tile_content[idx].iter() { - let mob = monsters.get(*entity_id); - match mob { + let faction = factions.get(*entity_id); + match faction { None => {} - Some(_) => { - can_heal = false; + Some(faction) => { + let reaction = + crate::raws::faction_reaction(&faction.name, "player", &crate::raws::RAWS.lock().unwrap()); + if reaction == Reaction::Attack { + can_heal = false; + } } } } diff --git a/src/raws/rawmaster.rs b/src/raws/rawmaster.rs index b1d27ca..67d3a4e 100644 --- a/src/raws/rawmaster.rs +++ b/src/raws/rawmaster.rs @@ -295,8 +295,6 @@ pub fn spawn_named_mob( for flag in flags.iter() { match flag.as_str() { "BLOCKS_TILE" => eb = eb.with(BlocksTile {}), - "BYSTANDER" => eb = eb.with(Bystander {}), - "MONSTER" => eb = eb.with(Monster {}), "MINDLESS" => { eb = eb.with(Faction { name: "mindless".to_string() }); has_faction = true; diff --git a/src/saveload_system.rs b/src/saveload_system.rs index 5e576eb..4647b23 100644 --- a/src/saveload_system.rs +++ b/src/saveload_system.rs @@ -56,7 +56,7 @@ pub fn save_game(ecs: &mut World) { BlocksTile, BlocksVisibility, Burden, - Bystander, + Chasing, Clock, Confusion, Consumable, @@ -83,7 +83,6 @@ pub fn save_game(ecs: &mut World) { MagicMapper, MeleeWeapon, Mind, - Monster, MultiAttack, NaturalAttacks, Name, @@ -174,7 +173,7 @@ pub fn load_game(ecs: &mut World) { BlocksTile, BlocksVisibility, Burden, - Bystander, + Chasing, Clock, Confusion, Consumable, @@ -201,7 +200,6 @@ pub fn load_game(ecs: &mut World) { MagicMapper, MeleeWeapon, Mind, - Monster, MultiAttack, NaturalAttacks, Name,