added GameOver screen

Author: bbarker

src/damage_system.rs

@@ -1,7 +1,8 @@
 use crate::{
-    components::{Name, Position, Positionable},
+    components::{Name, Player, Position, Positionable},
     gamelog::GameLog,
     map::Map,
+    RunState,
 };
 
 use super::{CombatStats, EventIncomingDamage};
@@ -27,23 +28,29 @@ impl<'a> System<'a> for DamageSystem {
     }
 }
 
-pub fn delete_the_dead(ecs: &mut World) {
+pub fn delete_the_dead(ecs: &mut World) -> Option<RunState> {
     let mut dead: Vec<Entity> = Vec::new();
+    let mut newrunstate_opt = None;
     {
         let entities = ecs.entities();
         let mut log = ecs.write_resource::<GameLog>();
         let combat_stats = ecs.read_storage::<CombatStats>();
         let names = ecs.read_storage::<Name>();
         let positions = ecs.read_storage::<Position>();
+        let players = ecs.read_storage::<Player>();
         (&entities, &combat_stats, &positions)
             .join()
             .for_each(|(ent, stats, pos)| {
                 if stats.hp < 1 {
-                    // TODO: add different handling for player death
                     dead.push(ent);
                     if let Some(victim_name) = names.get(ent) {
                         log.entries.push(format!("{} is dead.", victim_name.name));
                     }
+                    if let Some(_player) = players.get(ent) {
+                        {
+                            newrunstate_opt = Some(RunState::GameOver);
+                        }
+                    }
                     let ix = {
                         let map = ecs.fetch::<Map>();
                         map.pos_idx(pos.from())
@@ -57,4 +64,5 @@ pub fn delete_the_dead(ecs: &mut World) {
         ecs.delete_entity(*victim)
             .unwrap_or_else(|er| panic!("Unable to delete entity with id {}: {}", victim.id(), er))
     });
+    newrunstate_opt
 }

src/gui.rs

@@ -557,3 +557,42 @@ pub fn main_menu(gs: &State, ctx: &mut BTerm) -> MainMenuResult {
         }
     }
 }
+
+#[derive(PartialEq, Copy, Clone)]
+pub enum GameOverResult {
+    NoSelection,
+    QuitToMenu,
+}
+
+pub fn game_over(ctx: &mut BTerm) -> GameOverResult {
+    ctx.print_color_centered(
+        15,
+        RGB::named(YELLOW),
+        RGB::named(BLACK),
+        "Your journey has ended!",
+    );
+    ctx.print_color_centered(
+        17,
+        RGB::named(WHITE),
+        RGB::named(BLACK),
+        "One day, we'll tell you all about how you did.",
+    );
+    ctx.print_color_centered(
+        18,
+        RGB::named(WHITE),
+        RGB::named(BLACK),
+        "That day, sadly, is not in this chapter..",
+    );
+
+    ctx.print_color_centered(
+        20,
+        RGB::named(MAGENTA),
+        RGB::named(BLACK),
+        "Press any key to return to the menu.",
+    );
+
+    match ctx.key {
+        None => GameOverResult::NoSelection,
+        Some(_) => GameOverResult::QuitToMenu,
+    }
+}

src/main.rs

@@ -68,6 +68,7 @@ pub enum RunState {
     KeyBindingsMenu,
     SaveGame,
     NextLevel,
+    GameOver,
 }
 
 pub struct State {
@@ -230,15 +231,25 @@ impl GameState for State {
             *runstate
         };
 
+        // FIXME: appears runstate is being possibly set to AwaitingInput before
+        // going into `tick`
+        /*
+        tick runstate: PlayerTurn
+        tick runstate: MonsterTurn
+        tick runstate: AwaitingInput
+        new runstate: GameOver
+        tick runstate: AwaitingInput
+        tick runstate: AwaitingInput
+                */
         ctx.cls();
 
-        match newrunstate {
-            RunState::MainMenu { .. } => {}
+        newrunstate = match newrunstate {
+            RunState::MainMenu { .. } => newrunstate,
             _ => {
                 draw_map(&self.ecs, ctx);
                 draw_ui(&self.ecs, ctx, &self.display);
 
-                delete_the_dead(&mut self.ecs);
+                let game_over_opt = delete_the_dead(&mut self.ecs);
 
                 {
                     // draw renderables
@@ -254,9 +265,9 @@ impl GameState for State {
                             ctx.set(pos.xx, pos.yy, render.fg, render.bg, render.glyph);
                         });
                 }
+                game_over_opt.unwrap_or(newrunstate)
             }
-        }
-
+        };
         match newrunstate {
             RunState::PreRun => {
                 self.run_systems();
@@ -362,6 +373,7 @@ impl GameState for State {
                     }
                     gui::MainMenuStatus::Selected => match result.highlighted {
                         gui::MainMenuSelection::NewGame => {
+                            delete_state(&mut self.ecs);
                             (*self, _) = init_state(false, Some(ctx));
                             newrunstate = RunState::PreRun
                         }
@@ -404,12 +416,33 @@ impl GameState for State {
                 self.goto_next_level();
                 newrunstate = RunState::PreRun;
             }
+            RunState::GameOver => {
+                let result = gui::game_over(ctx);
+                match result {
+                    gui::GameOverResult::NoSelection => {}
+                    gui::GameOverResult::QuitToMenu => {
+                        delete_state(&mut self.ecs);
+                        newrunstate = RunState::MainMenu {
+                            menu_selection: gui::MainMenuSelection::NewGame,
+                        }
+                    }
+                }
+            }
         }
         let mut runstate = self.ecs.fetch_mut::<RunState>();
         *runstate = newrunstate;
     }
 }
 
+pub fn delete_state(ecs: &mut World) {
+    // Delete everything
+    let to_delete: Vec<Entity> = ecs.entities().join().collect();
+    to_delete.iter().for_each(|entity| {
+        ecs.delete_entity(*entity)
+            .unwrap_or_else(|er| panic!("Unable to delete entity with id {}: {}", entity.id(), er))
+    });
+}
+
 pub fn init_state(test_ecs: bool, ctxt_opt: Option<&BTerm>) -> (State, Option<BTerm>) {
     let (mut gs, opt_ctxt) = if test_ecs {
         (

src/saveload_system.rs

@@ -5,8 +5,8 @@ use std::{
 
 use specs::{prelude::*, saveload::*, World, WorldExt};
 
-use crate::components::*;
 use crate::execute_with_type_list;
+use crate::{components::*, delete_state};
 
 const SAVE_FILE: &str = "savegame.json";
 
@@ -78,11 +78,7 @@ macro_rules! deserialize_individually {
 
 pub fn load_game(ecs: &mut World) {
     // Delete everything
-    let to_delete: Vec<Entity> = ecs.entities().join().collect();
-    to_delete.iter().for_each(|entity| {
-        ecs.delete_entity(*entity)
-            .unwrap_or_else(|er| panic!("Unable to delete entity with id {}: {}", entity.id(), er))
-    });
+    delete_state(ecs);
     let save_file_contents = fs::read_to_string(SAVE_FILE)
         .unwrap_or_else(|_| panic!("Unable to read file {}", SAVE_FILE));
     let mut de_ser = serde_json::Deserializer::from_str(&save_file_contents);

src/util.rs

@@ -66,6 +66,7 @@ fn cloneable_fn_test_fn() -> () {
         aa + bb
     }
     let _foo2 = foo.clone();
+    #[allow(unused_allocation)]
     let _foo3 = Box::new(foo).clone_box();
 }