Enum screeps::objects::Structure

pub enum Structure {
    Container(StructureContainer),
    Controller(StructureController),
    Extension(StructureExtension),
    Extractor(StructureExtractor),
    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 transfered 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)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)

Methods

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, Structure, ResourceType};

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 transfered 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_can_store_energy(&self) -> Option<&dyn CanStoreEnergy>

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 HasId for Structure

fn id(&self) -> String

impl RoomObjectProperties for Structure

fn room(&self) -> Room

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) -> Structure where
    Self: SizedRoomObject, 

impl FromExpectedType<Reference> for Structure

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

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 ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl AsRef<Reference> for Structure

fn as_ref(&self) -> &Reference

Performs the conversion.

impl From<Structure> for Reference

fn from(wrapper: Structure) -> Reference

Performs the conversion.

impl Eq for Structure

impl InstanceOf for Structure

fn instance_of(reference: &Reference) -> bool

Checks whenever a given Reference if of type Self.

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 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!