From 0d545ea6e634ed990dd8f731a24a4e0838ffedbf Mon Sep 17 00:00:00 2001 From: Guillaume Pasquet Date: Wed, 11 Mar 2020 07:35:23 +0000 Subject: stuff --- TODO.md | 21 +++++++++++++- src/state.rs | 90 ++---------------------------------------------------------- 2 files changed, 22 insertions(+), 89 deletions(-) diff --git a/TODO.md b/TODO.md index 9289b2d..981e42b 100644 --- a/TODO.md +++ b/TODO.md @@ -1,4 +1,23 @@ +# TODO + - Add unit tests - Disassociate level to view, move view around if terminal too small - Add equipment system -- Remove rendering logic from State \ No newline at end of file +- Remove rendering logic from State + + +## Separate rendering logic + +``` +------- --------- +| main| -----> | State | +------- | --------- + | + | ------------ + +-> | ViewPort | + ------------ +``` + +- Main game logic mutates State in reaction to player input +- Render is triggered by giving it a read-only reference to current state +- Heavy use of traits in ViewPort allows multiple type of viewports (Piston etc.) diff --git a/src/state.rs b/src/state.rs index 8561486..542f822 100644 --- a/src/state.rs +++ b/src/state.rs @@ -1,9 +1,5 @@ -use crossterm::cursor::MoveTo; -use crossterm::{execute, queue, Output}; -use std::io::{stdout, Write}; - -use crate::entities::{Character, Entity, Player}; -use crate::tiling::{tile_to_str, Tile, TileGrid, TileType}; +use crate::entities::{Character, Entity}; +use crate::tiling::{Tile, TileGrid, TileType}; use crate::world::{apply_movement, Dungeon, Generatable, Level, Movement}; const PLAYER_SIGHT: usize = 3; @@ -36,86 +32,6 @@ impl State { self.grid = Some(self.current_level().to_tilegrid().unwrap()); } - pub fn render_level(&self) { - let mut sout = stdout(); - execute!(sout, MoveTo(0, 0)).unwrap(); - for (linenum, line) in self.grid.as_ref().unwrap().raw_data().iter().enumerate() { - let linestr = line.iter().map(tile_to_str).collect::>(); - let mut linestr2 = String::from(""); - for chr in linestr { - linestr2.push_str(chr); - } - queue!(sout, Output(linestr2), MoveTo(0, linenum as u16)).unwrap(); - sout.flush().unwrap(); - } - } - - fn render_entity(&self, entity: &dyn Entity) { - if !entity.is_visible() || !entity.is_dirty() { - return; - } - let dirt = entity.previous_location(); - let background = self.grid.as_ref().unwrap().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.location().0 as u16, entity.location().1 as u16), - Output(tile_to_str(entity.tile())) - ) - .unwrap(); - sout.flush().unwrap(); - } - - pub fn render_entities(&self) { - for e in self.current_level().entities.iter() { - self.render_entity(&**e); - } - } - - pub fn render_player(&mut self) { - self.render_entity(&self.player); - - self.grid - .as_mut() - .unwrap() - .clear_fog_of_war(self.player.location(), PLAYER_SIGHT); - } - - fn ui_state_position(&self) -> MoveTo { - MoveTo(0, (self.dungeon.ysize()) as u16) - } - - fn ui_notification_position(&self) -> MoveTo { - MoveTo(0, (self.dungeon.ysize() + 1) as u16) - } - - pub fn render_ui(&self) { - let mut sout = stdout(); - queue!(sout, self.ui_state_position(), Output(self.player.stats())).unwrap(); - sout.flush().unwrap(); - } - - pub fn notify(&self, message: String) { - let mut sout = stdout(); - queue!( - sout, - self.ui_notification_position(), - Output(" ".repeat(self.dungeon.xsize())), - self.ui_notification_position(), - Output(message) - ) - .unwrap(); - sout.flush().unwrap(); - } - - pub fn ui_help(&self) { - self.notify(String::from( - "quit: q, movement{up(k), down(j), left(h), right(l)}", - )) - } - pub fn current_level(&self) -> &Level { &self.dungeon.levels[self.level] } @@ -157,7 +73,6 @@ impl State { match grid.block_at(loc.0, loc.1).get_type() { TileType::StairsDown => { self.switch_level(self.level + 1); - self.render_level(); Ok(()) } _ => Err(String::from("Not on stairs!")), @@ -178,7 +93,6 @@ impl State { match grid.block_at(loc.0, loc.1).get_type() { TileType::StairsUp => { self.switch_level(self.level - 1); - self.render_level(); Ok(()) } _ => Err(String::from("Not on stairs!")), -- cgit v1.2.3 From 3c88cf07a47201daeffbd7b50a805c6ce72b8741 Mon Sep 17 00:00:00 2001 From: Guillaume Pasquet Date: Wed, 11 Mar 2020 07:35:56 +0000 Subject: add viewport file --- src/viewport.rs | 100 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 src/viewport.rs diff --git a/src/viewport.rs b/src/viewport.rs new file mode 100644 index 0000000..afd11c1 --- /dev/null +++ b/src/viewport.rs @@ -0,0 +1,100 @@ +use crossterm::cursor::MoveTo; +use crossterm::{execute, queue, Output}; +use std::io::{stdout, Write}; + +use crate::entities::{Character, Entity, Player}; +use crate::state::State; +use crate::tiling::{tile_to_str, Tile, TileGrid, TileType}; +use crate::world::{apply_movement, Dungeon, Generatable, Level, Movement}; + + +pub trait ViewPort { + fn render_state(&mut self, &State); +} + +pub struct CrossTermViewPort { + xsize: usize, + ysize: usize +} + +impl CrossTermViewPort { + pub fn render_level(&self) { + let mut sout = stdout(); + execute!(sout, MoveTo(0, 0)).unwrap(); + for (linenum, line) in self.grid.as_ref().unwrap().raw_data().iter().enumerate() { + let linestr = line.iter().map(tile_to_str).collect::>(); + let mut linestr2 = String::from(""); + for chr in linestr { + linestr2.push_str(chr); + } + queue!(sout, Output(linestr2), MoveTo(0, linenum as u16)).unwrap(); + sout.flush().unwrap(); + } + } + + fn render_entity(&self, entity: &dyn Entity) { + if !entity.is_visible() || !entity.is_dirty() { + return; + } + let dirt = entity.previous_location(); + let background = self.grid.as_ref().unwrap().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.location().0 as u16, entity.location().1 as u16), + Output(tile_to_str(entity.tile())) + ) + .unwrap(); + sout.flush().unwrap(); + } + + pub fn render_entities(&self) { + for e in self.current_level().entities.iter() { + self.render_entity(&**e); + } + } + + pub fn render_player(&mut self) { + self.render_entity(&self.player); + + self.grid + .as_mut() + .unwrap() + .clear_fog_of_war(self.player.location(), PLAYER_SIGHT); + } + + fn ui_state_position(&self) -> MoveTo { + MoveTo(0, (self.dungeon.ysize()) as u16) + } + + fn ui_notification_position(&self) -> MoveTo { + MoveTo(0, (self.dungeon.ysize() + 1) as u16) + } + + pub fn render_ui(&self) { + let mut sout = stdout(); + queue!(sout, self.ui_state_position(), Output(self.player.stats())).unwrap(); + sout.flush().unwrap(); + } + + pub fn notify(&self, message: String) { + let mut sout = stdout(); + queue!( + sout, + self.ui_notification_position(), + Output(" ".repeat(self.dungeon.xsize())), + self.ui_notification_position(), + Output(message) + ) + .unwrap(); + sout.flush().unwrap(); + } + + pub fn ui_help(&self) { + self.notify(String::from( + "quit: q, movement{up(k), down(j), left(h), right(l)}", + )) + } +} -- cgit v1.2.3 From ca41f72497723ce1102480182ba048f63867461f Mon Sep 17 00:00:00 2001 From: Guillaume Pasquet Date: Wed, 11 Mar 2020 08:52:35 +0000 Subject: Decouple viewport --- src/main.rs | 20 +++++++++---------- src/state.rs | 21 ++++++++++++++++++- src/viewport.rs | 62 +++++++++++++++++++++++++++++++++++++-------------------- 3 files changed, 70 insertions(+), 33 deletions(-) diff --git a/src/main.rs b/src/main.rs index d00db53..6348757 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,6 +1,7 @@ mod entities; mod state; mod tiling; +mod viewport; mod world; use std::env; @@ -17,6 +18,7 @@ use simplelog::*; use entities::Player; use state::State; +use viewport::{CrossTermViewPort, ViewPort}; use world::{Dungeon, DOWN, LEFT, RIGHT, UP}; fn player_name() -> String { @@ -45,10 +47,13 @@ fn main() { let _raw = RawScreen::into_raw_mode(); // Initialise state, create the player and dungeon + let xsize = term_size.0 as usize; + let ysize = (term_size.1 - 2) as usize; let mut state = State::new( Player::new(player_name(), String::from("Warrior"), 30, 10, 10, 20), - Dungeon::new(term_size.0 as usize, (term_size.1 - 2) as usize, 5), + Dungeon::new(xsize, ysize, 5), ); + let mut window = CrossTermViewPort::new(xsize, ysize); state.init(); let input = input(); @@ -57,18 +62,13 @@ fn main() { // Main loop, dispatches events and calls rendering routines. Don't // add any game logic here. loop { - state.render_player(); - state.render_level(); - state.render_entities(); - state.render_player(); - - state.render_ui(); + window.render_state(&state); if let Some(event) = reader.next() { match event { InputEvent::Keyboard(KeyEvent::Char('q')) => break, InputEvent::Keyboard(KeyEvent::Char('?')) => { - state.ui_help(); + window.ui_help(); } InputEvent::Keyboard(KeyEvent::Char('j')) => state.move_player(DOWN).ignore(), InputEvent::Keyboard(KeyEvent::Char('k')) => state.move_player(UP).ignore(), @@ -83,11 +83,11 @@ fn main() { // Stairs InputEvent::Keyboard(KeyEvent::Char('>')) => match state.down_stairs() { Ok(()) => (), - Err(info) => state.notify(info), + Err(info) => window.notify(info), }, InputEvent::Keyboard(KeyEvent::Char('<')) => match state.up_stairs() { Ok(()) => (), - Err(info) => state.notify(info), + Err(info) => window.notify(info), }, _ => (), } diff --git a/src/state.rs b/src/state.rs index 542f822..776f2bf 100644 --- a/src/state.rs +++ b/src/state.rs @@ -25,11 +25,21 @@ impl State { self.dungeon.generate(); self.switch_level(0); self.player.place(self.current_level().start_point()); + self.fog_of_war(); + } + + pub fn get_grid(&self) -> Option<&TileGrid> { + self.grid.as_ref() + } + + pub fn get_player(&self) -> &Character { + &self.player } pub fn switch_level(&mut self, num_level: usize) { self.level = num_level; self.grid = Some(self.current_level().to_tilegrid().unwrap()); + self.fog_of_war(); } pub fn current_level(&self) -> &Level { @@ -56,7 +66,9 @@ impl State { if !State::can_step_on(grid.block_at(loc.0, loc.1)) { return Err(String::from("Can't move entity!")); } - self.player.move_by(dir) + let ret = self.player.move_by(dir); + self.fog_of_war(); + ret } pub fn down_stairs(&mut self) -> Result<(), String> { @@ -98,4 +110,11 @@ impl State { _ => Err(String::from("Not on stairs!")), } } + + pub fn fog_of_war(&mut self) { + self.grid + .as_mut() + .unwrap() + .clear_fog_of_war(self.player.location(), PLAYER_SIGHT); + } } diff --git a/src/viewport.rs b/src/viewport.rs index afd11c1..37dfd21 100644 --- a/src/viewport.rs +++ b/src/viewport.rs @@ -1,5 +1,6 @@ use crossterm::cursor::MoveTo; use crossterm::{execute, queue, Output}; +use log::debug; use std::io::{stdout, Write}; use crate::entities::{Character, Entity, Player}; @@ -7,21 +8,28 @@ use crate::state::State; use crate::tiling::{tile_to_str, Tile, TileGrid, TileType}; use crate::world::{apply_movement, Dungeon, Generatable, Level, Movement}; - pub trait ViewPort { - fn render_state(&mut self, &State); + fn render_state(&mut self, state: &State); } pub struct CrossTermViewPort { xsize: usize, - ysize: usize + ysize: usize, + // Use below when switching to moveable window + //start: (usize, usize) } impl CrossTermViewPort { - pub fn render_level(&self) { + pub fn new(xsize: usize, ysize: usize) -> CrossTermViewPort { + CrossTermViewPort { xsize, ysize } + } + + fn draw_level(&self, state: &State) { let mut sout = stdout(); + let grid = state.get_grid().unwrap(); execute!(sout, MoveTo(0, 0)).unwrap(); - for (linenum, line) in self.grid.as_ref().unwrap().raw_data().iter().enumerate() { + for (linenum, line) in grid.raw_data().iter().enumerate() { + debug!("Drawing linenum {} -- {:?}", linenum, line); let linestr = line.iter().map(tile_to_str).collect::>(); let mut linestr2 = String::from(""); for chr in linestr { @@ -32,12 +40,13 @@ impl CrossTermViewPort { } } - fn render_entity(&self, entity: &dyn Entity) { + fn draw_entity(&self, state: &State, entity: &dyn Entity) { if !entity.is_visible() || !entity.is_dirty() { return; } + let grid = state.get_grid().unwrap(); let dirt = entity.previous_location(); - let background = self.grid.as_ref().unwrap().block_at(dirt.0, dirt.1); + let background = grid.block_at(dirt.0, dirt.1); let mut sout = stdout(); queue!( sout, @@ -50,32 +59,32 @@ impl CrossTermViewPort { sout.flush().unwrap(); } - pub fn render_entities(&self) { - for e in self.current_level().entities.iter() { - self.render_entity(&**e); + fn draw_entities(&self, state: &State) { + for e in state.current_level().entities.iter() { + self.draw_entity(state, &**e); } } - pub fn render_player(&mut self) { - self.render_entity(&self.player); - - self.grid - .as_mut() - .unwrap() - .clear_fog_of_war(self.player.location(), PLAYER_SIGHT); + fn draw_player(&mut self, state: &State) { + self.draw_entity(state, state.get_player()); } fn ui_state_position(&self) -> MoveTo { - MoveTo(0, (self.dungeon.ysize()) as u16) + MoveTo(0, (self.ysize) as u16) } fn ui_notification_position(&self) -> MoveTo { - MoveTo(0, (self.dungeon.ysize() + 1) as u16) + MoveTo(0, (self.ysize + 1) as u16) } - pub fn render_ui(&self) { + fn draw_ui(&self, state: &State) { let mut sout = stdout(); - queue!(sout, self.ui_state_position(), Output(self.player.stats())).unwrap(); + queue!( + sout, + self.ui_state_position(), + Output(state.get_player().stats()) + ) + .unwrap(); sout.flush().unwrap(); } @@ -84,7 +93,7 @@ impl CrossTermViewPort { queue!( sout, self.ui_notification_position(), - Output(" ".repeat(self.dungeon.xsize())), + Output(" ".repeat(self.xsize)), self.ui_notification_position(), Output(message) ) @@ -98,3 +107,12 @@ impl CrossTermViewPort { )) } } + +impl ViewPort for CrossTermViewPort { + fn render_state(&mut self, state: &State) { + self.draw_level(state); + self.draw_entities(state); + self.draw_player(state); + self.draw_ui(state); + } +} -- cgit v1.2.3 From 1162b36667cf9eb5c5faeaf0395a887b9a9e7b25 Mon Sep 17 00:00:00 2001 From: Guillaume Pasquet Date: Wed, 11 Mar 2020 10:05:46 +0000 Subject: Ignore logs --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 53eaa21..cce2d15 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ /target **/*.rs.bk +*.log -- cgit v1.2.3 From 49ca52844b0fa74bcd92018ef313923e9f355632 Mon Sep 17 00:00:00 2001 From: Guillaume Pasquet Date: Fri, 13 Mar 2020 21:40:45 +0000 Subject: stuff --- src/events.rs | 10 ++++++++ src/main.rs | 63 ++++++++++++++----------------------------------- src/viewport.rs | 73 +++++++++++++++++++++++++++++++++++++++++++++++++++------ 3 files changed, 93 insertions(+), 53 deletions(-) create mode 100644 src/events.rs diff --git a/src/events.rs b/src/events.rs new file mode 100644 index 0000000..0619b18 --- /dev/null +++ b/src/events.rs @@ -0,0 +1,10 @@ +use crate::world::Movement; + +#[derive(Copy, Clone, Debug)] +pub enum ViewportEvent { + Quit, + Help, + MovePlayer(Movement), + DownStairs, + UpStairs, +} diff --git a/src/main.rs b/src/main.rs index 6348757..3f7f81c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,25 +1,24 @@ mod entities; +mod events; mod state; mod tiling; mod viewport; mod world; -use std::env; -use std::fs::File; -use std::io::{stdout, Write}; - -use crossterm::cursor; -use crossterm::execute; -use crossterm::input::{input, InputEvent, KeyEvent}; -use crossterm::screen::{EnterAlternateScreen, LeaveAlternateScreen, RawScreen}; -use crossterm::terminal; use ignore_result::Ignore; use simplelog::*; +use std::env; +use std::fs::File; use entities::Player; +use events::ViewportEvent; use state::State; use viewport::{CrossTermViewPort, ViewPort}; -use world::{Dungeon, DOWN, LEFT, RIGHT, UP}; +use world::Dungeon; + +const DUNGEON_SIZE_X: usize = 20; +const DUNGEON_SIZE_Y: usize = 20; +const DUNGEON_DEPTH: usize = 5; fn player_name() -> String { match env::var_os("USER") { @@ -39,62 +38,34 @@ fn main() { .unwrap(); } - // Initialise the terminal, the raw alternate mode allows direct character - // seeking and hides the prompt. - let term_size = terminal::size().unwrap(); - execute!(stdout(), EnterAlternateScreen).unwrap(); - execute!(stdout(), cursor::Hide).unwrap(); - let _raw = RawScreen::into_raw_mode(); - - // Initialise state, create the player and dungeon - let xsize = term_size.0 as usize; - let ysize = (term_size.1 - 2) as usize; let mut state = State::new( Player::new(player_name(), String::from("Warrior"), 30, 10, 10, 20), - Dungeon::new(xsize, ysize, 5), + Dungeon::new(DUNGEON_SIZE_X, DUNGEON_SIZE_Y, DUNGEON_DEPTH), ); - let mut window = CrossTermViewPort::new(xsize, ysize); + let mut window = CrossTermViewPort::new(); state.init(); - let input = input(); - let mut reader = input.read_sync(); - // Main loop, dispatches events and calls rendering routines. Don't // add any game logic here. loop { window.render_state(&state); - if let Some(event) = reader.next() { + if let Some(event) = window.wait_input() { match event { - InputEvent::Keyboard(KeyEvent::Char('q')) => break, - InputEvent::Keyboard(KeyEvent::Char('?')) => { - window.ui_help(); - } - InputEvent::Keyboard(KeyEvent::Char('j')) => state.move_player(DOWN).ignore(), - InputEvent::Keyboard(KeyEvent::Char('k')) => state.move_player(UP).ignore(), - InputEvent::Keyboard(KeyEvent::Char('h')) => state.move_player(LEFT).ignore(), - InputEvent::Keyboard(KeyEvent::Char('l')) => state.move_player(RIGHT).ignore(), - // Arrow keys for noobs - InputEvent::Keyboard(KeyEvent::Down) => state.move_player(DOWN).ignore(), - InputEvent::Keyboard(KeyEvent::Up) => state.move_player(UP).ignore(), - InputEvent::Keyboard(KeyEvent::Left) => state.move_player(LEFT).ignore(), - InputEvent::Keyboard(KeyEvent::Right) => state.move_player(RIGHT).ignore(), - - // Stairs - InputEvent::Keyboard(KeyEvent::Char('>')) => match state.down_stairs() { + ViewportEvent::Quit => break, + ViewportEvent::MovePlayer(direction) => state.move_player(direction).ignore(), + ViewportEvent::DownStairs => match state.down_stairs() { Ok(()) => (), Err(info) => window.notify(info), }, - InputEvent::Keyboard(KeyEvent::Char('<')) => match state.up_stairs() { + ViewportEvent::UpStairs => match state.up_stairs() { Ok(()) => (), Err(info) => window.notify(info), }, _ => (), } } + // actors actions (normally attack / interact if on same location as the character) } - - execute!(stdout(), LeaveAlternateScreen).unwrap(); - execute!(stdout(), cursor::Show).unwrap(); } diff --git a/src/viewport.rs b/src/viewport.rs index 37dfd21..1fd13aa 100644 --- a/src/viewport.rs +++ b/src/viewport.rs @@ -1,12 +1,17 @@ +use crate::events::ViewportEvent; +use crate::world::{DOWN, LEFT, RIGHT, UP}; +use crossterm::cursor; use crossterm::cursor::MoveTo; +use crossterm::input::{input, InputEvent, KeyEvent, SyncReader}; +use crossterm::screen::{EnterAlternateScreen, LeaveAlternateScreen, RawScreen}; +use crossterm::terminal; use crossterm::{execute, queue, Output}; use log::debug; use std::io::{stdout, Write}; -use crate::entities::{Character, Entity, Player}; +use crate::entities::{Entity, Player}; use crate::state::State; -use crate::tiling::{tile_to_str, Tile, TileGrid, TileType}; -use crate::world::{apply_movement, Dungeon, Generatable, Level, Movement}; +use crate::tiling::tile_to_str; pub trait ViewPort { fn render_state(&mut self, state: &State); @@ -15,13 +20,31 @@ pub trait ViewPort { pub struct CrossTermViewPort { xsize: usize, ysize: usize, - // Use below when switching to moveable window - //start: (usize, usize) + reader: SyncReader, + start: (usize, usize), } impl CrossTermViewPort { - pub fn new(xsize: usize, ysize: usize) -> CrossTermViewPort { - CrossTermViewPort { xsize, ysize } + pub fn new() -> CrossTermViewPort { + // Initialise the terminal, the raw alternate mode allows direct character + // seeking and hides the prompt. + let term_size = terminal::size().unwrap(); + execute!(stdout(), EnterAlternateScreen).unwrap(); + execute!(stdout(), cursor::Hide).unwrap(); + let _raw = RawScreen::into_raw_mode(); + + // Initialise state, create the player and dungeon + let xsize = term_size.0 as usize; + let ysize = (term_size.1 - 2) as usize; + + let input = input(); + + CrossTermViewPort { + xsize, + ysize, + reader: input.read_sync(), + start: (0, 0), + } } fn draw_level(&self, state: &State) { @@ -106,6 +129,35 @@ impl CrossTermViewPort { "quit: q, movement{up(k), down(j), left(h), right(l)}", )) } + + pub fn wait_input(&mut self) -> Option { + if let Some(event) = self.reader.next() { + return match event { + InputEvent::Keyboard(KeyEvent::Char('q')) => Some(ViewportEvent::Quit), + InputEvent::Keyboard(KeyEvent::Char('?')) => { + self.ui_help(); + None + } + InputEvent::Keyboard(KeyEvent::Char('j')) => Some(ViewportEvent::MovePlayer(DOWN)), + InputEvent::Keyboard(KeyEvent::Char('k')) => Some(ViewportEvent::MovePlayer(UP)), + InputEvent::Keyboard(KeyEvent::Char('h')) => Some(ViewportEvent::MovePlayer(LEFT)), + InputEvent::Keyboard(KeyEvent::Char('l')) => Some(ViewportEvent::MovePlayer(RIGHT)), + // Arrow keys for noobs + InputEvent::Keyboard(KeyEvent::Down) => Some(ViewportEvent::MovePlayer(DOWN)), + InputEvent::Keyboard(KeyEvent::Up) => Some(ViewportEvent::MovePlayer(UP)), + InputEvent::Keyboard(KeyEvent::Left) => Some(ViewportEvent::MovePlayer(LEFT)), + InputEvent::Keyboard(KeyEvent::Right) => Some(ViewportEvent::MovePlayer(RIGHT)), + + // Stairs + InputEvent::Keyboard(KeyEvent::Char('>')) => Some(ViewportEvent::DownStairs), + InputEvent::Keyboard(KeyEvent::Char('<')) => Some(ViewportEvent::UpStairs), + + // No match + _ => None, + }; + } + None + } } impl ViewPort for CrossTermViewPort { @@ -116,3 +168,10 @@ impl ViewPort for CrossTermViewPort { self.draw_ui(state); } } + +impl Drop for CrossTermViewPort { + fn drop(&mut self) { + execute!(stdout(), LeaveAlternateScreen).unwrap(); + execute!(stdout(), cursor::Show).unwrap(); + } +} -- cgit v1.2.3 From 9848a92fde2891177cc352064ae9e4ec1098277f Mon Sep 17 00:00:00 2001 From: Guillaume Pasquet Date: Sat, 14 Mar 2020 16:22:54 +0000 Subject: Make it work --- .vscode/launch.json | 1 + src/main.rs | 4 ++-- src/viewport.rs | 35 ++++++++++++++++++++--------------- 3 files changed, 23 insertions(+), 17 deletions(-) diff --git a/.vscode/launch.json b/.vscode/launch.json index e2e657d..981f449 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -22,6 +22,7 @@ "program": "${workspaceRoot}/target/debug/roguelike", "args": [], "cwd": "${workspaceRoot}", + "terminal": "external" } ] } \ No newline at end of file diff --git a/src/main.rs b/src/main.rs index 3f7f81c..bed0c8d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -16,8 +16,8 @@ use state::State; use viewport::{CrossTermViewPort, ViewPort}; use world::Dungeon; -const DUNGEON_SIZE_X: usize = 20; -const DUNGEON_SIZE_Y: usize = 20; +const DUNGEON_SIZE_X: usize = 80; +const DUNGEON_SIZE_Y: usize = 24; const DUNGEON_DEPTH: usize = 5; fn player_name() -> String { diff --git a/src/viewport.rs b/src/viewport.rs index 1fd13aa..7b4fb3e 100644 --- a/src/viewport.rs +++ b/src/viewport.rs @@ -2,7 +2,7 @@ use crate::events::ViewportEvent; use crate::world::{DOWN, LEFT, RIGHT, UP}; use crossterm::cursor; use crossterm::cursor::MoveTo; -use crossterm::input::{input, InputEvent, KeyEvent, SyncReader}; +use crossterm::input::{input, InputEvent, KeyEvent, TerminalInput}; use crossterm::screen::{EnterAlternateScreen, LeaveAlternateScreen, RawScreen}; use crossterm::terminal; use crossterm::{execute, queue, Output}; @@ -15,12 +15,14 @@ use crate::tiling::tile_to_str; pub trait ViewPort { fn render_state(&mut self, state: &State); + fn wait_input(&mut self) -> Option; } pub struct CrossTermViewPort { xsize: usize, ysize: usize, - reader: SyncReader, + raw: RawScreen, + input: TerminalInput, start: (usize, usize), } @@ -31,7 +33,7 @@ impl CrossTermViewPort { let term_size = terminal::size().unwrap(); execute!(stdout(), EnterAlternateScreen).unwrap(); execute!(stdout(), cursor::Hide).unwrap(); - let _raw = RawScreen::into_raw_mode(); + let raw = RawScreen::into_raw_mode().unwrap(); // Initialise state, create the player and dungeon let xsize = term_size.0 as usize; @@ -42,7 +44,8 @@ impl CrossTermViewPort { CrossTermViewPort { xsize, ysize, - reader: input.read_sync(), + raw, + input, start: (0, 0), } } @@ -129,9 +132,20 @@ impl CrossTermViewPort { "quit: q, movement{up(k), down(j), left(h), right(l)}", )) } +} + +impl ViewPort for CrossTermViewPort { + fn render_state(&mut self, state: &State) { + self.draw_level(state); + self.draw_entities(state); + self.draw_player(state); + self.draw_ui(state); + } + + fn wait_input(&mut self) -> Option { + let mut reader = self.input.read_sync(); - pub fn wait_input(&mut self) -> Option { - if let Some(event) = self.reader.next() { + if let Some(event) = reader.next() { return match event { InputEvent::Keyboard(KeyEvent::Char('q')) => Some(ViewportEvent::Quit), InputEvent::Keyboard(KeyEvent::Char('?')) => { @@ -160,15 +174,6 @@ impl CrossTermViewPort { } } -impl ViewPort for CrossTermViewPort { - fn render_state(&mut self, state: &State) { - self.draw_level(state); - self.draw_entities(state); - self.draw_player(state); - self.draw_ui(state); - } -} - impl Drop for CrossTermViewPort { fn drop(&mut self) { execute!(stdout(), LeaveAlternateScreen).unwrap(); -- cgit v1.2.3 From 219e32ad793e66a3111465ef02f3eb677f70277d Mon Sep 17 00:00:00 2001 From: Guillaume Pasquet Date: Thu, 2 Jan 2020 17:28:15 +0000 Subject: Fix for invisible enemies - Don't double-count visibility - Set enemies visibility with LOS - Set dirty flag when enemies are revealed --- .gitignore | 1 + src/entities.rs | 10 +++++----- src/state.rs | 25 +++++++++++++++++++++++++ src/world.rs | 9 +++++---- 4 files changed, 36 insertions(+), 9 deletions(-) diff --git a/.gitignore b/.gitignore index cce2d15..5542972 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ /target **/*.rs.bk +/log *.log diff --git a/src/entities.rs b/src/entities.rs index 78e5ab9..98c8443 100644 --- a/src/entities.rs +++ b/src/entities.rs @@ -41,7 +41,6 @@ pub struct Character { luck: i32, xp: i32, tile: Tile, - visible: bool, } pub trait Enemy { @@ -114,11 +113,14 @@ impl Entity for Character { } fn visibility(&mut self, visible: bool) { - self.visible = visible; + if visible != self.is_visible() { + self.dirty = true; + } + self.tile.visibility(visible) } fn is_visible(&self) -> bool { - self.visible + self.tile.is_visible() } } @@ -146,7 +148,6 @@ impl Enemy for Character { previous_location: location, tile: Tile::from(TileType::Character(tile_str)), dirty: false, - visible: false, } } @@ -182,7 +183,6 @@ impl Player for Character { false, ), dirty: false, - visible: true, } } diff --git a/src/state.rs b/src/state.rs index 776f2bf..0badaf0 100644 --- a/src/state.rs +++ b/src/state.rs @@ -46,6 +46,10 @@ impl State { &self.dungeon.levels[self.level] } + pub fn current_level_mut(&mut self) -> &mut Level { + &mut self.dungeon.levels[self.level] + } + fn can_step_on(tile: &Tile) -> bool { match tile.get_type() { TileType::Floor => true, @@ -55,6 +59,27 @@ impl State { } } + fn clear_los(&mut self) { + { + let grid = self.grid.as_mut().unwrap(); + grid.clear_fog_of_war(self.player.location(), PLAYER_SIGHT); + } + + for i in 0..self.current_level().entities.len() { + let loc = *self.current_level().entities[i].location(); + if self + .grid + .as_ref() + .unwrap() + .block_at(loc.0, loc.1) + .is_visible() + && !self.current_level().entities[i].is_visible() + { + self.current_level_mut().entities[i].visibility(true); + } + } + } + pub fn move_player(&mut self, dir: Movement) -> Result<(), String> { let grid = match &self.grid { Some(g) => g, diff --git a/src/world.rs b/src/world.rs index af72513..c577680 100644 --- a/src/world.rs +++ b/src/world.rs @@ -430,16 +430,17 @@ impl Generatable for Level { let room = &self.rooms[rng.gen_range(0, self.rooms.len() - 1)]; // Create the enemy + let enemy_coords = ( + room.start.0 + rng.gen_range(0, room.width - 1) + 1, + room.start.1 + rng.gen_range(0, room.height - 1) + 1, + ); self.entities.push(Box::::new(Enemy::new( String::from("snake"), 2 * self.depth as i32, (2.0 * self.depth as f32 * 0.6).round() as i32, (20.0 * self.depth as f32 * 0.2).max(80.0).round() as i32, 0, - ( - room.start.0 + rng.gen_range(0, room.width), - room.start.1 + rng.gen_range(0, room.height), - ), + enemy_coords, "s", ))); } -- cgit v1.2.3