Convert from ncurses to crossterm

4 files changed, 65 insertions, 65 deletions

diff --git a/src/main.rs b/src/main.rs
index f890a27..8799a46 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,5 @@
-extern crate pancurses;
+extern crate crossterm;
 extern crate rand;
-
 extern crate text_io;
 
 mod entities;
@@ -9,9 +8,14 @@ mod tiling;
 mod world;
 
 use entities::{Entity, Player};
-use pancurses::{endwin, initscr, noecho, Input};
 use state::State;
 use std::env;
+use std::io::{stdout, Write};
+use crossterm::{execute, Output};
+use crossterm::cursor;
+use crossterm::screen::{EnterAlternateScreen, LeaveAlternateScreen, RawScreen};
+use crossterm::input::{input, InputEvent, KeyEvent};
+use crossterm::terminal;
 use world::{Dungeon, DOWN, LEFT, RIGHT, UP};
 
 fn get_player_name() -> String {
@@ -22,53 +26,48 @@ fn get_player_name() -> String {
 }
 
 fn main() {
-    let window = initscr();
+    let term_size = terminal::size().unwrap();
 
     let mut state = State::new(
         Player::new(get_player_name(), String::from("Warrior"), 30, 10, 10, 20),
         Dungeon::new(
-            window.get_max_x() as usize,
-            (window.get_max_y() - 2) as usize,
+            term_size.0 as usize,
+            (term_size.1 - 2) as usize,
             5,
         ),
     );
 
     state.init();
 
-    window.keypad(true);
-    noecho();
+    execute!(stdout(), EnterAlternateScreen).unwrap();
+    execute!(stdout(), cursor::Hide).unwrap();
+
+    let _raw = RawScreen::into_raw_mode();
 
-    state.render_level(&window);
+    state.render_level();
+
+    let input = input();
+    let mut reader = input.read_sync();
 
     loop {
         // update
-        state.render_entities(&window);
+        state.render_entities();
 
-        state.render_player(&window);
+        state.render_player();
 
-        // get input and execute it
-        match window.getch() {
-            Some(Input::Character('?')) => {
-                window.addstr("q: quit\n");
-            }
-            Some(Input::Character('j')) => {
-                state.player.move_by(DOWN).unwrap();
-                // state.get_player_mut().move_by(DOWN).unwrap();
+        if let Some(event) = reader.next() {
+            match event {
+                InputEvent::Keyboard(KeyEvent::Char('q')) => break,
+                InputEvent::Keyboard(KeyEvent::Char('?')) => execute!(stdout(), Output("q: quit")).unwrap(),
+                InputEvent::Keyboard(KeyEvent::Char('j')) => state.player.move_by(DOWN).unwrap(),
+                InputEvent::Keyboard(KeyEvent::Char('k')) => state.player.move_by(UP).unwrap(),
+                InputEvent::Keyboard(KeyEvent::Char('h')) => state.player.move_by(LEFT).unwrap(),
+                InputEvent::Keyboard(KeyEvent::Char('l')) => state.player.move_by(RIGHT).unwrap(),
+                _ => ()
             }
-            Some(Input::Character('k')) => {
-                state.get_player_mut().move_by(UP).unwrap();
-            }
-            Some(Input::Character('h')) => {
-                state.get_player_mut().move_by(LEFT).unwrap();
-            }
-            Some(Input::Character('l')) => {
-                state.get_player_mut().move_by(RIGHT).unwrap();
-            }
-            Some(Input::Character('q')) => break,
-            Some(_) => (),
-            None => (),
         }
         // actors actions (normally attack / interact if on same location as the character)
     }
-    endwin();
+
+    execute!(stdout(), LeaveAlternateScreen).unwrap();
 }
diff --git a/src/state.rs b/src/state.rs
index b5ab6ca..038f46f 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -1,7 +1,9 @@
-use pancurses::Window;
+use std::io::{stdout, Write};
+use crossterm::{queue, Output};
+use crossterm::cursor::{MoveTo};
 
 use crate::entities::{Character, Entity};
-use crate::tiling::{tile_to_str, TileGrid, TileType};
+use crate::tiling::{tile_to_str, TileGrid};
 use crate::world::{Dungeon, Generatable, Level};
 
 pub struct State {
@@ -11,10 +13,6 @@ pub struct State {
     grid: Option<TileGrid>,
 }
 
-pub fn draw_block(window: &Window, block: &TileType) {
-    window.printw(tile_to_str(block));
-}
-
 impl State {
     pub fn new(player: Character, dungeon: Dungeon) -> State {
         State {
@@ -27,8 +25,9 @@ impl State {
 
     pub fn init(&mut self) {
         self.dungeon.generate();
-        self.player.place(self.current_level().get_start_point());
         self.switch_level(0);
+        eprintln!("{:?}", self.current_level().get_start_point());
+        self.player.place(self.current_level().get_start_point());
     }
 
     pub fn switch_level(&mut self, num_level: usize) {
@@ -36,47 +35,51 @@ impl State {
         self.grid = Some(self.current_level().to_tilegrid().unwrap());
     }
 
-    pub fn render_level(&self, window: &Window) {
+    pub fn render_level(&self) {
+        let mut sout = stdout();
         for (linenum, line) in self.grid.as_ref().unwrap().raw_data().iter().enumerate() {
-            for block in line.iter() {
-                draw_block(&window, &block);
+            let linestr = line.iter().map(tile_to_str).collect::<Vec<&str>>();
+            let mut linestr2 = String::from("");
+            for chr in linestr {
+                linestr2.push_str(chr);
             }
-            window.mv(linenum as i32, 0);
+            queue!(
+                sout,
+                Output(linestr2),
+                MoveTo(0, linenum as u16)
+            ).unwrap();
+            sout.flush().unwrap();
         }
     }
 
-    fn render_entity(&self, entity: &dyn Entity, window: &Window) {
+    fn render_entity(&self, entity: &dyn Entity) {
         if !entity.is_dirty() {
             return;
         }
         let dirt = entity.get_previous_location();
-        window.mv(dirt.1 as i32, dirt.0 as i32);
-        draw_block(
-            window,
-            self.grid.as_ref().unwrap().get_block_at(dirt.0, dirt.1),
-        );
-        window.mv(
-            entity.get_location().1 as i32,
-            entity.get_location().0 as i32,
-        );
-        draw_block(window, entity.get_tiletype());
+        let background = self.grid.as_ref().unwrap().get_block_at(dirt.0, dirt.1);
+        let mut sout = stdout();
+        queue!(
+            sout,
+            MoveTo(dirt.0 as u16, dirt.1 as u16),
+            Output(tile_to_str(background)),
+            MoveTo(entity.get_location().0 as u16, entity.get_location().1 as u16),
+            Output(tile_to_str(entity.get_tiletype()))
+        ).unwrap();
+        sout.flush().unwrap();
     }
 
-    pub fn render_entities(&self, window: &Window) {
+    pub fn render_entities(&self) {
         for e in self.current_level().entities.iter() {
-            self.render_entity(&**e, window);
+            self.render_entity(&**e);
         }
     }
 
-    pub fn render_player(&self, window: &Window) {
-        self.render_entity(&self.player, window)
+    pub fn render_player(&self) {
+        self.render_entity(&self.player)
     }
 
     pub fn current_level(&self) -> &Level {
         &self.dungeon.levels[self.level]
     }
-
-    pub fn get_player_mut(&mut self) -> &mut Character {
-        &mut self.player
-    }
 }
diff --git a/src/tiling.rs b/src/tiling.rs
index 2b6da80..fa00464 100644
--- a/src/tiling.rs
+++ b/src/tiling.rs
@@ -1,5 +1,3 @@
-extern crate pancurses;
-
 pub struct TileGrid {
     grid: Vec<Vec<TileType>>,
 }
diff --git a/src/world.rs b/src/world.rs
index 99e5ca9..96c928d 100644
--- a/src/world.rs
+++ b/src/world.rs
@@ -295,7 +295,7 @@ impl Level {
     }
 
     pub fn get_start_point(&self) -> Point {
-        if self.rooms.is_empty() {
+        if !self.rooms.is_empty() {
             return self.rooms[0].center;
         }
         (0, 0)