cargo fmt

chapter-07-damage/src/components.rs

@@ -1,5 +1,5 @@
-use specs::prelude::*;
 use rltk::RGB;
+use specs::prelude::*;
 
 #[derive(Component)]
 pub struct Position {
@@ -60,7 +60,6 @@ pub struct MoveEvent {
     pub tgt_y: i32,
 }
 
-
 /// This type represents all the "low-level" actions we have available
 /// to us, corresponding directly to the set of actions we have bound
 /// on the keys
@@ -68,8 +67,5 @@ pub struct MoveEvent {
 pub enum InputEvent {
     // attempt to move the player some amount in the given direction
     // (delta_x and delta_y should be -1, 0, or 1)
-    PlayerMovement {
-        delta_x: i32,
-        delta_y: i32,
-    },
+    PlayerMovement { delta_x: i32, delta_y: i32 },
 }

chapter-07-damage/src/main.rs

@@ -1,7 +1,6 @@
 #[macro_use]
 extern crate specs_derive;
 
-
 mod components;
 mod map;
 mod player;

chapter-07-damage/src/map.rs

@@ -1,8 +1,8 @@
-use std::cmp::{max, min};
 use crate::rect::Rect;
+use std::cmp::{max, min};
 
-use specs::prelude::*;
 use rltk::{Algorithm2D, BaseMap, Console, Point, RandomNumberGenerator, Rltk, RGB};
+use specs::prelude::*;
 
 const MAPWIDTH: usize = 80;
 const MAPHEIGHT: usize = 43;
@@ -139,7 +139,7 @@ impl Map {
     ) -> Option<Entity> {
         for potential in self.tile_content[target].iter() {
             if stats.contains(*potential) {
-                return Some(*potential)
+                return Some(*potential);
             }
         }
         None
@@ -207,7 +207,6 @@ impl Algorithm2D for Map {
     }
 }
 
-
 pub fn draw_map(ecs: &World, ctx: &mut Rltk) {
     let map = ecs.fetch::<Map>();
 

chapter-07-damage/src/player.rs

@@ -1,8 +1,7 @@
+use crate::{CombatStats, InputEvent, Map, MoveEvent, Position, RunState, State, WantsToMelee};
 use rltk::{Rltk, VirtualKeyCode};
-use crate::{CombatStats, Map, Position, MoveEvent, RunState, State, WantsToMelee, InputEvent};
 use specs::prelude::*;
 
-
 /// Handles converting low-level `InputEvent` components (which may
 /// represent one of several actions, or even a completely invalid
 /// action such as walking into a wall) and dispatches them to the
@@ -21,7 +20,10 @@ impl<'a> System<'a> for HandleInputEvent {
         WriteStorage<'a, MoveEvent>,
     );
 
-    fn run(&mut self, (mut event, map, entities, position, stats, mut attack, mut mov): Self::SystemData) {
+    fn run(
+        &mut self,
+        (mut event, map, entities, position, stats, mut attack, mut mov): Self::SystemData,
+    ) {
         for (e, ev, pos) in (&entities, &event, &position).join() {
             match *ev {
                 InputEvent::PlayerMovement { delta_x, delta_y } => {
@@ -31,11 +33,19 @@ impl<'a> System<'a> for HandleInputEvent {
                     let tgt_y = pos.y + delta_y;
                     let destination = map.xy_idx(tgt_x, tgt_y);
                     if let Some(target) = map.get_attackable(destination, &stats) {
-                        attack.insert(e, WantsToMelee { target })
+                        attack
+                            .insert(e, WantsToMelee { target })
                             .expect("Unable to add WantsToAttack");
                     } else {
-                        mov.insert(e, MoveEvent { destination, tgt_x, tgt_y })
-                            .expect("Unable to add MoveEvent");
+                        mov.insert(
+                            e,
+                            MoveEvent {
+                                destination,
+                                tgt_x,
+                                tgt_y,
+                            },
+                        )
+                        .expect("Unable to add MoveEvent");
                     }
                 }
             }
@@ -52,33 +62,74 @@ pub fn player_input(gs: &mut State, ctx: &mut Rltk) -> RunState {
     match ctx.key {
         None => return RunState::AwaitingInput, // Nothing happened
         Some(key) => match key {
-            VirtualKeyCode::Left | VirtualKeyCode::Numpad4 | VirtualKeyCode::H =>
-                input.insert(player, InputEvent::PlayerMovement { delta_x: -1, delta_y: 0 }),
+            VirtualKeyCode::Left | VirtualKeyCode::Numpad4 | VirtualKeyCode::H => input.insert(
+                player,
+                InputEvent::PlayerMovement {
+                    delta_x: -1,
+                    delta_y: 0,
+                },
+            ),
 
-            VirtualKeyCode::Right | VirtualKeyCode::Numpad6 | VirtualKeyCode::L =>
-                input.insert(player, InputEvent::PlayerMovement { delta_x: 1, delta_y: 0 }),
+            VirtualKeyCode::Right | VirtualKeyCode::Numpad6 | VirtualKeyCode::L => input.insert(
+                player,
+                InputEvent::PlayerMovement {
+                    delta_x: 1,
+                    delta_y: 0,
+                },
+            ),
 
-            VirtualKeyCode::Up | VirtualKeyCode::Numpad8 | VirtualKeyCode::K =>
-                input.insert(player, InputEvent::PlayerMovement { delta_x: 0, delta_y: -1 }),
+            VirtualKeyCode::Up | VirtualKeyCode::Numpad8 | VirtualKeyCode::K => input.insert(
+                player,
+                InputEvent::PlayerMovement {
+                    delta_x: 0,
+                    delta_y: -1,
+                },
+            ),
 
-            VirtualKeyCode::Down | VirtualKeyCode::Numpad2 | VirtualKeyCode::J =>
-                input.insert(player, InputEvent::PlayerMovement { delta_x: 0, delta_y: 1 }),
+            VirtualKeyCode::Down | VirtualKeyCode::Numpad2 | VirtualKeyCode::J => input.insert(
+                player,
+                InputEvent::PlayerMovement {
+                    delta_x: 0,
+                    delta_y: 1,
+                },
+            ),
 
             // Diagonals
-            VirtualKeyCode::Numpad9 | VirtualKeyCode::U =>
-                input.insert(player, InputEvent::PlayerMovement { delta_x: 1, delta_y: -1 }),
+            VirtualKeyCode::Numpad9 | VirtualKeyCode::U => input.insert(
+                player,
+                InputEvent::PlayerMovement {
+                    delta_x: 1,
+                    delta_y: -1,
+                },
+            ),
 
-            VirtualKeyCode::Numpad7 | VirtualKeyCode::Y =>
-                input.insert(player, InputEvent::PlayerMovement { delta_x: -1, delta_y: -1 }),
+            VirtualKeyCode::Numpad7 | VirtualKeyCode::Y => input.insert(
+                player,
+                InputEvent::PlayerMovement {
+                    delta_x: -1,
+                    delta_y: -1,
+                },
+            ),
 
-            VirtualKeyCode::Numpad3 | VirtualKeyCode::N =>
-                input.insert(player, InputEvent::PlayerMovement { delta_x: 1, delta_y: 1 }),
+            VirtualKeyCode::Numpad3 | VirtualKeyCode::N => input.insert(
+                player,
+                InputEvent::PlayerMovement {
+                    delta_x: 1,
+                    delta_y: 1,
+                },
+            ),
 
-            VirtualKeyCode::Numpad1 | VirtualKeyCode::B =>
-                input.insert(player, InputEvent::PlayerMovement { delta_x: -1, delta_y: 1 }),
+            VirtualKeyCode::Numpad1 | VirtualKeyCode::B => input.insert(
+                player,
+                InputEvent::PlayerMovement {
+                    delta_x: -1,
+                    delta_y: 1,
+                },
+            ),
 
             _ => return RunState::AwaitingInput,
         },
-    }.expect("Unable to insert player movement");
+    }
+    .expect("Unable to insert player movement");
     RunState::PlayerTurn
 }

chapter-07-damage/src/systems/draw_system.rs

@@ -1,7 +1,7 @@
-use rltk::{Console, Rltk};
-use specs::{Join, ReadStorage, ReadExpect, System};
 use crate::components::{Position, Renderable};
 use crate::map::Map;
+use rltk::{Console, Rltk};
+use specs::{Join, ReadExpect, ReadStorage, System};
 
 pub struct DrawRenderables<'r> {
     pub ctx: &'r mut Rltk,
@@ -18,7 +18,8 @@ impl<'a, 'r> System<'a> for DrawRenderables<'r> {
         for (pos, render) in (&positions, &renderables).join() {
             let idx = map.xy_idx(pos.x, pos.y);
             if map.visible_tiles[idx] {
-                self.ctx.set(pos.x, pos.y, render.fg, render.bg, render.glyph);
+                self.ctx
+                    .set(pos.x, pos.y, render.fg, render.bg, render.glyph);
             }
         }
     }

chapter-07-damage/src/systems/mod.rs

@@ -1,15 +1,15 @@
+mod damage_system;
 mod draw_system;
-mod visibility_system;
 mod map_indexing_system;
-mod monster_ai_system;
 mod melee_combat_system;
+mod monster_ai_system;
 mod movement_system;
-mod damage_system;
+mod visibility_system;
 
+pub use damage_system::*;
 pub use draw_system::*;
-pub use visibility_system::*;
 pub use map_indexing_system::*;
-pub use monster_ai_system::*;
 pub use melee_combat_system::*;
+pub use monster_ai_system::*;
 pub use movement_system::*;
-pub use damage_system::*;
+pub use visibility_system::*;

chapter-07-damage/src/systems/monster_ai_system.rs

@@ -1,6 +1,6 @@
 use crate::{Map, Monster, Position, RunState, Viewshed, WantsToMelee};
-use specs::prelude::*;
 use rltk::Point;
+use specs::prelude::*;
 
 pub struct MonsterAI;
 

chapter-07-damage/src/systems/movement_system.rs

@@ -27,7 +27,11 @@ impl<'a> System<'a> for HandleMoveEvent {
 
     fn run(&mut self, (mut move_events, mut pos, mut viewshed, mut point, map): Self::SystemData) {
         for (&event, pos, viewshed) in (&move_events, &mut pos, &mut viewshed).join() {
-            let MoveEvent { destination, tgt_x, tgt_y } = event;
+            let MoveEvent {
+                destination,
+                tgt_x,
+                tgt_y,
+            } = event;
             if !map.blocked[destination] {
                 viewshed.dirty = true;
                 pos.x = tgt_x;

chapter-07-damage/src/systems/visibility_system.rs

@@ -1,6 +1,6 @@
 use crate::{Map, Player, Position, Viewshed};
-use specs::prelude::*;
 use rltk::{field_of_view, Point};
+use specs::prelude::*;
 
 pub struct VisibilitySystem;