jlusiardi/el_diablo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

updated deps

Browse Source 
fixed clippy remarks
This commit is contained in:
Joachim Lusiardi
2024-10-20 14:59:20 +02:00
parent 210d590e38
commit efc4cdd363
12 changed files with 515 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/artifacts.rs
View File

@@ -36,10 +36,15 @@ impl Artifact for Chest {
("C", Color::Blue)
}
fn get_immutable_position(&self) -> &Position { &self.position }
fn get_immutable_position(&self) -> &Position {
&self.position
}
fn collect(&mut self, player: &mut Player, messages: &mut Vec<String>) {
player.retrieve_gold(self.gold);
messages.insert(0, format!("opened chest and collected {} gold.", self.gold).to_string());
messages.insert(
0,
format!("opened chest and collected {} gold.", self.gold).to_string(),
);
self.gold = 0;
}
@@ -67,21 +72,29 @@ impl Artifact for Potion {
fn get_representation(&self) -> (&str, Color) {
("P", Color::Green)
}
fn get_immutable_position(&self) -> &Position { &self.position }
fn get_immutable_position(&self) -> &Position {
&self.position
}
fn collect(&mut self, player: &mut Player, messages: &mut Vec<String>) {
// only consume potion of the player can gain at least one health point
if !player.is_healthy() {
let old = player.get_life();
player.change_life(self.health.try_into().unwrap());
let new = player.get_life();
messages.insert(0, format!("picked up potion and gained {} hp.", new - old).to_string());
messages.insert(
0,
format!("picked up potion and gained {} hp.", new - old).to_string(),
);
self.health = 0;
} else {
messages.insert(0, "not using the potion because you're healthy.".to_string());
messages.insert(
0,
"not using the potion because you're healthy.".to_string(),
);
}
}
fn was_collected(&self) -> bool {
self.health == 0
}
}
}

91
src/game.rs
View File

