roguelike-game/src/saveload_system.rs

216 lines
5.6 KiB
Rust
Raw Normal View History

2021-12-10 20:16:48 -05:00
use std::fs;
use std::fs::File;
use std::path::Path;
2021-11-08 13:58:40 -05:00
use specs::error::NoError;
use specs::prelude::*;
use specs::saveload::{
DeserializeComponents, MarkedBuilder, SerializeComponents, SimpleMarker, SimpleMarkerAllocator,
};
2021-12-10 20:16:48 -05:00
use crate::components::*;
2021-11-08 13:58:40 -05:00
macro_rules! serialize_individually {
($ecs:expr, $ser:expr, $data:expr, $( $type:ty),*,) => {
2021-11-08 13:58:40 -05:00
$(
SerializeComponents::<NoError, SimpleMarker<SerializeMe>>::serialize(
&( $ecs.read_storage::<$type>(), ),
&$data.0,
&$data.1,
&mut $ser,
)
.unwrap();
)*
};
}
2021-11-09 10:49:39 -05:00
#[cfg(target_arch = "wasm32")]
pub fn save_game(_ecs: &mut World) {}
#[cfg(not(target_arch = "wasm32"))]
2021-11-08 13:58:40 -05:00
pub fn save_game(ecs: &mut World) {
// Create helper
let mapcopy = ecs.get_mut::<crate::map::Map>().unwrap().clone();
let savehelper = ecs
.create_entity()
.with(SerializationHelper { map: mapcopy })
.marked::<SimpleMarker<SerializeMe>>()
.build();
// Actually serialize
{
let data = (
ecs.entities(),
ecs.read_storage::<SimpleMarker<SerializeMe>>(),
);
let writer = File::create("./savegame.json").unwrap();
let mut serializer = serde_json::Serializer::new(writer);
serialize_individually!(
ecs,
serializer,
data,
Position,
Renderable,
Player,
Viewshed,
Monster,
Name,
BlocksTile,
CombatStats,
SufferDamage,
WantsToMelee,
Item,
Consumable,
Ranged,
InflictsDamage,
AreaOfEffect,
Confusion,
ProvidesHealing,
InBackpack,
WantsToPickupItem,
WantsToUseItem,
WantsToDropItem,
2021-11-15 09:19:22 -05:00
SerializationHelper,
2021-11-15 11:32:09 -05:00
Equippable,
Equipped,
MeleePowerBonus,
DefenseBonus,
2021-11-16 11:33:58 -05:00
WantsToRemoveItem,
2021-11-17 16:23:01 -05:00
ParticleLifetime,
HungerClock,
ProvidesFood,
MagicMapper,
2021-11-29 16:00:07 -05:00
Hidden,
EntryTrigger,
EntityMoved,
2021-12-01 09:46:34 -05:00
SingleActivation,
2021-12-17 14:07:14 -05:00
BlocksVisibility,
Door,
2021-11-08 13:58:40 -05:00
);
}
// Clean up
ecs.delete_entity(savehelper)
.expect("Failed to clean up savehelper component");
}
pub fn does_save_exist() -> bool {
Path::new("./savegame.json").exists()
}
2021-11-09 10:29:23 -05:00
macro_rules! deserialize_individually {
($ecs:expr, $de:expr, $data:expr, $( $type:ty),*,) => {
$(
DeserializeComponents::<NoError, _>::deserialize(
&mut ( &mut $ecs.write_storage::<$type>(), ),
&$data.0, // entities
&mut $data.1, // marker
&mut $data.2, // allocater
&mut $de,
)
.unwrap();
)*
};
}
2021-11-09 10:29:23 -05:00
pub fn load_game(ecs: &mut World) {
{
// Delete everything
let mut to_delete = Vec::new();
for e in ecs.entities().join() {
to_delete.push(e);
}
for del in to_delete.iter() {
ecs.delete_entity(*del).expect("Failed to delete entity");
}
}
let data = fs::read_to_string("./savegame.json").unwrap();
let mut de = serde_json::Deserializer::from_str(&data);
{
let mut d = (
&mut ecs.entities(),
&mut ecs.write_storage::<SimpleMarker<SerializeMe>>(),
&mut ecs.write_resource::<SimpleMarkerAllocator<SerializeMe>>(),
);
deserialize_individually!(
ecs,
de,
d,
Position,
Renderable,
Player,
Viewshed,
Monster,
Name,
BlocksTile,
CombatStats,
SufferDamage,
WantsToMelee,
Item,
Consumable,
Ranged,
InflictsDamage,
AreaOfEffect,
Confusion,
ProvidesHealing,
InBackpack,
WantsToPickupItem,
WantsToUseItem,
WantsToDropItem,
2021-11-15 09:19:22 -05:00
SerializationHelper,
2021-11-15 11:32:09 -05:00
Equippable,
Equipped,
MeleePowerBonus,
DefenseBonus,
2021-11-16 11:33:58 -05:00
WantsToRemoveItem,
2021-11-17 16:23:01 -05:00
ParticleLifetime,
HungerClock,
ProvidesFood,
MagicMapper,
2021-11-29 16:00:07 -05:00
Hidden,
EntryTrigger,
EntityMoved,
2021-12-01 09:46:34 -05:00
SingleActivation,
2021-12-17 14:07:14 -05:00
BlocksVisibility,
Door,
2021-11-09 10:29:23 -05:00
);
}
let mut deleteme: Option<Entity> = None;
{
let entities = ecs.entities();
let helper = ecs.read_storage::<SerializationHelper>();
let player = ecs.read_storage::<Player>();
let position = ecs.read_storage::<Position>();
for (e, h) in (&entities, &helper).join() {
let mut worldmap = ecs.write_resource::<crate::map::Map>();
*worldmap = h.map.clone();
worldmap.tile_content = vec![Vec::new(); crate::map::MAP_COUNT];
deleteme = Some(e);
}
for (e, _p, pos) in (&entities, &player, &position).join() {
let mut ppos = ecs.write_resource::<rltk::Point>();
*ppos = rltk::Point::new(pos.x, pos.y);
let mut player_resource = ecs.write_resource::<Entity>();
*player_resource = e;
}
}
ecs.delete_entity(deleteme.unwrap())
.expect("Unable to delete helper entity");
2021-11-09 10:29:23 -05:00
}
pub fn delete_save() {
if Path::new("./savegame.json").exists() {
std::fs::remove_file("./savegame.json").expect("Failed to delete save file.");
}
}