Switch serialization format to json (#58)

* switch to serde_json serialization and keep backward compat

* put backward compat code in a separate module

* test backward compat

* update changelog

Author: facundoolano

CHANGELOG.md

@@ -1,6 +1,9 @@
 # Changelog
 
 ## Unreleased
+### Changed
+* Game data is now serialized to JSON to allow extending it without breaking backwards compatibility.
+
 ## [0.4.0](https://github.com/facundoolano/rpg-cli/releases/tag/0.4.0) - 2021-06-05
 ### Added
 * This Changelog

Cargo.lock

@@ -16,3 +16,4 @@ clap = "3.0.0-beta.2"
 typetag = "0.1"
 dunce = "1.0.1"
 once_cell = "1.7.2"
+serde_json = "1.0.64"

Cargo.toml

@@ -9,6 +9,7 @@ use crate::randomizer::{random, Randomizer};
 use class::Class;
 
 #[derive(Serialize, Deserialize, Debug)]
+#[serde(default)]
 pub struct Character {
     #[serde(skip, default = "default_class")]
     class: &'static Class,
@@ -25,6 +26,12 @@ pub struct Character {
     pub speed: i32,
 }
 
+impl Default for Character {
+    fn default() -> Self {
+        Character::player()
+    }
+}
+
 // Always attach the static hero class to deserialized characters
 fn default_class() -> &'static Class {
     &Class::HERO

src/character/mod.rs

@@ -0,0 +1,76 @@
+use super::tombstone::Tombstone;
+use crate::character::Character;
+use crate::item::Item;
+use crate::location::Location;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// v0.4.0 of the game struct, kept for backwards compatibility when upgrading
+/// the game data file to the new version
+/// FIXME this will be removed on a subsequent version
+#[derive(Serialize, Deserialize)]
+struct Game040 {
+    pub player: Character,
+    pub location: Location,
+    pub gold: i32,
+    inventory: HashMap<String, Vec<Box<dyn Item>>>,
+    tombstones: HashMap<Location, Tombstone>,
+}
+
+/// Get a new Game instance out of a v0.4.0 one
+pub fn deserialize(data: &[u8]) -> Result<super::Game, bincode::Error> {
+    let mut v4game: Game040 = bincode::deserialize(&data)?;
+    let mut new_game = super::Game::new();
+    std::mem::swap(&mut new_game.player, &mut v4game.player);
+    std::mem::swap(&mut new_game.location, &mut v4game.location);
+    std::mem::swap(&mut new_game.inventory, &mut v4game.inventory);
+    new_game.tombstones = v4game
+        .tombstones
+        .drain()
+        .map(|(l, t)| (l.to_string(), t))
+        .collect();
+    new_game.gold = v4game.gold;
+    Ok(new_game)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::item;
+    use item::equipment::Equipment;
+
+    #[test]
+    fn test_backwards_compatibility() {
+        // build a game040 with everything
+        let mut game_v4 = Game040 {
+            location: Location::home(),
+            player: Character::player(),
+            gold: 10,
+            inventory: HashMap::new(),
+            tombstones: HashMap::new(),
+        };
+        game_v4.player.sword = Some(item::equipment::Sword::new(1));
+        game_v4.player.shield = Some(item::equipment::Shield::new(1));
+        game_v4
+            .inventory
+            .insert("potion".to_string(), vec![Box::new(item::Potion::new(1))]);
+
+        let mut tombstone_game = super::super::Game::new();
+        tombstone_game.add_item("potion", Box::new(item::Potion::new(1)));
+        game_v4
+            .tombstones
+            .insert(Location::home(), Tombstone::drop(&mut tombstone_game));
+
+        let data = bincode::serialize(&game_v4).unwrap();
+        let mut new_game = deserialize(&data).unwrap();
+
+        assert_eq!(10, new_game.gold);
+        assert!(new_game.location.is_home());
+        assert!(new_game.player.sword.is_some());
+        assert!(new_game.player.shield.is_some());
+        assert_eq!(1 as usize, *new_game.inventory().get("potion").unwrap());
+        // pick up tombstone @ home
+        new_game.visit_home();
+        assert_eq!(2 as usize, *new_game.inventory().get("potion").unwrap());
+    }
+}

src/game/game040.rs

@@ -12,6 +12,7 @@ use std::{fs, io, path};
 use tombstone::Tombstone;
 
 pub mod battle;
+mod game040;
 pub mod tombstone;
 
 #[derive(Debug)]
@@ -22,12 +23,13 @@ pub enum Error {
 }
 
 #[derive(Serialize, Deserialize)]
+#[serde(default)]
 pub struct Game {
     pub player: Character,
     pub location: Location,
     pub gold: i32,
     inventory: HashMap<String, Vec<Box<dyn Item>>>,
-    tombstones: HashMap<Location, Tombstone>,
+    tombstones: HashMap<String, Tombstone>,
 }
 
 impl Game {
@@ -43,7 +45,13 @@ impl Game {
 
     pub fn load() -> Result<Self, Error> {
         let data = fs::read(data_file()).or(Err(Error::NoDataFile))?;
-        let game: Game = bincode::deserialize(&data).unwrap();
+        let game: Game = if let Ok(game) = serde_json::from_slice(&data) {
+            game
+        } else {
+            // if json deserialization fails, attempt bincode assuming
+            // it may be a file from v0.4.0
+            game040::deserialize(&data).unwrap()
+        };
         Ok(game)
     }
 
@@ -53,7 +61,7 @@ impl Game {
             fs::create_dir(&rpg_dir).unwrap();
         }
 
-        let data = bincode::serialize(&self).unwrap();
+        let data = serde_json::to_vec(&self).unwrap();
         fs::write(data_file(), &data)
     }
 
@@ -134,7 +142,7 @@ impl Game {
 
     /// If there's a tombstone laying in the current location, pick up its items
     fn pick_up_tombstone(&mut self) -> bool {
-        if let Some(mut tombstone) = self.tombstones.remove(&self.location) {
+        if let Some(mut tombstone) = self.tombstones.remove(&self.location.to_string()) {
             tombstone.pick_up(self);
             true
         } else {
@@ -205,7 +213,7 @@ impl Game {
         } else {
             // leave hero items in the location
             let tombstone = Tombstone::drop(self);
-            self.tombstones.insert(self.location.clone(), tombstone);
+            self.tombstones.insert(self.location.to_string(), tombstone);
 
             log::battle_lost(&self.player);
             Err(Error::GameOver)