logs + events refactor

src/components.rs

@@ -4,6 +4,7 @@ use specs::error::NoError;
 use specs::prelude::*;
 use specs::saveload::{ConvertSaveload, Marker};
 use specs_derive::*;
+use std::collections::HashMap;
 
 // Serialization helper code. We need to implement ConvertSaveload for each type that contains an
 // Entity.
@@ -12,6 +13,8 @@ pub struct SerializeMe;
 #[derive(Component, Serialize, Deserialize, Clone)]
 pub struct SerializationHelper {
     pub map: super::map::Map,
+    pub log: Vec<Vec<crate::gamelog::LogFragment>>,
+    pub events: HashMap<String, i32>,
 }
 
 #[derive(Component, ConvertSaveload, Clone)]

src/gamelog/events.rs

@@ -0,0 +1,43 @@
+use std::collections::HashMap;
+use std::sync::Mutex;
+
+lazy_static! {
+    static ref EVENTS: Mutex<HashMap<String, i32>> = Mutex::new(HashMap::new());
+}
+
+pub fn clear_events() {
+    EVENTS.lock().unwrap().clear();
+}
+
+pub fn record_event<T: ToString>(event: T, n: i32) {
+    let event_name = event.to_string();
+    let mut events_lock = EVENTS.lock();
+    let mut events = events_lock.as_mut().unwrap();
+    if let Some(e) = events.get_mut(&event_name) {
+        *e += n;
+    } else {
+        events.insert(event_name, n);
+    }
+}
+
+pub fn get_event_count<T: ToString>(event: T) -> i32 {
+    let event_name = event.to_string();
+    let events_lock = EVENTS.lock();
+    let events = events_lock.unwrap();
+    if let Some(e) = events.get(&event_name) {
+        *e
+    } else {
+        0
+    }
+}
+
+pub fn clone_events() -> HashMap<String, i32> {
+    EVENTS.lock().unwrap().clone()
+}
+
+pub fn load_events(events: HashMap<String, i32>) {
+    EVENTS.lock().unwrap().clear();
+    events.iter().for_each(|(k, v)| {
+        EVENTS.lock().unwrap().insert(k.to_string(), *v);
+    });
+}

src/gamelog/logstore.rs

@@ -32,3 +32,12 @@ pub fn log_display() -> TextBuilder {
 
     return buf;
 }
+
+pub fn clone_log() -> Vec<Vec<crate::gamelog::LogFragment>> {
+    return LOG.lock().unwrap().clone();
+}
+
+pub fn restore_log(log: &mut Vec<Vec<crate::gamelog::LogFragment>>) {
+    LOG.lock().unwrap().clear();
+    LOG.lock().unwrap().append(log);
+}

src/gamelog/mod.rs

@@ -4,8 +4,12 @@ mod builder;
 pub use builder::*;
 mod logstore;
 use logstore::*;
-pub use logstore::{clear_log, log_display};
+pub use logstore::{clear_log, clone_log, log_display, restore_log};
+mod events;
+pub use events::*;
 
+use serde::{Deserialize, Serialize};
+#[derive(Serialize, Deserialize, Clone)]
 pub struct LogFragment {
     pub colour: RGB,
     pub text: String,

src/gui.rs

@@ -25,7 +25,16 @@ pub fn draw_ui(ecs: &World, ctx: &mut Rltk) {
     // Render depth
     let map = ecs.fetch::<Map>();
     let depth = format!(" D{} ", map.depth);
-    ctx.print_color(74, 43, RGB::named(rltk::YELLOW), RGB::named(rltk::BLACK), &depth);
+    ctx.print_color_right(78, 43, RGB::named(rltk::YELLOW), RGB::named(rltk::BLACK), &depth);
+
+    // Render turn
+    ctx.print_color_right(
+        78,
+        49,
+        RGB::named(rltk::YELLOW),
+        RGB::named(rltk::BLACK),
+        &format!(" T{} ", crate::gamelog::get_event_count("Turn")),
+    );
 
     // Render mouse cursor
     let mouse_pos = ctx.mouse_pos();

src/main.rs

@@ -214,6 +214,9 @@ impl GameState for State {
             }
             RunState::AwaitingInput => {
                 new_runstate = player_input(self, ctx);
+                if new_runstate != RunState::AwaitingInput {
+                    gamelog::record_event("Turn", 1);
+                }
             }
             RunState::PlayerTurn => {
                 self.run_systems();
@@ -432,6 +435,7 @@ fn main() -> rltk::BError {
     gs.ecs.insert(player_entity);
 
     gamelog::clear_log();
+    gamelog::clear_events();
     gamelog::Logger::new()
         .append("Welcome!")
         .colour(rltk::CYAN)

src/saveload_system.rs

@@ -27,8 +27,15 @@ pub fn save_game(_ecs: &mut World) {}
 pub fn save_game(ecs: &mut World) {
     // Create helper
     let mapcopy = ecs.get_mut::<super::map::Map>().unwrap().clone();
-    let savehelper =
+    let savehelper = ecs
-        ecs.create_entity().with(SerializationHelper { map: mapcopy }).marked::<SimpleMarker<SerializeMe>>().build();
+        .create_entity()
+        .with(SerializationHelper {
+            map: mapcopy,
+            log: crate::gamelog::clone_log(),
+            events: crate::gamelog::clone_events(),
+        })
+        .marked::<SimpleMarker<SerializeMe>>()
+        .build();
 
     // Actually serialize
     {
@@ -156,6 +163,8 @@ pub fn load_game(ecs: &mut World) {
             *worldmap = h.map.clone();
             worldmap.tile_content = vec![Vec::new(); super::map::MAPCOUNT];
             deleteme = Some(e);
+            crate::gamelog::restore_log(&mut h.log.clone());
+            crate::gamelog::load_events(h.events.clone());
         }
         for (e, _p, pos) in (&entities, &player, &position).join() {
             let mut ppos = ecs.write_resource::<rltk::Point>();