rusty_sword_arena/

game.rs

use crate::{
    gfx::{ButtonState, ButtonValue, Color, Vec2},
    timer::Timer,
    VERSION,
};

use serde::{Deserialize, Serialize};
use std::cmp::Ordering;
use std::collections::{hash_map::DefaultHasher, HashMap};
use std::fmt;
use std::hash::{Hash, Hasher};
use std::time::Duration;

/// Stateful, stack-based button processor.  You can use this to process button state/values and
/// update a `PlayerInput` that you can send to the server.  Also handles the attack button.
#[derive(Default)]
pub struct ButtonProcessor {
    horizontal: Vec<ButtonValue>,
    vertical: Vec<ButtonValue>,
}

impl ButtonProcessor {
    /// Create a new `ButtonProcessor`
    pub fn new() -> Self {
        Self {
            horizontal: Vec::new(),
            vertical: Vec::new(),
        }
    }
    /// Process one button, and update the PlayerInput accordingly. Handles movement & attack.
    pub fn process(
        &mut self,
        button_state: ButtonState,
        button_value: ButtonValue,
        player_input: &mut PlayerInput,
    ) {
        match button_state {
            ButtonState::Pressed => match button_value {
                ButtonValue::Up | ButtonValue::Down => self.vertical.push(button_value),
                ButtonValue::Left | ButtonValue::Right => self.horizontal.push(button_value),
                ButtonValue::Action1 => player_input.attack = true,
                _ => (),
            },
            ButtonState::Released => match button_value {
                ButtonValue::Up | ButtonValue::Down => self.vertical.retain(|&x| x != button_value),
                ButtonValue::Left | ButtonValue::Right => {
                    self.horizontal.retain(|&x| x != button_value)
                }
                ButtonValue::Action1 => player_input.attack = false,
                _ => (),
            },
        }
        // Set horizontal movement based on the stack
        if let Some(last_horiz) = self.horizontal.last() {
            match last_horiz {
                ButtonValue::Left => player_input.move_amount.x = -1.0,
                ButtonValue::Right => player_input.move_amount.x = 1.0,
                _ => {}
            }
        } else {
            player_input.move_amount.x = 0.0;
        }
        // Set vertical movement based on the stack
        if let Some(last_vert) = self.vertical.last() {
            match last_vert {
                ButtonValue::Up => player_input.move_amount.y = 1.0,
                ButtonValue::Down => player_input.move_amount.y = -1.0,
                _ => {}
            }
        } else {
            player_input.move_amount.y = 0.0;
        }
    }
}

/// Convenience trait that adds an `.f32()` method that returns a 32-bit float representation of
/// something.  Implemented for `std::time::Duration` and `rusty_sword_arena::timer::Timer`.
pub trait Floatable {
    fn f32(&self) -> f32;
}

impl Floatable for Duration {
    fn f32(&self) -> f32 {
        self.as_secs() as f32 + self.subsec_nanos() as f32 * 1e-9
    }
}

/// Various game control actions. Used by the networking module and the server.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub enum GameControlMsg {
    Join { name: String },
    Leave { id: u8 },
    Fetch,
}

/// The game settings.  Mostly useful if you want to try to write client-side animations that match
/// server simulation, movement prediction, AI, etc.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct GameSettings {
    /// Version number of the server you are connecting to. Compare to `rusty_sword_arena::version`
    pub version: String,
    /// The maximum amount of players this server will allow
    pub max_players: u8,
    /// How quickly a player can get moving (magnitude in OpenGL units per second^2)
    pub acceleration: f32,
    /// Maximum velocity of a player (magnitude in OpenGL units per second)
    pub max_velocity: f32,
    /// How much drag there is on movement when the player is _not_ trying to move (how quick you
    /// stop)
    pub drag: f32,
    /// Move threshold. Magnitude of Vec2 below which a move_speed will be considered 0.
    pub move_threshold: f32,
    /// Milliseconds. How long the server will wait to respawn a player who dies.
    pub respawn_delay: u64,
    /// Milliseconds. How long the server will allow not receiving input before dropping a player.
    pub drop_delay: u64,
}

