Enum screeps::objects::Structure

pub enum Structure {
    Container(StructureContainer),
    Controller(StructureController),
    Extension(StructureExtension),
    Extractor(StructureExtractor),
    Factory(StructureFactory),
    InvaderCore(StructureInvaderCore),
    KeeperLair(StructureKeeperLair),
    Lab(StructureLab),
    Link(StructureLink),
    Nuker(StructureNuker),
    Observer(StructureObserver),
    PowerBank(StructurePowerBank),
    PowerSpawn(StructurePowerSpawn),
    Portal(StructurePortal),
    Rampart(StructureRampart),
    Road(StructureRoad),
    Spawn(StructureSpawn),
    Storage(StructureStorage),
    Terminal(StructureTerminal),
    Tower(StructureTower),
    Wall(StructureWall),
}

Wrapper which can be any of the game Structures.

This is somewhat useful by itself, but has additional utility methods. Some tricks:

To get a particular type, match on the structure:

use screeps::Structure;

match my_struct {
    Structure::Container(cont) => {
        // cont here is StructureContainer
    }
    _ => {
        // other structure
    }
}

To use structures of a particular type, like something that can be attacked, or something that can be transferred to, use helper methods:

use screeps::Structure;

match my_struct.as_transferable() {
    Some(transf) => {
        // transf is a reference to `dyn Transferable`, and you can transfer to it.
    }
    None => {
        // my_struct is not transferable
    }
}

See method documentation for a full list of possible helpers.

Variants

Container(StructureContainer)

Controller(StructureController)

Extension(StructureExtension)

Extractor(StructureExtractor)

Factory(StructureFactory)

InvaderCore(StructureInvaderCore)

KeeperLair(StructureKeeperLair)

Lab(StructureLab)

Link(StructureLink)

Nuker(StructureNuker)

Observer(StructureObserver)

PowerBank(StructurePowerBank)

PowerSpawn(StructurePowerSpawn)

Portal(StructurePortal)

Rampart(StructureRampart)

Road(StructureRoad)

Spawn(StructureSpawn)

Storage(StructureStorage)

Terminal(StructureTerminal)

Tower(StructureTower)

Wall(StructureWall)

Implementations

impl Structure

pub fn as_transferable(&self) -> Option<&dyn Transferable>

Cast this structure as something Transferable, or return None if it isn’t.

Example usage:

use screeps::{Creep, ResourceType, Structure};

match my_struct.as_transferable() {
    Some(transf) => {
        // transf is a reference to `dyn Transferable`, and you can transfer to it.
        my_creep.transfer_all(transf, ResourceType::Energy);
    }
    None => {
        // my_struct cannot be transferred to
    }
}

pub fn as_withdrawable(&self) -> Option<&dyn Withdrawable>

Cast this as something which can be withdrawn from

pub fn as_attackable(&self) -> Option<&dyn Attackable>

Cast this as something which can be attacked and has hit points.

The only Structure which cannot be attacked is StructureController.

pub fn as_owned(&self) -> Option<&dyn OwnedStructureProperties>

Cast this as something which can be owned.

Example:

use screeps::Structure;

let is_my = my_struct.as_owned().map(|os| os.my()).unwrap_or(false);

pub fn as_can_decay(&self) -> Option<&dyn CanDecay>

pub fn as_has_cooldown(&self) -> Option<&dyn HasCooldown>

pub fn as_has_energy_for_spawn(&self) -> Option<&dyn HasEnergyForSpawn>

pub fn as_has_store(&self) -> Option<&dyn HasStore>

Trait Implementations

impl AsRef<Reference> for Structure

fn as_ref(&self) -> &Reference

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Structure

fn clone(&self) -> Structure

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<Structure> for Reference

fn from(wrapper: Structure) -> Reference

Converts to this type from the input type.

impl FromExpectedType<Reference> for Structure

fn from_expected_type(reference: Reference) -> Result<Self, ConversionError>

impl HasId for Structure

fn untyped_id(&self) -> RawObjectId

Retrieves this object’s id as an untyped, packed value.

fn id(&self) -> ObjectId<Self>where
    Self: Sized,

Retrieves this object’s id as a typed, packed value.

impl InstanceOf for Structure

fn instance_of(reference: &Reference) -> bool

Checks whenever a given Reference if of type Self.

impl PartialEq<Structure> for Structure

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

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

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

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

impl ReferenceType for Structure

unsafe fn from_reference_unchecked(reference: Reference) -> Self

Converts a given reference into a concrete reference-like wrapper. Doesn’t do any type checking; highly unsafe to use!

impl RoomObjectProperties for Structure

fn room(&self) -> Option<Room>

The room that the object is in, or None if an object is a flag or a construction site and is placed in a room that is not visible to you.

fn effects(&self) -> Vec<Effect>

impl StructureProperties for Structure

fn structure_type(&self) -> StructureType

fn destroy(&self) -> ReturnCode

fn is_active(&self) -> bool

fn notify_when_attacked(&self, notify_when_attacked: bool) -> ReturnCode

Usable on either owned structures or neutral structures in owned rooms, returns ReturnCode::NotOwner otherwise.

fn as_structure(self) -> Structurewhere
    Self: SizedRoomObject,

impl TryFrom<Reference> for Structure

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(reference: Reference) -> Result<Self, ConversionError>

Performs the conversion.

impl TryFrom<Value> for Structure

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(v: Value) -> Result<Structure, Self::Error>

Performs the conversion.

impl Eq for Structure