@@ -9,14 +9,13 @@ pub const LEVELS: usize = 10;
/// represents a state of a game
pub enum GameState {
/// the game is ongoing (neither won or lost)
RUNNING,
Running,
/// the player died
LOST,
Lost,
/// the player reached the Ω
WON,
Won,
}
/// the main structure to hold all information about the ongoing game
pub struct Game {
/// the player
@@ -37,11 +36,12 @@ impl Game {
levels: v,
messages: Vec::with_capacity(10),
};
let start = {
g.get_level(0).start
};
g.get_mutable_player().get_position().set(0, start.0, start.1);
g.get_mutable_level(0).discover(&Position::new(0, start.0, start.1));
let start = { g.get_level(0).start };
g.get_mutable_player()
.get_position()
.set(0, start.0, start.1);
g.get_mutable_level(0)
.discover(&Position::new(0, start.0, start.1));
g
}
@@ -49,11 +49,8 @@ impl Game {
fn player_reached_goal(&mut self) -> bool {
match self.next_element(0, 0) {
None => {}
Some(a) => {
match a {
StructureElement::End => { return true; }
_ => {}
}
Some(a) => if a == StructureElement::End {
return true
}
};
false
@@ -61,12 +58,12 @@ impl Game {
/// returns the state of the game (depending on player's life and position)
pub fn get_game_state(&mut self) -> GameState {
if self.player.is_dead() {
return GameState::LOST;
return GameState::Lost;
}
if self.player_reached_goal() {
return GameState::WON;
return GameState::Won;
}
GameState::RUNNING
GameState::Running
}
pub fn get_player(&self) -> &Player {
&self.player
@@ -74,8 +71,12 @@ impl Game {
pub fn get_mutable_player(&mut self) -> &mut Player {
&mut self.player
}
pub fn get_level(&self, level: usize) -> &Level { &self.levels[level] }
pub fn get_mutable_level(&mut self, level: usize) -> &mut Level { &mut self.levels[level] }
pub fn get_level(&self, level: usize) -> &Level {
&self.levels[level]
}
pub fn get_mutable_level(&mut self, level: usize) -> &mut Level {
&mut self.levels[level]
}
/// check if the player can move in the given direction. This only checks for structure element
/// limitation as walls.
fn can_move(&mut self, dx: i16, dy: i16) -> bool {
@@ -120,32 +121,36 @@ impl Game {
let structure = self.next_element(dx, dy);
// use stairs if walked onto one
match structure {
Some(e) => {
match e {
StructureElement::StairDown => {
(dx, dy) = (0, 0);
let (next_level, x, y) = self.next_start();
player_level = next_level;
self.messages.insert(0, format!("you climb down to level {}.", next_level));
self.get_mutable_player().get_position().set(next_level, x, y);
}
StructureElement::StairUp => {
(dx, dy) = (0, 0);
let (next_level, x, y) = self.prev_end();
player_level = next_level;
self.messages.insert(0, format!("you climb up to level {}.", next_level));
self.get_mutable_player().get_position().set(next_level, x, y);
}
_ => {}
if let Some(e) = structure {
match e {
StructureElement::StairDown => {
(dx, dy) = (0, 0);
let (next_level, x, y) = self.next_start();
player_level = next_level;
self.messages
.insert(0, format!("you climb down to level {}.", next_level));
self.get_mutable_player()
.get_position()
.set(next_level, x, y);
}
StructureElement::StairUp => {
(dx, dy) = (0, 0);
let (next_level, x, y) = self.prev_end();
player_level = next_level;
self.messages
.insert(0, format!("you climb up to level {}.", next_level));
self.get_mutable_player()
.get_position()
.set(next_level, x, y);
}
_ => {}
}
_ => {}
}
};
// update position and discover area on new position
let (new_x, new_y) = self.get_mutable_player().get_position().change(dx, dy);
self.get_mutable_level(player_level).discover(&Position::new(player_level, new_x, new_y));
self.get_mutable_level(player_level)
.discover(&Position::new(player_level, new_x, new_y));
(-dx, -dy)
}
pub fn player_fights_monster(&mut self) -> bool {
@@ -159,8 +164,10 @@ impl Game {
// TODO fight the monster
self.player.change_life(-1);
m.decrease_life(1);
self.messages.insert(0, format!("{} hits you.", m.get_name()).to_string());
self.messages.insert(0, format!("you hit {}.", m.get_name()).to_string());
self.messages
.insert(0, format!("{} hits you.", m.get_name()).to_string());
self.messages
.insert(0, format!("you hit {}.", m.get_name()).to_string());
// monster died, player gains experience
if m.is_dead() {
self.player.gain_experience(m.get_experience_gain());

61
src/level.rs
View File

@@ -1,14 +1,14 @@
use std::cmp::{max, min};
use rand::Rng;
use rand::rngs::ThreadRng;
use rand::Rng;
#[cfg(test)]
use crate::artifacts::{Chest, Potion};
use crate::artifacts::Artifact;
#[cfg(test)]
use crate::monster::{Orc, Rat};
use crate::artifacts::{Chest, Potion};
use crate::monster::Monster;
#[cfg(test)]
use crate::monster::{Orc, Rat};
use crate::player::Player;
use crate::position::HasPosition;
use crate::position::Position;
@@ -27,6 +27,9 @@ pub enum StructureElement {
Unknown,
}
type PossibleArtifact<'a> = Option<&'a mut Box<(dyn Artifact + 'static)>>;
type PossibleMonster<'a> = Option<&'a mut Box<(dyn Monster + 'static)>>;
pub struct Level {
pub(crate) level: usize,
pub(crate) structure: [[StructureElement; LEVEL_HEIGHT]; LEVEL_WIDTH],
@@ -41,7 +44,15 @@ pub struct Level {
}
impl Level {
pub fn get_element(&mut self, x: i16, y: i16) -> (Option<StructureElement>, Option<&mut Box<(dyn Monster + 'static)>>, Option<&mut Box<(dyn Artifact + 'static)>>) {
pub fn get_element(
&mut self,
x: i16,
y: i16,
) -> (
Option<StructureElement>,
PossibleMonster,
PossibleArtifact
) {
if x < 0 || y < 0 {
return (None, None, None);
}
@@ -129,19 +140,27 @@ impl Level {
loop {
// calculate the direction the monster will try to walk
let (dx, dy) = match self.rng.gen_range(0..5) {
1 => { (1, 0) }
2 => { (-1, 0) }
3 => { (0, 1) }
4 => { (0, -1) }
_ => { (0, 0) }
1 => (1, 0),
2 => (-1, 0),
3 => (0, 1),
4 => (0, -1),
_ => (0, 0),
};
if self.can_monster_move(self.monsters[index].as_ref(), dx, dy) {
let (new_x, new_y) = self.monsters[index].get_position().change(dx, dy);
if player.get_immutable_position().get_x() == new_x && player.get_immutable_position().get_y() == new_y {
if player.get_immutable_position().get_x() == new_x
&& player.get_immutable_position().get_y() == new_y
{
self.monsters[index].decrease_life(1);
player.change_life(-1);
messages.insert(0, format!("{} hits you.", self.monsters[index].get_name()).to_string());
messages.insert(0, format!("you hit {}.", self.monsters[index].get_name()).to_string());
messages.insert(
0,
format!("{} hits you.", self.monsters[index].get_name()).to_string(),
);
messages.insert(
0,
format!("you hit {}.", self.monsters[index].get_name()).to_string(),
);
// if the attack did not kill the opponent, back down
if !player.is_dead() {
self.monsters[index].get_position().change(-dx, -dy);
@@ -171,7 +190,9 @@ impl Level {
for index in 0..self.monsters.len() {
let pos = self.monsters[index].get_immutable_position();
if pos.get_x() == new_x && pos.get_y() == new_y { return false; }
if pos.get_x() == new_x && pos.get_y() == new_y {
return false;
}
}
self.structure[new_x][new_y] != StructureElement::Wall
}
@@ -239,8 +260,16 @@ fn test_get_element() {
let mut l = Level::new(0);
assert_eq!(l.get_element(-1, -1).0, None);
assert_eq!(l.get_element(0, 0).0.unwrap(), StructureElement::Unknown);
assert_eq!(l.get_element(LEVEL_WIDTH as i16 - 1, LEVEL_HEIGHT as i16 - 1).0.unwrap(), StructureElement::Unknown);
assert_eq!(l.get_element(LEVEL_WIDTH as i16, LEVEL_HEIGHT as i16).0, None);
assert_eq!(
l.get_element(LEVEL_WIDTH as i16 - 1, LEVEL_HEIGHT as i16 - 1)
.0
.unwrap(),
StructureElement::Unknown
);
assert_eq!(
l.get_element(LEVEL_WIDTH as i16, LEVEL_HEIGHT as i16).0,
None
);
}
#[test]

127
src/level_generator.rs
View File

@@ -6,8 +6,8 @@ use petgraph::data::*;
use petgraph::graph::Graph;
use petgraph::graph::UnGraph;
use rand::prelude::SliceRandom;
use rand::Rng;
use rand::rngs::ThreadRng;
use rand::Rng;
use crate::artifacts::{Artifact, Chest, Potion};
use crate::level::{Level, StructureElement};
@@ -93,7 +93,8 @@ impl LevelGenerator {
rooms[0][0].kind = RoomType::BasicRoom;
while !LevelGenerator::rooms_connectable(&rooms) {
let mut room_types: Vec<RoomType> = Vec::with_capacity(ROOMS_HORIZONTAL * ROOMS_VERTICAL);
let mut room_types: Vec<RoomType> =
Vec::with_capacity(ROOMS_HORIZONTAL * ROOMS_VERTICAL);
// level 0 contains a start room, all others contain a stair up
if first {
room_types.push(RoomType::Start);
@@ -112,21 +113,21 @@ impl LevelGenerator {
for _ in room_types.len()..ROOMS_HORIZONTAL * ROOMS_VERTICAL {
match rng.gen_range(1..=100) {
// TODO tune room type distribution
1..=33 => { room_types.push(RoomType::EmptyRoom) }
34..=66 => { room_types.push(RoomType::TreasureRoom) }
67..=90 => { room_types.push(RoomType::MonsterRoom) }
_ => { room_types.push(RoomType::BasicRoom) }
1..=33 => room_types.push(RoomType::EmptyRoom),
34..=66 => room_types.push(RoomType::TreasureRoom),
67..=90 => room_types.push(RoomType::MonsterRoom),
_ => room_types.push(RoomType::BasicRoom),
}
}
room_types.shuffle(&mut rng);
graph.clear();
// place the rooms in the array an add nodes to the graph for every non empty room
for c in 0..ROOMS_VERTICAL {
for r in 0..ROOMS_HORIZONTAL {
rooms[c][r].kind = room_types.pop().unwrap();
if rooms[c][r].kind != RoomType::EmptyRoom {
rooms[c][r].random(&mut rng);
for (c, rs) in rooms.iter_mut().enumerate().take(ROOMS_VERTICAL) {
for (r, room) in rs.iter_mut().enumerate().take(ROOMS_HORIZONTAL) {
room.kind = room_types.pop().unwrap();
if room.kind != RoomType::EmptyRoom {
room.random(&mut rng);
graph.add_node((c, r));
}
}
@@ -142,15 +143,21 @@ impl LevelGenerator {
let src_index = graph.node_indices().find(|i| graph[*i] == (c, r)).unwrap();
for r_1 in r + 1..ROOMS_HORIZONTAL {
if rooms[c][r_1].kind != RoomType::EmptyRoom {
let tgt_index = graph.node_indices().find(|i| graph[*i] == (c, r_1)).unwrap();
let tgt_index = graph
.node_indices()
.find(|i| graph[*i] == (c, r_1))
.unwrap();
// todo use random weight for edge
graph.add_edge(src_index, tgt_index, 1);
break;
}
}
for c_1 in c + 1..ROOMS_VERTICAL {
if rooms[c_1][r].kind != RoomType::EmptyRoom {
let tgt_index = graph.node_indices().find(|i| graph[*i] == (c_1, r)).unwrap();
for (c_1, rs) in rooms.iter().enumerate().take(ROOMS_VERTICAL).skip(c + 1) {
if rs[r].kind != RoomType::EmptyRoom {
let tgt_index = graph
.node_indices()
.find(|i| graph[*i] == (c_1, r))
.unwrap();
// todo use random weight for edge
graph.add_edge(src_index, tgt_index, 1);
break;
@@ -160,7 +167,8 @@ impl LevelGenerator {
}
// calculate a minimum spanning tree
let mst: Graph<(usize, usize), u16, petgraph::Undirected> = Graph::from_elements(min_spanning_tree(&graph));
let mst: Graph<(usize, usize), u16, petgraph::Undirected> =
Graph::from_elements(min_spanning_tree(&graph));
for edge in mst.raw_edges() {
let src = mst[edge.source()];
let tgt = mst[edge.target()];
@@ -170,24 +178,31 @@ impl LevelGenerator {
// cols are the same, either up or down
if src.0 == tgt.0 {
let range = LevelGenerator::range_overlap(src_room.get_x_range(), tgt_room.get_x_range());
let position: usize;
if range.is_empty() {
position = range.start;
let range =
LevelGenerator::range_overlap(src_room.get_x_range(), tgt_room.get_x_range());
let position: usize = if range.is_empty() {
range.start
} else {
position = rng.gen_range(range);
}
rng.gen_range(range)
};
if src.1 < tgt.1 {
// src to tgt
rooms[src.0][src.1].connection_down = Some(ConnectionInfo { offset: position, distance: tgt.1 - src.1 });
rooms[src.0][src.1].connection_down = Some(ConnectionInfo {
offset: position,
distance: tgt.1 - src.1,
});
} else {
// tgt to src
tgt_room.connection_down = Some(ConnectionInfo { offset: position, distance: src.1 - tgt.1 });
tgt_room.connection_down = Some(ConnectionInfo {
offset: position,
distance: src.1 - tgt.1,
});
}
}
// rows are the same, either left or right
if src.1 == tgt.1 {
let range = LevelGenerator::range_overlap(src_room.get_y_range(), tgt_room.get_y_range());
let range =
LevelGenerator::range_overlap(src_room.get_y_range(), tgt_room.get_y_range());
let mut position: usize;
if range.is_empty() {
position = range.start;
@@ -199,18 +214,21 @@ impl LevelGenerator {
}
if src.0 < tgt.0 {
// src to tgt
rooms[src.0][src.1].connection_right = Some(ConnectionInfo { offset: position, distance: tgt.0 - src.0 });
rooms[src.0][src.1].connection_right = Some(ConnectionInfo {
offset: position,
distance: tgt.0 - src.0,
});
} else {
// tgt to src
tgt_room.connection_right = Some(ConnectionInfo { offset: position, distance: src.1 - tgt.1 });
tgt_room.connection_right = Some(ConnectionInfo {
offset: position,
distance: src.1 - tgt.1,
});
}
}
}
LevelGenerator {
rooms,
level,
}
LevelGenerator { rooms, level }
}
fn range_overlap(r1: Range<usize>, r2: Range<usize>) -> Range<usize> {
@@ -224,8 +242,8 @@ impl LevelGenerator {
for r in 0..ROOMS_HORIZONTAL {
if rooms[c][r].kind != RoomType::EmptyRoom {
let mut connected = 0;
for c1 in 0..ROOMS_VERTICAL {
if rooms[c1][r].kind != RoomType::EmptyRoom {
for room in rooms.iter().take(ROOMS_VERTICAL) {
if room[r].kind != RoomType::EmptyRoom {
connected += 1;
}
}
@@ -240,11 +258,12 @@ impl LevelGenerator {
}
}
}
return true;
true
}
pub fn render(&self) -> Level {
let mut rng = rand::thread_rng();
let mut structure = [[StructureElement::Wall; 1 + ROOMS_HORIZONTAL * ROOM_HEIGHT]; 1 + ROOMS_VERTICAL * ROOM_WIDTH];
let mut structure = [[StructureElement::Wall; 1 + ROOMS_HORIZONTAL * ROOM_HEIGHT];
1 + ROOMS_VERTICAL * ROOM_WIDTH];
let mut artifacts: Vec<Box<dyn Artifact>> = Vec::with_capacity(10);
let mut enemies: Vec<Box<dyn Monster>> = Vec::with_capacity(10);
let mut start_x: usize = 0;
@@ -258,7 +277,8 @@ impl LevelGenerator {
let room = self.rooms[c][r];
for x in 0..room.width {
for y in 0..room.height {
structure[left + room.offset_x + x][top + room.offset_y + y] = StructureElement::Floor;
structure[left + room.offset_x + x][top + room.offset_y + y] =
StructureElement::Floor;
}
}
if room.kind == RoomType::TreasureRoom {
@@ -266,8 +286,14 @@ impl LevelGenerator {
let t_y = top + room.offset_y + rng.gen_range(0..room.height);
// TODO randomize artifacts
match rng.gen_range(1..=100) {
1..=50 => { artifacts.push(Box::new(Chest::new(Position::new(self.level, t_x, t_y)))); }
_ => { artifacts.push(Box::new(Potion::new(Position::new(self.level, t_x, t_y)))); }
1..=50 => {
artifacts
.push(Box::new(Chest::new(Position::new(self.level, t_x, t_y))));
}
_ => {
artifacts
.push(Box::new(Potion::new(Position::new(self.level, t_x, t_y))));
}
};
}
if room.kind == RoomType::MonsterRoom {
@@ -276,10 +302,14 @@ impl LevelGenerator {
// TODO randomize enemies here
match rng.gen_range(1..=100) {
1..=50 => {
enemies.push(Box::new(Orc::new_with_position(Position::new(self.level, t_x, t_y))));
enemies.push(Box::new(Orc::new_with_position(Position::new(
self.level, t_x, t_y,
))));
}
_ => {
enemies.push(Box::new(Rat::new_with_position(Position::new(self.level, t_x, t_y))));
enemies.push(Box::new(Rat::new_with_position(Position::new(
self.level, t_x, t_y,
))));
}
};
}
@@ -315,7 +345,10 @@ impl LevelGenerator {
let tgt_room = self.rooms[c][r + x_conn.distance];
let top = 1 + r * ROOM_HEIGHT + src_room.offset_y;
let left = 1 + c * ROOM_WIDTH + x_conn.offset;
let bottom = 1 + (r + x_conn.distance) * ROOM_HEIGHT + tgt_room.offset_y + tgt_room.height;
let bottom = 1
+ (r + x_conn.distance) * ROOM_HEIGHT
+ tgt_room.offset_y
+ tgt_room.height;
for i in top..bottom {
if structure[left][i] == StructureElement::Wall {
structure[left][i] = StructureElement::Floor;
@@ -327,10 +360,11 @@ impl LevelGenerator {
let top = 1 + r * ROOM_HEIGHT + src_room.offset_y + y_conn.offset - 1;
let left = 1 + c * ROOM_WIDTH + src_room.offset_x;
let right = 1 + (c + y_conn.distance) * ROOM_WIDTH + tgt_room.offset_x + tgt_room.width;
for i in left..right {
if structure[i][top] == StructureElement::Wall {
structure[i][top] = StructureElement::Floor;
let right =
1 + (c + y_conn.distance) * ROOM_WIDTH + tgt_room.offset_x + tgt_room.width;
for room in structure.iter_mut().take(right).skip(left) {
if room[top] == StructureElement::Wall {
room[top] = StructureElement::Floor;
}
}
}
@@ -339,7 +373,8 @@ impl LevelGenerator {
Level {
level: self.level,
structure,
discovered: [[false; 1 + ROOMS_HORIZONTAL * ROOM_HEIGHT]; 1 + ROOMS_VERTICAL * ROOM_WIDTH],
discovered: [[false; 1 + ROOMS_HORIZONTAL * ROOM_HEIGHT];
1 + ROOMS_VERTICAL * ROOM_WIDTH],
monsters: enemies,
artifacts,
start: (start_x, start_y),

6
src/level_widget.rs
View File

@@ -13,11 +13,7 @@ pub struct LevelWidget {}
impl LevelWidget {
fn set_cell(&self, buf: &mut Buffer, x: u16, y: u16, symbol: &str, fg: Color, bg: Color) {
buf.
get_mut(x, y).
set_symbol(symbol).
set_bg(bg).
set_fg(fg);
buf[(x, y)].set_symbol(symbol).set_bg(bg).set_fg(fg);
}
}

107
src/main.rs
View File

@@ -1,19 +1,19 @@
use std::io::Result;
use std::io::stdout;
use std::io::Result;
use std::time::Instant;
use crossterm::{
event::{self, KeyCode, KeyEventKind},
ExecutableCommand,
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
ExecutableCommand,
};
use ratatui::prelude::*;
use ratatui::widgets::block::{Position, Title};
use ratatui::widgets::{Block, BorderType, Borders, Wrap};
use ratatui::{
prelude::{CrosstermBackend, Terminal},
widgets::Paragraph,
};
use ratatui::prelude::*;
use ratatui::widgets::{Block, Borders, BorderType, Wrap};
use ratatui::widgets::block::{Position, Title};
use whoami::realname;
use crate::game::{Game, GameState};
@@ -21,14 +21,14 @@ use crate::level_widget::LevelWidget;
use crate::player::Player;
use crate::position::HasPosition;
mod game;
mod player;
mod level;
mod position;
mod level_widget;
mod level_generator;
mod artifacts;
mod game;
mod level;
mod level_generator;
mod level_widget;
mod monster;
mod player;
mod position;
/// length of a game frame in ms
pub const FRAME_LENGTH: u64 = 100;
@@ -46,8 +46,11 @@ fn main() -> Result<()> {
let mut ticks = 0;
loop {
terminal.draw(|frame| {
let mut area = frame.size();
frame.render_widget(Block::default().style(Style::default().bg(Color::Green)), area);
let mut area = frame.area();
frame.render_widget(
Block::default().style(Style::default().bg(Color::Green)),
area,
);
// don't draw stuff except an info box if the terminal is too small (less than 80x25)
// to prevent the read drawing code from crashing the game.
@@ -90,23 +93,25 @@ fn main() -> Result<()> {
};
let block = Block::default()
.title(
Title::from(
format!(" {} ", game.get_player().get_name()))
Title::from(format!(" {} ", game.get_player().get_name()))
.alignment(Alignment::Center)
.position(Position::Top)
.position(Position::Top),
)
.borders(Borders::TOP)
.border_style(Style::default().fg(Color::White))
.border_type(BorderType::Rounded)
.style(Style::default().bg(Color::Blue));
frame.render_widget(
Paragraph::new(format!("Health: {}/{}\nExp: {}\nGold: {}\nLevel: {}",
game.get_player().get_life(),
game.get_player().get_max_life(),
game.get_player().get_experience(),
game.get_player().get_gold(),
game.get_player().get_immutable_position().get_level()))
.block(block).wrap(Wrap { trim: true }),
Paragraph::new(format!(
"Health: {}/{}\nExp: {}\nGold: {}\nLevel: {}",
game.get_player().get_life(),
game.get_player().get_max_life(),
game.get_player().get_experience(),
game.get_player().get_gold(),
game.get_player().get_immutable_position().get_level()
))
.block(block)
.wrap(Wrap { trim: true }),
stats_area,
);
let messages_area = Rect {
@@ -117,33 +122,46 @@ fn main() -> Result<()> {
};
// Display the latest messages from the game to the user
let block = Block::default()
.title(Title::from(" messages ").alignment(Alignment::Center).position(Position::Top))
.title(
Title::from(" messages ")
.alignment(Alignment::Center)
.position(Position::Top),
)
.borders(Borders::TOP)
.border_style(Style::default().fg(Color::White))
.border_type(BorderType::Rounded)
.style(Style::default().bg(Color::Blue));
let paragraph1 = if game.messages.is_empty() { "".to_string() } else { format!("> {}", game.messages.join("\n> ")) };
let paragraph1 = if game.messages.is_empty() {
"".to_string()
} else {
format!("> {}", game.messages.join("\n> "))
};
frame.render_widget(
Paragraph::new(paragraph1).block(block).wrap(Wrap { trim: true }),
Paragraph::new(paragraph1)
.block(block)
.wrap(Wrap { trim: true }),
messages_area,
);
})?;
if event::poll(std::time::Duration::from_millis(FRAME_LENGTH))? {
if let event::Event::Key(key) = event::read()? {
if key.kind == KeyEventKind::Press && key.code == KeyCode::Char('v') {
game.messages.insert(0, format!("You are playing version '{}'.", env!("GIT_HASH")).to_string());
game.messages.insert(
0,
format!("You are playing version '{}'.", env!("GIT_HASH")).to_string(),
);
}
if key.kind == KeyEventKind::Press && key.code == KeyCode::Char('q') {
break;
}
if key.kind == KeyEventKind::Press {
let new_pos = match key.code {
KeyCode::Left => { game.move_player(-1, 0) }
KeyCode::Right => { game.move_player(1, 0) }
KeyCode::Up => { game.move_player(0, -1) }
KeyCode::Down => { game.move_player(0, 1) }
_ => { (0, 0) }
KeyCode::Left => game.move_player(-1, 0),
KeyCode::Right => game.move_player(1, 0),
KeyCode::Up => game.move_player(0, -1),
KeyCode::Down => game.move_player(0, 1),
_ => (0, 0),
};
if !game.player_fights_monster() {
// player attacked monster but did not kill it
@@ -154,7 +172,7 @@ fn main() -> Result<()> {
}
}
game.update_level(ticks);
if game.get_game_state() != GameState::RUNNING {
if game.get_game_state() != GameState::Running {
break;
}
ticks += 1;
@@ -162,7 +180,7 @@ fn main() -> Result<()> {
let playtime = start_time.elapsed();
loop {
let _ = terminal.draw(|frame| {
let mut area = frame.size();
let mut area = frame.area();
let w = area.width / 2;
let h = area.height / 2;
area.x += w - 20;
@@ -170,24 +188,33 @@ fn main() -> Result<()> {
area.width = 40;
area.height = 20;
let block = Block::default()
.title(Title::from(" Game ended ").alignment(Alignment::Center).position(Position::Top))
.title(
Title::from(" Game ended ")
.alignment(Alignment::Center)
.position(Position::Top),
)
.title(Title::from("Press `q` to quit!").position(Position::Bottom))
.borders(Borders::ALL)
.border_style(Style::default().fg(Color::White))
.border_type(BorderType::Rounded)
.style(Style::default().bg(Color::Black));
let mut text = match game.get_game_state() {
GameState::RUNNING => {
GameState::Running => {
"Quitting is for cowards! You'll better try again!".to_string()
}
GameState::LOST => {
GameState::Lost => {
"Sorry, you died in the dungeon. Better luck next time!".to_string()
}
GameState::WON => {
"Congratulation! You mastered your way through the dungeon and won the game.".to_string()
GameState::Won => {
"Congratulation! You mastered your way through the dungeon and won the game."
.to_string()
}
};
text += format!("\nYou gained {} experience.", game.get_player().get_experience()).as_str();
text += format!(
"\nYou gained {} experience.",
game.get_player().get_experience()
)
.as_str();
text += format!("\nYou collected {} gold.", game.get_player().get_gold()).as_str();
text += format!("\nYou played {} seconds.", playtime.as_secs()).as_str();
let paragraph = Paragraph::new(text).block(block).wrap(Wrap { trim: true });

3
src/monster.rs
View File

@@ -91,7 +91,6 @@ impl Orc {
default_monster!(Orc);
#[test]
fn monsters_can_move() {
let mut m = Rat::new_with_position(Position::new(0, 0, 0));
@@ -115,4 +114,4 @@ fn monsters_can_die() {
m.decrease_life(2);
assert_eq!(m.get_life(), 0);
assert_eq!(m.is_dead(), true);
}
}

26
src/player.rs
View File

@@ -23,7 +23,7 @@ impl Player {
}
}
pub fn get_name(&self) -> String {
return self.name.clone();
self.name.clone()
}
pub fn change_life(&mut self, by: i16) {
self.life = max(0, min(self.max_life, self.life + by));
@@ -32,22 +32,34 @@ impl Player {
self.life
}
/// returns true if the player is dead (life <= 0)
pub fn is_dead(&self) -> bool { self.life <= 0 }
pub fn is_dead(&self) -> bool {
self.life <= 0
}
/// returns true if the player's life is at maximum
pub fn is_healthy(&self) -> bool { self.life == self.max_life }
pub fn is_healthy(&self) -> bool {
self.life == self.max_life
}
pub fn get_max_life(&self) -> i16 {
self.max_life
}
/// add the given amount to the players gold stash
pub fn retrieve_gold(&mut self, amount: usize) { self.gold += amount }
pub fn retrieve_gold(&mut self, amount: usize) {
self.gold += amount
}
/// return the size of the players gold stash
pub fn get_gold(&self) -> usize { self.gold }
pub fn get_gold(&self) -> usize {
self.gold
}
pub fn gain_experience(&mut self, amount: usize) { self.experience += amount }
pub fn gain_experience(&mut self, amount: usize) {
self.experience += amount
}
pub fn get_experience(&self) -> usize { self.experience }
pub fn get_experience(&self) -> usize {
self.experience
}
}
impl HasPosition for Player {

12
src/position.rs
View File

@@ -17,11 +17,7 @@ pub struct Position {
impl Position {
pub fn new(level: usize, x: usize, y: usize) -> Self {
Self {
level,
x,
y,
}
Self { level, x, y }
}
pub fn change(&mut self, dx: i16, dy: i16) -> (usize, usize) {
self.x = max((self.x as i16) + dx, 0) as usize;
@@ -42,7 +38,9 @@ impl Position {
self.x
}
pub fn get_y(&self) -> usize { self.y }
pub fn get_y(&self) -> usize {
self.y
}
}
#[test]
@@ -73,4 +71,4 @@ fn test_position_set() {
assert_eq!(p.get_level(), 1);
assert_eq!(p.get_x(), 2);
assert_eq!(p.get_y(), 3);
}
}