impl GameSettings {
    /// Create the default game settings
    pub fn new() -> Self {
        GameSettings {
            version: VERSION.to_string(),
            max_players: 64,
            acceleration: 1.5,
            max_velocity: 0.25,
            drag: 5.0,
            move_threshold: 0.05,
            respawn_delay: 5000,
            drop_delay: 4000,
        }
    }
    /// Looking forward to the day when game settings can be changed mid-game.
    pub fn get_hash(&self) -> u64 {
        let mut hasher = DefaultHasher::new();
        self.hash(&mut hasher);
        hasher.finish()
    }
}

impl Hash for GameSettings {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.version.hash(state);
        self.max_players.hash(state);
        (self.acceleration as u32).hash(state);
        (self.drag as u32).hash(state);
        (self.move_threshold as u32).hash(state);
        self.respawn_delay.hash(state);
        self.drop_delay.hash(state);
    }
}

impl Default for GameSettings {
    fn default() -> Self {
        Self::new()
    }
}

/// A single player's score
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct Score {
    name: String,
    points: i32,
}

impl Score {
    /// Create a new score
    fn new(name: &str, points: i32) -> Self {
        Self {
            name: name.to_string(),
            points,
        }
    }
}

impl fmt::Display for Score {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:<4.0} {}", self.points, self.name)
    }
}

impl Eq for Score {}

impl Ord for Score {
    fn cmp(&self, other: &Score) -> Ordering {
        if self.points < other.points {
            Ordering::Less
        } else if self.points == other.points {
            if self.name < other.name {
                Ordering::Greater
            } else if self.name == other.name {
                Ordering::Equal
            } else {
                Ordering::Less
            }
        } else {
            Ordering::Greater
        }
    }
}

impl PartialOrd for Score {
    fn partial_cmp(&self, other: &Score) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

/// High Scores!  High scores are reset every time the server restarts, but other than that they
/// are persistent across joins/leaves.
#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
pub struct HighScores {
    pub scores: Vec<Score>,
}

impl HighScores {
    /// Create a new, blank set of high scores
    pub fn new() -> Self {
        Self {
            scores: Vec::<Score>::new(),
        }
    }
    /// Bump a player's score up by one. If the player is not present, he will be added.
    pub fn score(&mut self, name: &str) {
        self.add_player(name);
        if let Some(score) = self.scores.iter_mut().find(|x| x.name == name) {
            score.points += 1;
        }
        self.sort();
    }
    /// Decrement a player's score by one. If the player is not present, he will be added.
    pub fn penalize(&mut self, name: &str) {
        self.add_player(name);
        if let Some(score) = self.scores.iter_mut().find(|x| x.name == name) {
            score.points -= 1;
        }
        self.sort();
    }
    /// Return a clone with only the top-10 scoring players. This is what the server sends the
    /// client.
    pub fn top10(&self) -> Self {
        let mut top10 = self.clone();
        while top10.scores.len() > 10 {
            top10.scores.pop();
        }
        top10
    }
    /// Add a new player with a zero score. Used internally by both `score()` and `penalize()`
    pub fn add_player(&mut self, name: &str) {
        // Abort if we've already seen this player.
        if self.scores.iter().any(|x| x.name == name) {
            return;
        }
        self.scores.push(Score::new(name, 0));
        self.sort();
    }
    // Sort the internal score vector in the direction we want.
    fn sort(&mut self) {
        self.scores.sort_by(|a, b| b.cmp(a));
    }
}

impl fmt::Display for HighScores {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let _ = write!(f, "-----------\nHigh Scores\n-----------");
        for score in self.scores.iter() {
            let _ = write!(f, "\n{}", score);
        }
        Ok(())
    }
}

/// A player event that has happened to your player this frame!  Note that it's possible to receive
/// a whole bunch of events in the same frame.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub enum PlayerEvent {
    /// Player has attacked and hit player id.
    AttackHit { id: u8 },
    /// Player has attacked, but not hit anyone.
    AttackMiss,
    /// Player has died
    Die,
    /// Player has spawned
    Spawn,
    /// Player has received damage
    TookDamage,
    /// Player has joined the game
    Join,
}

