Merge pull request #74 from facundoolano/chest_random

Random chest contents

Author: facundoolano

src/character/mod.rs

@@ -203,6 +203,13 @@ impl Character {
             _ => Ok(None),
         }
     }
+
+    /// Return the player level rounded to offer items at "pretty levels", e.g.
+    /// potion[1], sword[5]
+    pub fn rounded_level(self: &Character) -> i32 {
+        // allow level 1 or level 5n
+        std::cmp::max(1, (self.level / 5) * 5)
+    }
 }
 
 #[cfg(test)]

src/game/chest.rs

@@ -1,6 +1,6 @@
 use crate::game;
 use crate::item::equipment::{Shield, Sword};
-use crate::item::{equipment::Equipment, Item, Potion};
+use crate::item::{equipment::Equipment, Escape, Item, Potion, Remedy};
 use crate::randomizer::random;
 use crate::randomizer::Randomizer;
 use serde::{Deserialize, Serialize};
@@ -20,34 +20,35 @@ pub struct Chest {
 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,
+        // To give the impression of "dynamic" chest contents, each content type
+        // is randomized separately, and what's found is combined into a single
+        // chest at the end
+        let distance = &game.location.distance_from_home();
+        let gold_chest = random().gold_chest(distance);
+        let equipment_chest = random().equipment_chest(distance);
+        let item_chest = random().item_chest(distance);
+
+        let mut chest = Self::default();
+
+        if gold_chest {
+            chest.gold = random().gold_gained(game.player.level * 200)
+        }
+
+        if equipment_chest {
+            let (sword, shield) = random_equipment(game.player.rounded_level());
+            chest.sword = sword;
+            chest.shield = shield;
+        }
+
+        if item_chest {
+            chest.items = random_items(game.player.rounded_level());
+        }
+
+        // Return None instead of an empty chest if none was found
+        if gold_chest || equipment_chest || item_chest {
+            Some(chest)
+        } else {
+            None
         }
     }
 
@@ -125,6 +126,42 @@ impl Chest {
     }
 }
 
