253 lines
8.9 KiB
Rust
253 lines
8.9 KiB
Rust
use crate::level::{Level, StructureElement};
|
|
use crate::level_generator::LevelGenerator;
|
|
use crate::player::Player;
|
|
use crate::position::{HasPosition, Position};
|
|
|
|
pub const LEVELS: usize = 10;
|
|
|
|
#[derive(PartialEq)]
|
|
/// represents a state of a game
|
|
pub enum GameState {
|
|
/// the game is ongoing (neither won or lost)
|
|
Running,
|
|
/// the player died
|
|
Lost,
|
|
/// the player reached the Ω
|
|
Won,
|
|
}
|
|
|
|
/// the main structure to hold all information about the ongoing game
|
|
pub struct Game {
|
|
/// the player
|
|
player: Player,
|
|
/// the levels of the game
|
|
levels: Vec<Level>,
|
|
/// messages that are displayed in the ui
|
|
pub messages: Vec<String>,
|
|
}
|
|
|
|
impl Game {
|
|
pub fn new(p: Player) -> Game {
|
|
let mut v: Vec<Level> = Vec::with_capacity(LEVELS);
|
|
for d in 0..LEVELS {
|
|
v.push(LevelGenerator::generate(d, d == 0, d == LEVELS - 1).render());
|
|
}
|
|
let mut g = Game {
|
|
player: p,
|
|
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));
|
|
g
|
|
}
|
|
|
|
/// returns true if the player is standing on the End element
|
|
fn player_reached_goal(&mut self) -> bool {
|
|
match self.next_element(0, 0) {
|
|
None => {}
|
|
Some(a) => {
|
|
if a == StructureElement::End {
|
|
return true;
|
|
}
|
|
}
|
|
};
|
|
false
|
|
}
|
|
/// 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;
|
|
}
|
|
if self.player_reached_goal() {
|
|
return GameState::Won;
|
|
}
|
|
GameState::Running
|
|
}
|
|
pub fn get_player(&self) -> &Player {
|
|
&self.player
|
|
}
|
|
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]
|
|
}
|
|
/// 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 {
|
|
let player_pos = &self.player.get_position();
|
|
let level = &mut self.levels[player_pos.get_level()];
|
|
level.can_player_move(&self.player, dx, dy)
|
|
}
|
|
/// returns the position (as tuple) of the next level's start point.
|
|
fn next_start(&self) -> (usize, usize, usize) {
|
|
let level = self.player.get_immutable_position().get_level() + 1;
|
|
let (x, y) = self.levels[level].start;
|
|
(level, x, y)
|
|
}
|
|
/// returns the position (as tuple) of the previous level's end point.
|
|
fn prev_end(&self) -> (usize, usize, usize) {
|
|
let level = self.player.get_immutable_position().get_level() - 1;
|
|
let (x, y) = self.levels[level].end;
|
|
(level, x, y)
|
|
}
|
|
/// get the next structure element sen from the player's position into the given direction.
|
|
fn next_element(&mut self, dx: i16, dy: i16) -> Option<StructureElement> {
|
|
let player_pos = &self.player.get_position();
|
|
let new_x: i16 = player_pos.get_x() as i16 + dx;
|
|
let new_y: i16 = player_pos.get_y() as i16 + dy;
|
|
let player_level = player_pos.get_level();
|
|
let level = &mut self.levels[player_level];
|
|
level.get_element(new_x, new_y).0
|
|
}
|
|
|
|
/// move the game's player into the given direction. If on the target field there is a stair,
|
|
/// the player follows the stair up/down to the next level.
|
|
/// Discovery is performed on the new location of the player.
|
|
/// The returned value is the direction that will bring the player back to his original field.
|
|
pub fn move_player(&mut self, mut dx: i16, mut dy: i16) -> (i16, i16) {
|
|
// verify the player can do the move
|
|
if !self.can_move(dx, dy) {
|
|
return (-dx, -dy);
|
|
}
|
|
|
|
let player_pos = &self.player.get_position();
|
|
let mut player_level = player_pos.get_level();
|
|
let structure = self.next_element(dx, dy);
|
|
|
|
// use stairs if walked onto one
|
|
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 + 1));
|
|
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 + 1));
|
|
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));
|
|
(-dx, -dy)
|
|
}
|
|
|
|
pub fn player_fights_monster(&mut self) -> bool {
|
|
let player_pos = &self.player.get_immutable_position();
|
|
let player_level = player_pos.get_level();
|
|
let level = &mut self.levels[player_level];
|
|
let (_, m, _) = level.get_element(player_pos.get_x() as i16, player_pos.get_y() as i16);
|
|
match m {
|
|
None => {}
|
|
Some(m) => {
|
|
let player_dmg = self.player.damage();
|
|
m.decrease_life(player_dmg);
|
|
if m.is_dead() {
|
|
self.player.gain_experience(m.get_experience_gain());
|
|
self.messages.insert(
|
|
0,
|
|
format!(
|
|
"you hit {} for {} damage and kill it.",
|
|
m.get_name(),
|
|
player_dmg
|
|
)
|
|
.to_string(),
|
|
);
|
|
} else {
|
|
self.messages.insert(
|
|
0,
|
|
format!("you hit {} for {} damage.", m.get_name(), player_dmg).to_string(),
|
|
);
|
|
let monster_dmg = m.damage() as i16;
|
|
self.player.change_life(-monster_dmg);
|
|
|
|
self.messages.insert(
|
|
0,
|
|
format!("{} hits you for {} damage.", m.get_name(), monster_dmg)
|
|
.to_string(),
|
|
);
|
|
}
|
|
return m.is_dead();
|
|
}
|
|
};
|
|
true
|
|
}
|
|
pub fn player_collects_artifact(&mut self) {
|
|
let player_pos = &self.player.get_immutable_position();
|
|
let player_level = player_pos.get_level();
|
|
let level = &mut self.levels[player_level];
|
|
let (_, _, a) = level.get_element(player_pos.get_x() as i16, player_pos.get_y() as i16);
|
|
match a {
|
|
None => {}
|
|
Some(a) => {
|
|
a.collect(&mut self.player, &mut self.messages);
|
|
}
|
|
}
|
|
}
|
|
/// updates the player's current level. This will remove collected artifacts and dead monsters.
|
|
pub fn update_level(&mut self, ticks: u128) {
|
|
let player_pos = &self.player.get_immutable_position();
|
|
let player_level = player_pos.get_level();
|
|
let level = &mut self.levels[player_level];
|
|
level.update(ticks, &mut self.player, &mut self.messages);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn game_has_correct_number_of_levels() {
|
|
let p = Player::new("foo", 42);
|
|
let g = Game::new(p);
|
|
assert_eq!(g.levels.len(), LEVELS);
|
|
}
|
|
|
|
#[test]
|
|
fn game_has_player() {
|
|
let p = Player::new("foo", 42);
|
|
let g = Game::new(p);
|
|
assert_eq!(g.get_player().get_name(), "foo");
|
|
assert_eq!(g.get_player().get_immutable_position().get_level(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn game_has_mutable_player() {
|
|
let p = Player::new("foo", 42);
|
|
let mut g = Game::new(p);
|
|
assert_eq!(g.get_player().get_name(), "foo");
|
|
g.get_mutable_player().change_life(-1);
|
|
assert_eq!(g.get_player().get_life(), 41);
|
|
}
|
|
|
|
#[test]
|
|
fn game_get_level() {
|
|
let p = Player::new("foo", 42);
|
|
let mut g = Game::new(p);
|
|
g.get_level(0);
|
|
assert_ne!(g.get_level(0).start, (0, 0));
|
|
g.get_mutable_level(0).discover(&Position::new(0, 1, 1));
|
|
}
|