164 lines
4.2 KiB
Rust
164 lines
4.2 KiB
Rust
//! This file contains the global state of the game. Data here is passed around to all handler functions.
|
|
|
|
use std::{fmt, fs::File, io::BufReader};
|
|
|
|
use raylib::{
|
|
camera::Camera2D, math::Vector2, prelude::RaylibDrawHandle, RaylibHandle, RaylibThread,
|
|
};
|
|
|
|
use crate::{
|
|
player::{Player, PlayerInventory},
|
|
resources::GlobalResources,
|
|
world::World,
|
|
};
|
|
|
|
use failure::Error;
|
|
use log::debug;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
/// Overall states for the game
|
|
#[derive(Debug, PartialEq, Copy, Clone)]
|
|
pub enum GameState {
|
|
Loading,
|
|
MainMenu,
|
|
PauseMenu,
|
|
GameQuit,
|
|
InGame,
|
|
GameEnd,
|
|
InShop
|
|
}
|
|
|
|
impl fmt::Display for GameState {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(f, "{:?}", self)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize, Default)]
|
|
pub struct GameProgress {
|
|
pub coins: u32,
|
|
pub max_depth: f32,
|
|
pub fastest_time: Option<f64>,
|
|
pub inventory: PlayerInventory,
|
|
}
|
|
|
|
impl GameProgress {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
pub fn from_file(file: String) -> Result<Self, Error> {
|
|
// Load the file
|
|
let file = File::open(file)?;
|
|
let reader = BufReader::new(file);
|
|
|
|
// Deserialize
|
|
Ok(serde_json::from_reader(reader)?)
|
|
}
|
|
|
|
pub fn try_from_file(file: String) -> Self {
|
|
// Load from file
|
|
let loaded = GameProgress::from_file(file);
|
|
if loaded.is_ok() {
|
|
return loaded.unwrap();
|
|
} else {
|
|
return GameProgress::new();
|
|
}
|
|
}
|
|
|
|
pub fn to_file(&self, file: String) -> Result<(), Error> {
|
|
// Serialize
|
|
let json = serde_json::to_string(self)?;
|
|
|
|
// Write to file
|
|
std::fs::write(file, json)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn update(&mut self, new_progress: &GameProgress) {
|
|
|
|
// Bring in new data
|
|
self.coins = new_progress.coins;
|
|
self.inventory = new_progress.inventory.clone();
|
|
self.max_depth = self.max_depth.max(new_progress.max_depth);
|
|
// self.fastest_time = self.fastest_time.min(new_progress.fastest_time);
|
|
|
|
// Write to file
|
|
let result = self.to_file("./assets/savestate.json".to_string());
|
|
if result.is_err() {
|
|
println!("Could not save game state. Holding in RAM");
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/// This structure contains the entire game state, and should be passed around to various logic functions.
|
|
pub struct GameCore {
|
|
/// The game's overall state
|
|
pub state: GameState,
|
|
pub last_state: GameState,
|
|
pub last_state_change_time: f64,
|
|
pub last_frame_time: f64,
|
|
pub has_rendered_first_frame: bool,
|
|
|
|
/// Resources
|
|
pub resources: GlobalResources,
|
|
|
|
/// Camera (more than one maybe?)
|
|
pub master_camera: Camera2D,
|
|
|
|
/// Debug features
|
|
pub show_simple_debug_info: bool,
|
|
|
|
/// The world
|
|
pub world: World,
|
|
|
|
/// The player
|
|
pub player: Player,
|
|
pub progress: GameProgress,
|
|
}
|
|
|
|
impl GameCore {
|
|
pub fn new(
|
|
raylib: &mut RaylibHandle,
|
|
thread: &RaylibThread,
|
|
world: World,
|
|
progress: GameProgress,
|
|
) -> Self {
|
|
let player = Player::new(&world.player_spawn);
|
|
Self {
|
|
state: GameState::Loading,
|
|
last_state: GameState::Loading,
|
|
last_state_change_time: 0.0,
|
|
last_frame_time: 0.0,
|
|
has_rendered_first_frame: false,
|
|
resources: GlobalResources::load_all(raylib, thread)
|
|
.expect("Failed to load game assets. Can not launch!"),
|
|
master_camera: Camera2D {
|
|
offset: Vector2::zero(),
|
|
target: world.player_spawn,
|
|
rotation: 0.0,
|
|
zoom: 2.0,
|
|
},
|
|
show_simple_debug_info: false,
|
|
world: world,
|
|
player,
|
|
progress: progress,
|
|
}
|
|
}
|
|
|
|
pub fn switch_state(&mut self, new_state: GameState, draw_handle: Option<&RaylibDrawHandle>) {
|
|
debug!("Switching global state to: {}", new_state);
|
|
|
|
self.last_state = self.state;
|
|
self.state = new_state;
|
|
|
|
if draw_handle.is_some() {
|
|
self.last_state_change_time = draw_handle.as_ref().unwrap().get_time();
|
|
}
|
|
}
|
|
}
|