176 lines
4.2 KiB
Rust
176 lines
4.2 KiB
Rust
use std::cell::RefCell;
|
|
|
|
/// DOOM version
|
|
pub const VERSION:i32 = 110;
|
|
|
|
/// BASE_WIDTH
|
|
/// For resize of screen, at start of game.
|
|
/// It will not work dynamically, see visplanes. TODO: Investigate what this means.
|
|
pub const BASE_WIDTH: i32 = 320;
|
|
|
|
/// Screen scale multiplier?
|
|
/// Original source comment:
|
|
/// It is educational but futile to change this
|
|
/// scaling e.g. to 2. Drawing of status bar,
|
|
/// menues etc. is tied to the scale implied
|
|
/// by the graphics.
|
|
pub const SCREEN_MUL: i32 = 1;
|
|
|
|
/// Inverse of the aspect ratio
|
|
pub const INV_ASPECT_RATIO: f32 = 0.625; // 0.75, ideally according to the original source
|
|
|
|
/// SCREENWIDTH
|
|
/// = SCREEN_MUL*BASE_WIDTH //320
|
|
pub const SCREENWIDTH: i32 = 320;
|
|
|
|
/// SCREENHEIGHT
|
|
/// (int)(SCREEN_MUL*BASE_WIDTH*INV_ASPECT_RATIO) //200
|
|
pub const SCREENHEIGHT:i32 = 200;
|
|
|
|
|
|
/// The maximum number of players, multiplayer/networking.
|
|
pub const MAXPLAYERS: i32 = 4;
|
|
|
|
/// The number of state updates (ticks) to be done per second
|
|
pub const TICRATE: i32 = 35;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
pub enum GameMode {
|
|
Shareware,
|
|
Registered,
|
|
Retail,
|
|
Commercial,
|
|
Indetermined
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
pub enum GameState {
|
|
Level,
|
|
Intermission,
|
|
Finale,
|
|
Demoscreen,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
#[repr(i32)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum Skill {
|
|
sk_baby = 0,
|
|
sk_easy = 1,
|
|
sk_medium = 2,
|
|
sk_hard = 3,
|
|
sk_nightmare = 4
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct DoomGlobalState {
|
|
pub devparm: bool,
|
|
pub nomonsters: bool,
|
|
pub respawnparm: bool,
|
|
pub fastparm: bool,
|
|
pub drone: bool,
|
|
pub singletics: bool,
|
|
pub advancedemo: bool,
|
|
pub automapactive: bool,
|
|
pub scaledviewwidth: usize,
|
|
pub viewheight: usize,
|
|
pub inhelpscreens: bool,
|
|
pub paused: bool,
|
|
pub viewactive: bool,
|
|
pub menuactive: bool,
|
|
pub gameaction: bool,
|
|
pub usergame: bool,
|
|
pub autostart: bool,
|
|
pub demorecording: bool,
|
|
pub modifiedgame: bool,
|
|
pub deathmatch: u32,
|
|
pub language: u32,
|
|
pub singledemo: bool,
|
|
pub consoleplayer: u32,
|
|
pub maketic: u32,
|
|
|
|
// Buffers
|
|
pub wadfile: [u8; 1024],
|
|
pub mapdir: [u8; 1024],
|
|
pub basedefault: [u8; 1024],
|
|
pub title: [u8; 128],
|
|
|
|
// System State
|
|
pub gamemode: GameMode,
|
|
pub startskill: i32,
|
|
pub startepisode: i32,
|
|
pub startmap: i32,
|
|
pub wipegamestate: GameState,
|
|
pub gametic: u32,
|
|
|
|
// Lists
|
|
pub wadfiles: Vec<String>,
|
|
}
|
|
|
|
impl Default for DoomGlobalState {
|
|
fn default () -> Self {
|
|
Self {
|
|
devparm: false,
|
|
nomonsters: false,
|
|
respawnparm: false,
|
|
fastparm: false,
|
|
drone: false,
|
|
singletics: false,
|
|
advancedemo: false,
|
|
automapactive: false,
|
|
scaledviewwidth: 0,
|
|
viewheight: 0,
|
|
inhelpscreens: false,
|
|
paused: false,
|
|
viewactive: true,
|
|
menuactive: false,
|
|
gameaction: false, // ga_nothing
|
|
usergame: true,
|
|
autostart: false,
|
|
demorecording: false,
|
|
modifiedgame: false,
|
|
deathmatch: 0,
|
|
language: 0, // english
|
|
singledemo: false,
|
|
consoleplayer: 0,
|
|
maketic: 0,
|
|
wadfile: [0; 1024],
|
|
mapdir: [0; 1024],
|
|
basedefault: [0; 1024],
|
|
title: [0; 128],
|
|
gamemode: GameMode::Indetermined,
|
|
startskill: Skill::sk_medium as i32,
|
|
startepisode: 1,
|
|
startmap: 1,
|
|
wipegamestate: GameState::Demoscreen,
|
|
gametic: 0,
|
|
wadfiles: Vec::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
thread_local! {
|
|
// We promise not to be naughty and access this from another thread :)
|
|
static GLOBALS: RefCell<DoomGlobalState> = RefCell::new(DoomGlobalState::default());
|
|
}
|
|
|
|
|
|
pub struct DOOMGLOBALS;
|
|
|
|
impl DOOMGLOBALS {
|
|
/// Provides mutable access to the globals
|
|
pub fn with_mut<F, R>(f: F) -> R
|
|
where
|
|
F: FnOnce(&mut DoomGlobalState) -> R
|
|
{
|
|
GLOBALS.with(|g| f(&mut g.borrow_mut()))
|
|
}
|
|
|
|
/// Provides reference only access to the globals
|
|
pub fn with_ref<F, R>(f: F) -> R
|
|
where
|
|
F: FnOnce(&DoomGlobalState) -> R
|
|
{
|
|
GLOBALS.with(|g| f(&g.borrow()))
|
|
}
|
|
} |