+// TODO consider using weighted random instead of these matches
+fn random_equipment(level: i32) -> (Option<Sword>, Option<Shield>) {
+    match random().range(15) {
+        n if n < 8 => (Some(Sword::new(level)), None),
+        n if n < 13 => (None, Some(Shield::new(level))),
+        14 => (Some(Sword::new(level + 5)), None),
+        _ => (None, Some(Shield::new(level + 5))),
+    }
+}
+
+fn random_items(level: i32) -> HashMap<String, Vec<Box<dyn Item>>> {
+    let mut map = HashMap::new();
+    let potion = || Box::new(Potion::new(level));
+
+    let (key, items): (&str, Vec<Box<dyn Item>>) = match random().range(15) {
+        n if n < 7 => ("potion", vec![potion()]),
+        n if n < 11 => ("potion", vec![potion(), potion()]),
+        n if n < 13 => ("potion", vec![potion(), potion(), potion()]),
+        13 => ("remedy", vec![Box::new(Remedy::new())]),
+        _ => ("escape", vec![Box::new(Escape::new())]),
+    };
+    map.insert(key.to_string(), items);
+    map
+}
+
+impl Default for Chest {
+    fn default() -> Self {
+        Self {
+            gold: 0,
+            sword: None,
+            shield: None,
+            items: HashMap::new(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/game/mod.rs

@@ -135,6 +135,8 @@ impl Game {
         self.visit(Location::home()).unwrap_or_default();
     }
 
+    // TODO consider introducing an item "bag" wrapper over these types of hashmaps
+    // (same is used in chests and in tests)
     pub fn add_item(&mut self, name: &str, item: Box<dyn Item>) {
         let entry = self
             .inventory

src/item/shop.rs

@@ -37,7 +37,7 @@ pub fn buy(game: &mut Game, item: &str) -> Result<(), Error> {
 /// Build a list of items currently available at the shop
 fn available_items(player: &Character) -> Vec<(String, Box<dyn Shoppable>)> {
     let mut items = Vec::<(String, Box<dyn Shoppable>)>::new();
-    let level = available_level(player);
+    let level = player.rounded_level();
 
     let sword = Sword::new(level);
     if sword.is_upgrade_from(&player.sword.as_ref()) {
@@ -61,13 +61,6 @@ fn available_items(player: &Character) -> Vec<(String, Box<dyn Shoppable>)> {
     items
 }
 
-/// The offered items/equipment have levels e.g. potion[1], sword[5], etc.
-/// they become available for purchase only when the player reaches that level
-fn available_level(player: &Character) -> i32 {
-    // allow level 1 or level 5n
-    std::cmp::max(1, (player.level / 5) * 5)
-}
-
 pub trait Shoppable: Display {
     fn cost(&self) -> i32;
     fn buy(&self, game: &mut Game) -> Result<(), Error> {

src/log.rs

@@ -297,11 +297,11 @@ fn chest(items: &[String], gold: i32) {
 }
 
 fn tombstone(items: &[String], gold: i32) {
-    format_ls("\u{1FAA6}", items, gold);
+    format_ls("\u{1FAA6} ", items, gold);
 }
 
 fn format_ls(emoji: &str, items: &[String], gold: i32) {
-    print!("{} ", emoji);
+    print!("{}", emoji);
     if gold > 0 {
         print!("  {}", format_gold_plus(gold));
     }

src/randomizer.rs

@@ -33,6 +33,10 @@ pub trait Randomizer {
     fn stat_increase(&self, increase: i32) -> i32;
 
     fn range(&self, max: i32) -> i32;
+
+    fn gold_chest(&self, distance: &location::Distance) -> bool;
+    fn equipment_chest(&self, distance: &location::Distance) -> bool;
+    fn item_chest(&self, distance: &location::Distance) -> bool;
 }
 
 #[cfg(not(test))]
@@ -127,6 +131,36 @@ impl Randomizer for DefaultRandomizer {
         let mut rng = rand::thread_rng();
         rng.gen_range(0..max)
     }
+
+    fn gold_chest(&self, distance: &location::Distance) -> bool {
+        let mut rng = rand::thread_rng();
+
+        match distance {
+            location::Distance::Near(_) => rng.gen_ratio(5, 20),
+            location::Distance::Mid(_) => rng.gen_ratio(6, 20),
+            location::Distance::Far(_) => rng.gen_ratio(3, 20),
+        }
+    }
+
+    fn equipment_chest(&self, distance: &location::Distance) -> bool {
+        let mut rng = rand::thread_rng();
+
+        match distance {
+            location::Distance::Near(_) => false,
+            location::Distance::Mid(_) => rng.gen_ratio(3, 20),
+            location::Distance::Far(_) => rng.gen_ratio(5, 20),
+        }
+    }
+
+    fn item_chest(&self, distance: &location::Distance) -> bool {
+        let mut rng = rand::thread_rng();
+
+        match distance {
+            location::Distance::Near(_) => rng.gen_ratio(3, 20),
+            location::Distance::Mid(_) => rng.gen_ratio(8, 20),
+            location::Distance::Far(_) => rng.gen_ratio(14, 20),
+        }
+    }
 }
 
 fn is_critical() -> bool {
@@ -198,6 +232,18 @@ impl Randomizer for TestRandomizer {
     fn range(&self, max: i32) -> i32 {
         max
     }
+
+    fn gold_chest(&self, _distance: &location::Distance) -> bool {
+        false
+    }
+
+    fn equipment_chest(&self, _distance: &location::Distance) -> bool {
+        false
+    }
+
+    fn item_chest(&self, _distance: &location::Distance) -> bool {
+        false
+    }
 }
 
 #[cfg(test)]