initial commit

using rltk

src/main.rs

@@ -0,0 +1,176 @@
+use rltk::{GameState, Point, Rltk, RGB};
+use specs::prelude::*;
+
+mod components;
+pub use components::*;
+mod map;
+pub use map::*;
+mod player;
+use player::*;
+mod rect;
+pub use rect::Rect;
+mod gamelog;
+use gamelog::GameLog;
+mod gui;
+mod visibility_system;
+use visibility_system::VisibilitySystem;
+mod monster_ai_system;
+use monster_ai_system::MonsterAI;
+mod map_indexing_system;
+use map_indexing_system::MapIndexingSystem;
+mod damage_system;
+use damage_system::*;
+mod melee_combat_system;
+use melee_combat_system::MeleeCombatSystem;
+
+#[derive(PartialEq, Copy, Clone)]
+pub enum RunState {
+    AwaitingInput,
+    PreRun,
+    PlayerTurn,
+    MonsterTurn,
+}
+
+pub struct State {
+    pub ecs: World,
+}
+
+impl State {
+    fn run_systems(&mut self) {
+        let mut vis = VisibilitySystem {};
+        vis.run_now(&self.ecs);
+        let mut mob = MonsterAI {};
+        mob.run_now(&self.ecs);
+        let mut mapindex = MapIndexingSystem {};
+        mapindex.run_now(&self.ecs);
+        let mut melee_system = MeleeCombatSystem {};
+        melee_system.run_now(&self.ecs);
+        let mut damage_system = DamageSystem {};
+        damage_system.run_now(&self.ecs);
+        self.ecs.maintain();
+    }
+}
+
+impl GameState for State {
+    fn tick(&mut self, ctx: &mut Rltk) {
+        ctx.cls();
+
+        let mut new_runstate;
+        {
+            let runstate = self.ecs.fetch::<RunState>();
+            new_runstate = *runstate;
+        }
+
+        match new_runstate {
+            RunState::PreRun => {
+                self.run_systems();
+                new_runstate = RunState::AwaitingInput;
+            }
+            RunState::AwaitingInput => {
+                new_runstate = player_input(self, ctx);
+            }
+            RunState::PlayerTurn => {
+                self.run_systems();
+                new_runstate = RunState::MonsterTurn;
+            }
+            RunState::MonsterTurn => {
+                self.run_systems();
+                new_runstate = RunState::AwaitingInput;
+            }
+        }
+
+        {
+            let mut runwriter = self.ecs.write_resource::<RunState>();
+            *runwriter = new_runstate;
+        }
+
+        damage_system::delete_the_dead(&mut self.ecs);
+        draw_map(&self.ecs, ctx);
+
+        let positions = self.ecs.read_storage::<Position>();
+        let renderables = self.ecs.read_storage::<Renderable>();
+        let map = self.ecs.fetch::<Map>();
+
+        for (pos, render) in (&positions, &renderables).join() {
+            let idx = map.xy_idx(pos.x, pos.y);
+            if map.visible_tiles[idx] {
+                ctx.set(pos.x, pos.y, render.fg, render.bg, render.glyph);
+            }
+        }
+
+        gui::draw_ui(&self.ecs, ctx);
+    }
+}
+
+fn main() -> rltk::BError {
+    use rltk::RltkBuilder;
+    let mut context = RltkBuilder::simple80x50()
+        .with_gutter(0)
+        .with_tile_dimensions(16, 16)
+        //.with_fitscreen(true)
+        .with_title("Roguelike Tutorial")
+        .build()?;
+    context.with_post_scanlines(true);
+    let mut gs = State { ecs: World::new() };
+
+    gs.ecs.register::<Position>();
+    gs.ecs.register::<Renderable>();
+    gs.ecs.register::<Player>();
+    gs.ecs.register::<Monster>();
+    gs.ecs.register::<Viewshed>();
+    gs.ecs.register::<Name>();
+    gs.ecs.register::<BlocksTile>();
+    gs.ecs.register::<CombatStats>();
+    gs.ecs.register::<WantsToMelee>();
+    gs.ecs.register::<SufferDamage>();
+
+    let map = Map::new_map_rooms_and_corridors();
+    let (player_x, player_y) = map.rooms[0].centre();
+
+    let player_entity = gs
+        .ecs
+        .create_entity()
+        .with(Position { x: player_x, y: player_y })
+        .with(Renderable { glyph: rltk::to_cp437('@'), fg: RGB::named(rltk::YELLOW), bg: RGB::named(rltk::BLACK) })
+        .with(Player {})
+        .with(Viewshed { visible_tiles: Vec::new(), range: 8, dirty: true })
+        .with(Name { name: "Player".to_string() })
+        .with(CombatStats { max_hp: 30, hp: 30, defence: 2, power: 5 })
+        .build();
+
+    let mut rng = rltk::RandomNumberGenerator::new();
+    for (i, room) in map.rooms.iter().skip(1).enumerate() {
+        let (x, y) = room.centre();
+        let glyph: rltk::FontCharType;
+        let name: String;
+        let roll = rng.roll_dice(1, 2);
+        match roll {
+            1 => {
+                glyph = rltk::to_cp437('g');
+                name = "Goblin".to_string();
+            }
+            _ => {
+                glyph = rltk::to_cp437('o');
+                name = "Orc".to_string();
+            }
+        }
+        gs.ecs
+            .create_entity()
+            .with(Position { x, y })
+            .with(Renderable { glyph: glyph, fg: RGB::named(rltk::RED), bg: RGB::named(rltk::BLACK) })
+            .with(Viewshed { visible_tiles: Vec::new(), range: 8, dirty: true })
+            .with(Monster {})
+            .with(Name { name: format!("{} #{}", &name, i) })
+            .with(BlocksTile {})
+            .with(CombatStats { max_hp: 16, hp: 16, defence: 1, power: 4 })
+            .build();
+    }
+
+    gs.ecs.insert(map);
+    gs.ecs.insert(Point::new(player_x, player_y));
+    gs.ecs.insert(player_entity);
+    gs.ecs.insert(gamelog::GameLog { entries: vec!["Here's your welcome message.".to_string()] });
+    gs.ecs.insert(RunState::PreRun);
+
+    rltk::main_loop(context, gs)
+}