Merge pull request #72 from facundoolano/chest_refactor

Unify chest and tombstone handling

Author: facundoolano

src/datafile/game040.rs

@@ -1,6 +1,6 @@
 use crate::character::Character;
 use crate::game;
-use crate::game::tombstone::Tombstone;
+use crate::game::chest::Chest;
 use crate::item::Item;
 use crate::location::Location;
 use serde::{Deserialize, Serialize};
@@ -15,7 +15,7 @@ struct Game040 {
     pub location: Location,
     pub gold: i32,
     inventory: HashMap<String, Vec<Box<dyn Item>>>,
-    tombstones: HashMap<Location, Tombstone>,
+    tombstones: HashMap<Location, Chest>,
 }
 
 /// Get a new Game instance out of a v0.4.0 one
@@ -60,7 +60,7 @@ mod tests {
         tombstone_game.add_item("potion", Box::new(item::Potion::new(1)));
         game_v4
             .tombstones
-            .insert(Location::home(), Tombstone::drop(&mut tombstone_game));
+            .insert(Location::home(), Chest::drop(&mut tombstone_game));
 
         let data = bincode::serialize(&game_v4).unwrap();
         let mut new_game = deserialize(&data).unwrap();

src/event.rs

@@ -59,10 +59,7 @@ pub enum Event<'a> {
     ChestFound {
         items: &'a [String],
         gold: i32,
-    },
-    TombstoneFound {
-        items: &'a [String],
-        gold: i32,
+        is_tombstone: bool,
     },
 }
 

src/game/tombstone.rs src/game/chest.rssrc/game/tombstone.rs renamed to src/game/chest.rs

@@ -1,21 +1,56 @@
 use crate::game;
 use crate::item::equipment::{Shield, Sword};
-use crate::item::{equipment::Equipment, Item};
+use crate::item::{equipment::Equipment, Item, Potion};
+use crate::randomizer::random;
+use crate::randomizer::Randomizer;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
 /// The tombstone is a bag of items left at the hero's dying location.
 /// When the next hero visits that location, it can pick up the items.
 #[derive(Serialize, Deserialize)]
