Struct GameState

#[non_exhaustive]
pub struct GameState {
    pub players: Vec<Player>,
    pub buildings: BTreeMap<EntityId, Building>,
    pub projectiles: BTreeMap<EntityId, Projectile>,
    pub collisions: Vec<Collision>,
    pub world: Option<World>,
    pub kills: Vec<Kill>,
    pub tick: DemoTick,
    pub server_classes: Vec<ServerClass>,
    pub interval_per_tick: f32,
    pub outer_map: HashMap<Handle, EntityId>,
    pub events: Vec<(DemoTick, GameEvent)>,
    pub objectives: BTreeMap<EntityId, Objective>,
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

players: Vec<Player>

buildings: BTreeMap<EntityId, Building>

projectiles: BTreeMap<EntityId, Projectile>

collisions: Vec<Collision>

world: Option<World>

kills: Vec<Kill>

tick: DemoTick

server_classes: Vec<ServerClass>

interval_per_tick: f32

outer_map: HashMap<Handle, EntityId>

events: Vec<(DemoTick, GameEvent)>

objectives: BTreeMap<EntityId, Objective>

Implementations

impl GameState

pub fn get_player(&self, id: EntityId) -> Option<&Player>

pub fn get_or_create_player(&mut self, entity_id: EntityId) -> &mut Player

pub fn get_or_create_building( &mut self, entity_id: EntityId, class: BuildingClass, ) -> &mut Building

pub fn check_collision(&self, projectile: &Projectile) -> Option<&Player>

pub fn projectile_destroy(&mut self, id: EntityId)

pub fn remove_building(&mut self, entity_id: EntityId)

Trait Implementations

impl Debug for GameState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GameState

fn default() -> GameState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GameState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for GameState

fn eq(&self, other: &GameState) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for GameState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for GameState