Enum screeps_api::RoomState

pub enum RoomState {
    Nonexistant,
    Closed,
    Open,
    Novice {
        end_time: Timespec,
    },
    SecondTierNovice {
        room_open_time: Timespec,
        end_time: Timespec,
    },
}

A room state, returned by room status.

Note that the API itself will return timestamps for "novice end" and "open time" even when the room is no longer novice, so the current system's knowledge of utc time is used to determine whether a room is novice or not.

Variants

Nonexistant

Room name does not exist.

Closed

Room exists and terrain has been generated, but room is completely closed.

Open

Room exists, is open, and is not part of a novice area.

Novice

Room is part of a novice area.

Fields of Novice

end_time: Timespec

The time when the novice area will expire.

SecondTierNovice

Room is part of a "second tier" novice area, which is closed, but when opened will be part of a novice area which already has other open rooms.

Fields of SecondTierNovice

room_open_time: Timespec

The time this room will open and join the surrounding novice area rooms.

end_time: Timespec

The time the novice area this room is a part of will expire.

Methods

impl RoomState

pub fn from_data(
    current_time: Timespec,
    novice_end: Option<Timespec>,
    open_time: Option<Timespec>
) -> Result<Self, ApiError>

Constructs a RoomState based off of the result from the API, and the current system time.

Note that the system time is used to determine whether the room is novice or second tier novice, because the API will only return the time that the novice area ends, and not if it is currently novice.

This is mainly for use from within other API result structures, and should never need to be used by an external user of the library.

novice_end is generally named novice in API results, open_time is openTime. Respectively, they mean the time at which the novice area at this room ends/ended, and the time at which this room opens/opened into a larger novice area from being completely inaccessible.

pub fn non_existant() -> Self

Creates a non-existant room state.

pub fn closed() -> Self

Creates a "closed" room state.

TODO: find what the server actually responds with for these rooms so we can find how to interpret them.

Trait Implementations

impl PartialEq<RoomState> for RoomState

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Clone for RoomState

fn clone(&self) -> RoomState

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Eq for RoomState

impl Copy for RoomState

impl Debug for RoomState

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

Formats the value using the given formatter.

impl Hash for RoomState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Serialize for RoomState

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

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for RoomState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.