/// A weapon a player may hold.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct Weapon {
    /// Something like "Rusty Sword", "Shiny Sword", "Rusty Spear", etc.
    pub description: String,
    /// How much damage the weapon can cause
    pub damage: f32,
    /// How long until the player can attack again
    pub attack_timer: Timer,
    /// How far attacks reach from your player, in OpenGL units.
    pub radius: f32,
}

impl Weapon {
    pub fn new() -> Self {
        Self {
            description: "Rusty Sword".to_string(),
            damage: 26.0,
            radius: 0.1,
            attack_timer: Timer::from_millis(500),
        }
    }
}

impl Default for Weapon {
    fn default() -> Self {
        Self::new()
    }
}

/// Represents the state of the player on the server for the current `GameState`.  The server always
/// creates `PlayeState`s, updates them, and sends them to the client each frame inside a
/// `GameState`. The client is free to modify its local copy (for example, to remove `PlayerEvent`s
/// it has processed) -- a new set of `PlayerState`s will be delivered the next frame. Clients
/// typically look at the fields, drain and process the player events, but don't call any of the
/// methods (since the methods are for server-side updates).  You _could_ potentially do your own
/// updates just for prediction or AI purposes, though.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct PlayerState {
    /// The ID of the player
    pub id: u8,
    /// The name of the player
    pub name: String,
    /// The color of the player
    pub color: Color,
    /// The position of the player in OpenGL units.
    pub pos: Vec2,
    /// The direction the player is facing, in radians
    pub direction: f32,
    /// Your player occupies a circle of this radius, in OpenGL units.
    pub radius: f32,
    /// Current velocity of the player
    pub velocity: Vec2,
    /// Current health of the player [0.0, 100.0]
    pub health: f32,
    // Private! No docs for you.  We use this when we respawn.
    starting_health: f32,
    /// Current weapon of the player
    pub weapon: Weapon,
    /// Any player events that have occurred to the player this frame
    pub player_events: Vec<PlayerEvent>,
    /// How long the server will wait to get input from you before disconnecting you
    pub drop_timer: Timer,
    /// How long until the player respawns.  If respawn_timer.ready == false, then the player is
    /// dead and you should seriously consider indicating that visually somehow, even if only by not
    /// displaying the player.
    pub respawn_timer: Timer,
    /// Are you dead?  Untangling health/respawn_timer dynamics is a pain, so we'll use this much
    /// more convenient boolean.
    pub dead: bool,
    /// You start dead when you join...but maybe you want to treat the joining dead differently than
    /// the properly-slain dead.
    pub joining: bool,
}

impl PlayerState {
    /// The client should never create a `PlayerState` -- the server will do that.
    pub fn new(
        game_settings: &GameSettings,
        id: u8,
        name: String,
        color: Color,
        pos: Vec2,
        radius: f32,
    ) -> Self {
        let mut respawn_timer = Timer::from_millis(game_settings.respawn_delay);
        respawn_timer.set_millis_transient(2000); // spawn more quickly on initial connect
        Self {
            id,
            name,
            color,
            pos,
            direction: 0.0,
            radius,
            velocity: Vec2::new(0., 0.),
            health: 100.0,
            starting_health: 100.0,
            weapon: Weapon::new(),
            player_events: vec![PlayerEvent::Join],
            drop_timer: Timer::from_millis(game_settings.drop_delay),
            respawn_timer,
            dead: true,
            joining: true,
        }
    }
    /// Clients never need to call update. The server calls it each time it processes some amount of
    /// time.
    pub fn update(&mut self, delta: Duration) {
        self.weapon.attack_timer.update(delta);
        self.drop_timer.update(delta);
        self.respawn_timer.update(delta);
    }
    /// Used by the server to reset things that have been taken care of last frame.
    pub fn new_frame(&mut self) {
        self.player_events.clear();
    }
    /// Used by the server when a player needs to die
    pub fn die(&mut self, msg: &str) {
        println!("{}", msg);
        self.health = -1.0;
        self.respawn_timer.reset();
        self.player_events.push(PlayerEvent::Die);
        self.dead = true;
    }
    /// Used by the server when a player needs to spawn
    pub fn respawn(&mut self, pos: Vec2, msg: &str) {
        println!("{}", msg);
        self.pos = pos;
        self.health = self.starting_health;
        self.player_events.push(PlayerEvent::Spawn);
        self.dead = false;
        self.joining = false;
    }
}