-pub struct Tombstone {
+pub struct Chest {
     items: HashMap<String, Vec<Box<dyn Item>>>,
     sword: Option<Sword>,
     shield: Option<Shield>,
     gold: i32,
 }
 
-impl Tombstone {
-    /// Dump the equipment, items and gold from a hero.
+impl Chest {
+    /// Randomly generate a chest at the current location.
+    pub fn generate(game: &game::Game) -> Option<Self> {
+        // FIXME improve random generation logic
+        // FIXME inlcude other items
+
+        match random().range(6) {
+            0 => {
+                let gold = random().gold_gained(game.player.level * 200);
+                Some(Self {
+                    items: HashMap::new(),
+                    sword: None,
+                    shield: None,
+                    gold,
+                })
+            }
+            1 => {
+                let potion = Box::new(Potion::new(game.player.level));
+                let potions: Vec<Box<dyn Item>> = vec![potion];
+
+                let mut items = HashMap::new();
+                items.insert("potion".to_string(), potions);
+
+                Some(Self {
+                    items,
+                    sword: None,
+                    shield: None,
+                    gold: 0,
+                })
+            }
+            _ => None,
+        }
+    }
+
+    /// Remove the gold, items and equipment from a hero and return them as a new chest.
     pub fn drop(game: &mut game::Game) -> Self {
         let sword = game.player.sword.take();
         let shield = game.player.shield.take();
@@ -31,7 +66,7 @@ impl Tombstone {
         }
     }
 
-    /// Add the items of the tombstone to the current game
+    /// Add the items of this chest to the current game/hero
     pub fn pick_up(&mut self, game: &mut game::Game) -> (Vec<String>, i32) {
         let mut to_log = Vec::new();
 
@@ -74,7 +109,7 @@ mod tests {
     #[test]
     fn test_empty_drop_pickup() {
         let mut game = game::Game::new();
-        let mut tomb = Tombstone::drop(&mut game);
+        let mut tomb = Chest::drop(&mut game);
 
         assert_eq!(0, tomb.gold);
         assert!(tomb.sword.is_none());
@@ -99,7 +134,7 @@ mod tests {
         game.player.shield = Some(Shield::new(1));
         game.gold = 100;
 
-        let mut tomb = Tombstone::drop(&mut game);
+        let mut tomb = Chest::drop(&mut game);
 
         assert_eq!(100, tomb.gold);
         assert!(tomb.sword.is_some());
@@ -124,7 +159,7 @@ mod tests {
         game.player.shield = Some(Shield::new(10));
         game.gold = 100;
 
-        let mut tomb = Tombstone::drop(&mut game);
+        let mut tomb = Chest::drop(&mut game);
 
         // set some defaults for the new game before picking up
         let mut game = game::Game::new();

src/game/mod.rs

@@ -3,17 +3,17 @@ extern crate dirs;
 use crate::character;
 use crate::character::Character;
 use crate::event::Event;
-use crate::item::{Item, Potion};
+use crate::item::Item;
 use crate::location::Location;
 use crate::quest::QuestList;
 use crate::randomizer::random;
 use crate::randomizer::Randomizer;
+use chest::Chest;
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
-use tombstone::Tombstone;
 
 pub mod battle;
-pub mod tombstone;
+pub mod chest;
 
 #[derive(Serialize, Deserialize)]
 #[serde(default)]
@@ -23,7 +23,7 @@ pub struct Game {
     pub gold: i32,
     pub quests: QuestList,
     pub inventory: HashMap<String, Vec<Box<dyn Item>>>,
-    pub tombstones: HashMap<String, Tombstone>,
+    pub tombstones: HashMap<String, Chest>,
     inspected: HashSet<Location>,
 }
 
@@ -77,35 +77,28 @@ impl Game {
     }
 
     /// Look for chests and tombstones at the current location.
-    /// Remembers previous checks for consistency.
+    /// Remembers previously visited locations for consistency.
     pub fn inspect(&mut self) {
-        self.pick_up_tombstone();
+        let maybe_tomb = self.tombstones.remove(&self.location.to_string());
+        self.pick_up_chest(maybe_tomb, true);
 
         if !self.inspected.contains(&self.location) {
             self.inspected.insert(self.location.clone());
+            self.pick_up_chest(Chest::generate(self), false);
+        }
+    }
 
-            // this could be extended to find better items, with a non uniform
-            // probability, and to change according to the distance from home
-            // it's likely better to extract to an item generator module at that point
-            match random().range(6) {
-                0 => {
-                    let gold = random().gold_gained(self.player.level * 200);
-                    Event::emit(self, Event::ChestFound { items: &[], gold });
-                    self.gold += gold;
-                }
-                1 => {
-                    let potion = Potion::new(self.player.level);
-                    Event::emit(
-                        self,
-                        Event::ChestFound {
-                            items: &["potion".to_string()],
-                            gold: 0,
-                        },
-                    );
-                    self.add_item("potion", Box::new(potion));
-                }
-                _ => {}
-            }
+    fn pick_up_chest(&mut self, maybe_chest: Option<Chest>, is_tombstone: bool) {
+        if let Some(mut chest) = maybe_chest {
+            let (items, gold) = chest.pick_up(self);
+            Event::emit(
+                self,
+                Event::ChestFound {
+                    items: &items,
+                    gold,
+                    is_tombstone,
+                },
+            );
         }
     }
 
@@ -177,20 +170,6 @@ impl Game {
             .collect::<HashMap<&str, usize>>()
     }
 
-    /// If there's a tombstone laying in the current location, pick up its items
-    fn pick_up_tombstone(&mut self) {
-        if let Some(mut tombstone) = self.tombstones.remove(&self.location.to_string()) {
-            let (items, gold) = tombstone.pick_up(self);
-            Event::emit(
-                self,
-                Event::TombstoneFound {
-                    items: &items,
-                    gold,
-                },
-            );
-        }
-    }
-
     pub fn maybe_spawn_enemy(&mut self) -> Option<Character> {
         let distance = self.location.distance_from_home();
         if random().should_enemy_appear(&distance) {
@@ -272,7 +251,7 @@ impl Game {
             }
             Err(character::Dead) => {
                 // leave hero items in the location
-                let tombstone = Tombstone::drop(self);
+                let tombstone = Chest::drop(self);
                 self.tombstones.insert(self.location.to_string(), tombstone);
 
                 Event::emit(self, Event::BattleLost);

src/log.rs

@@ -55,10 +55,18 @@ pub fn handle(game: &Game, event: &Event) {
         Event::BattleLost => {
             battle_lost(&game.player);
         }
-        Event::ChestFound { items, gold } => {
+        Event::ChestFound {
+            is_tombstone: false,
+            items,
+            gold,
+        } => {
             chest(items, *gold);
         }
-        Event::TombstoneFound { items, gold } => {
+        Event::ChestFound {
+            is_tombstone: true,
+            items,
+            gold,
+        } => {
             tombstone(items, *gold);
         }
         Event::Bribe { cost } => {

src/quest/tutorial.rs

@@ -103,6 +103,12 @@ impl Quest for VisitTomb {
     }
 
     fn handle(&mut self, event: &Event) -> bool {
-        matches!(event, Event::TombstoneFound { .. })
+        matches!(
+            event,
+            Event::ChestFound {
+                is_tombstone: true,
+                ..
+            }
+        )
     }
 }