Struct InstanceRef

pub struct InstanceRef<'a> {
    pub entity: &'a EntityInstance,
}

Fields

entity: &'a EntityInstance

Implementations

impl<'a> InstanceRef<'a>

pub fn x(&self) -> i64

Get the leftmost pixel of this entity’s anchor point

pub fn y(&self) -> i64

Get the topmost pixel of this entity’s anchor point

pub fn width(&self) -> i64

Get the pixel width of this entity

pub fn height(&self) -> i64

Get the pixel width of this entity

pub fn get_type(&self) -> &'a String

Get the category that this instance belongs to. Exactly matches the string name found in the LDTK entities list

pub fn try_get_typed_id<T: FromStr>(&self) -> Result<T, T::Err>

Try to get a type safe representation of this entity’s type, as long as the target type can be produced from a str representation

Example

#[derive(PartialEq, Debug)]
enum MyEntityType {
    Player,
    Monster,
}

impl FromStr for MyEntityType {
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "player" => Ok(Self::Player),
            "monster" => Ok(Self::Monster),
        }
    }
}

let data_from_ldtk: EntityInstance = EntityInstance {
    identifier: "player".to_string(),
    // ...other properties
};

let my_entity_type: InstanceRef<'_> = process_ldtk_data();
assert_eq!(my_entity_type.try_get_typed_id(), Ok(MyEntityType::Player));

pub fn property(&self, name: impl ToString) -> Value

Retrieve an associated property from this instance. Will return serde_json::Value::Null if there is no property with the given name

pub fn instance_ref(&self) -> &EntityInstance

Get a reference to the inner instance of this instance ref

Trait Implementations

impl<'a> Clone for InstanceRef<'a>

fn clone(&self) -> InstanceRef<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ToString> Index<T> for InstanceRef<'_>

type Output = Value

The returned type after indexing.

fn index(&self, index: T) -> &Self::Output

Performs the indexing (container[index]) operation.