/// Once per frame, the server will broadcast a GameState to all clients.  IMPORTANT: If you don't
/// receive a GameState for 2 full seconds, the client MUST DROP its ServerConnection (or just
/// exit entirely).  The underlying networking that we're currently using hides network disconnects,
/// which can leave the networking in a funky state if one end drops.  So we need to rely on
/// detecting this heartbeat and shutting down the clients to ensure networking is clean when the
/// server restarts.  (In the future, lets switch to a protocol that can detect disconnects...)
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct GameState {
    /// Which frame we're on.  Starts at zero and increments by 1 each frame.
    pub frame_number: u64,
    /// The actual time the server measured since the previous frame.
    pub delta: Duration,
    /// The hash of the current game setting. Your client should store this somewhere. If it changes
    /// then something has changed (most likely a player has joined or disconnected), so you should
    /// get the new `GameSettings` from the server and update your client state. (Not actually a
    /// concern yet since the server hasn't implemented changing the game state).
    pub game_settings_hash: u64,
    /// All of the current player's states, including your own! **NOTE:** The only reliable method
    /// of knowing that a player is present in the game or not is whether or not a state is in
    /// player_states.  If there isn't a state, then the player has left or has been kicked/dropped.
    /// If there is a state, then the player is in the game (and might have joined since the last
    /// GameState was sent).
    pub player_states: HashMap<u8, PlayerState>,
    /// High scores. The server will only send the top 10.
    pub high_scores: HighScores,
}
/// Clients should send `PlayerInput`s to the server often.  The quicker the server gets inputs, the
/// more accurate the simulation will be.  But of course, you also shouldn't overload the server
/// with too much traffic, because that's bad too.  Good rule of thumb: Coalesce 15 milliseconds
/// worth of input together, and send that.  That's just faster than frames are sent by the
/// server (60fps = 16.7ms).  The server should be able to handle ~67 pkts/sec per client.  I hope.
///
/// `PlayerInput` is used to collect input into and send it to the server.  You
/// can use the [angle_between](game/struct.Vec2.html#method.angle_between) method of a
/// Vec2 to find the direction for the input based off of the position in your own player's
/// [PlayerState](game/struct.PlayerState.html) and the current position of the mouse,
/// which you get from one of the [game events](../gfx/struct.Window.html#method.poll_game_events)
///
/// Note that `attack` is an indicator of whether the player is currently (still) attempting to
/// attack. The server will only attack once every once-in-awhile when the weapon's attack timer
/// is ready, so you probably want to keep attack on while an attack button is held down, and
/// then switch attack off when the attack button is released.
///
/// It's pretty safe to just overwrite move_amount and direction with the latest input you've got.
/// Direction handling is instantaneous, and the move_amount is treated like a force (you move with
/// a bit of inertia).
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct PlayerInput {
    /// The ID of your player
    pub id: u8,
    /// Whether you are attempting to attack (actual attack will occur if the server-side attack
    /// timer has reached 0)
    pub attack: bool,
    /// How much your player is attempting to move horizontally (x) and vertically (y) [-1.0, 1.0].
    /// Positive is right and up for x and y, respectively.  You can derive movement amounts from
    /// `Button` variants of the `GameEvent`s you get from the `Window.poll_game_events()`.
    pub move_amount: Vec2,
    /// What direction your player is facing. You can turn instantly, you lucky dog.
    pub direction: f32,
}

impl Default for PlayerInput {
    fn default() -> Self {
        Self {
            id: 0,
            attack: false,
            move_amount: Vec2::zeros(),
            direction: 0.0,
        }
    }
}

impl PlayerInput {
    /// Create a new PlayerInput
    pub fn with_id(id: u8) -> Self {
        Self {
            id,
            attack: false,
            move_amount: Vec2::zeros(),
            direction: 0.0,
        }
    }
    /// Used by the server. Unlikely to be used by the client.
    pub fn coalesce(&mut self, new: PlayerInput) {
        // Any attack sticks
        self.attack = self.attack || new.attack;
        // Anything else the new value wins
        self.move_amount = new.move_amount;
        self.direction = new.direction;
    }
}