Struct Entity 

pub struct Entity {

    pub id: u32,
    pub creator_id: Uuid,
    pub orientation: Vec2<f32>,
    pub position: Vec3<f32>,
    pub tilt: f32,
    pub action: EntityAction,
    pub attributes: ValueContainer,
    pub dirty_flags: u8,
    pub dirty_attributes: FxHashSet<String>,
    pub inventory: Vec<Option<Item>>,
    pub inventory_additions: FxHashMap<usize, Item>,
    pub inventory_removals: FxHashSet<usize>,
    pub inventory_updates: FxHashMap<usize, ItemUpdate>,
    pub equipped: IndexMap<String, Item>,
    pub wallet: Wallet,
}

The Rust representation of an Entity. The real entity class lives in Python, this class is the Rust side instantiation (to avoid unnecessary Python look ups for common attributes). The class gets synced with the Python side.

Fields

id: u32

The id of the entity in the entity manager

creator_id: Uuid

Maps the entity to a creator id

orientation: Vec2<f32>

The XZ orientation

position: Vec3<f32>

The position in the map

tilt: f32

The vertical camera tilt, 0.0 means flat, no tilt.

action: EntityAction

The current action, server side.

attributes: ValueContainer

Attributes

dirty_flags: u8

Dirty static attributes The dirty_flags field is a bitmask representing changes to various components of the entity. Each bit corresponds to a specific type of change:

• 0b00000001 (1): Position changed
• 0b00000010 (2): Orientation changed
• 0b00000100 (4): Tilt changed
• 0b00001000 (8): Inventory changed
• 0b00010000 (16): Equipped items changed
• 0b00100000 (32): Wallet changed

dirty_attributes: FxHashSet<String>

Dirty Attributes

inventory: Vec<Option<Item>>

Inventory: A container for the entity’s items

inventory_additions: FxHashMap<usize, Item>

Track added items

inventory_removals: FxHashSet<usize>

Track removed items

inventory_updates: FxHashMap<usize, ItemUpdate>

Track updated items

equipped: IndexMap<String, Item>

Equipped items

wallet: Wallet

Wallet

Implementations

impl Entity

pub fn new() -> Self

pub fn get_mode(&self) -> String

Get the entity mode.

pub fn get_pos_xz(&self) -> Vec2<f32>

Get the XZ position.

pub fn camera_look_at(&self) -> Vec3<f32>

Computes the look-at target based on position, orientation, and vertical tilt (tilt).

pub fn forward(&self) -> Vec3<f32>

A forward direction vector for the entity.

pub fn turn_left(&mut self, degrees: f32)

Rotates the entity to the left by a certain degree.

Examples found in repository

examples/map.rs (line 101)

    fn draw(&mut self, pixels: &mut [u8], ctx: &mut TheContext) {
        let _start = get_time();

        match &self.movement {
            MoveForward => {
                self.entity.move_forward(0.05);
            }
            MoveBackward => {
                self.entity.move_backward(0.05);
            }
            TurnLeft => {
                self.entity.turn_left(1.0);
            }
            TurnRight => {
                self.entity.turn_right(1.0);
            }
            Off => {}
        }
        // self.entity.apply_to_camera(&mut self.camera);

        // Set it up
        Rasterizer::setup(
            None,
            self.camera.view_matrix(),
            self.camera
                .projection_matrix(ctx.width as f32, ctx.height as f32),
        )
        .ambient(Vec4::one())
        .rasterize(
            &mut self.scene,
            pixels,     // Destination buffer
            ctx.width,  // Destination buffer width
            ctx.height, // Destination buffer height
            40,         // Tile size
            &self.assets,
        );

        let _stop = get_time();
        // println!("Execution time: {:?} ms.", _stop - _start);
    }

pub fn turn_right(&mut self, degrees: f32)

Rotates the entity to the right by a certain degree.

Examples found in repository

examples/map.rs (line 104)

    fn draw(&mut self, pixels: &mut [u8], ctx: &mut TheContext) {
        let _start = get_time();

        match &self.movement {
            MoveForward => {
                self.entity.move_forward(0.05);
            }
            MoveBackward => {
                self.entity.move_backward(0.05);
            }
            TurnLeft => {
                self.entity.turn_left(1.0);
            }
            TurnRight => {
                self.entity.turn_right(1.0);
            }
            Off => {}
        }
        // self.entity.apply_to_camera(&mut self.camera);

        // Set it up
        Rasterizer::setup(
            None,
            self.camera.view_matrix(),
            self.camera
                .projection_matrix(ctx.width as f32, ctx.height as f32),
        )
        .ambient(Vec4::one())
        .rasterize(
            &mut self.scene,
            pixels,     // Destination buffer
            ctx.width,  // Destination buffer width
            ctx.height, // Destination buffer height
            40,         // Tile size
            &self.assets,
        );

        let _stop = get_time();
        // println!("Execution time: {:?} ms.", _stop - _start);
    }

pub fn move_forward(&mut self, distance: f32)

Moves the entity forward along its current orientation.

Examples found in repository

examples/map.rs (line 95)

    fn draw(&mut self, pixels: &mut [u8], ctx: &mut TheContext) {
        let _start = get_time();

        match &self.movement {
            MoveForward => {
                self.entity.move_forward(0.05);
            }
            MoveBackward => {
                self.entity.move_backward(0.05);
            }
            TurnLeft => {
                self.entity.turn_left(1.0);
            }
            TurnRight => {
                self.entity.turn_right(1.0);
            }
            Off => {}
        }
        // self.entity.apply_to_camera(&mut self.camera);

        // Set it up
        Rasterizer::setup(
            None,
            self.camera.view_matrix(),
            self.camera
                .projection_matrix(ctx.width as f32, ctx.height as f32),
        )
        .ambient(Vec4::one())
        .rasterize(
            &mut self.scene,
            pixels,     // Destination buffer
            ctx.width,  // Destination buffer width
            ctx.height, // Destination buffer height
            40,         // Tile size
            &self.assets,
        );

        let _stop = get_time();
        // println!("Execution time: {:?} ms.", _stop - _start);
    }

pub fn move_backward(&mut self, distance: f32)

Moves the entity backward along its current orientation.

Examples found in repository

examples/map.rs (line 98)

    fn draw(&mut self, pixels: &mut [u8], ctx: &mut TheContext) {
        let _start = get_time();

        match &self.movement {
            MoveForward => {
                self.entity.move_forward(0.05);
            }
            MoveBackward => {
                self.entity.move_backward(0.05);
            }
            TurnLeft => {
                self.entity.turn_left(1.0);
            }
            TurnRight => {
                self.entity.turn_right(1.0);
            }
            Off => {}
        }
        // self.entity.apply_to_camera(&mut self.camera);

        // Set it up
        Rasterizer::setup(
            None,
            self.camera.view_matrix(),
            self.camera
                .projection_matrix(ctx.width as f32, ctx.height as f32),
        )
        .ambient(Vec4::one())
        .rasterize(
            &mut self.scene,
            pixels,     // Destination buffer
            ctx.width,  // Destination buffer width
            ctx.height, // Destination buffer height
            40,         // Tile size
            &self.assets,
        );

        let _stop = get_time();
        // println!("Execution time: {:?} ms.", _stop - _start);
    }

pub fn get_forward_pos(&mut self, distance: f32) -> Vec2<f32>

Gets the position in the direction of the entity’s orientation by a given distance.

pub fn apply_to_camera( &self, camera: &mut Box<dyn D3Camera>, firstp_eye_level: f32, )

Applies the camera’s position and look-at parameters based on the entity’s state.

pub fn set_position(&mut self, new_position: Vec3<f32>)

Set the position and mark it as dirty

pub fn set_pos_xz(&mut self, new_position: Vec2<f32>)

Set the position as a Vec2 and mark it as dirty

pub fn set_orientation(&mut self, new_orientation: Vec2<f32>)

Set the orientation and mark it as dirty

pub fn set_tilt(&mut self, new_tilt: f32)

Set the tilt and mark it as dirty

pub fn set_tilt_from_screen_coordinate(&mut self, screen_y: f32)

Maps a normalized screen coordinate (0.0 to 1.0) to a tilt angle. 0.0 -> maximum downward tilt, 1.0 -> maximum upward tilt.

Examples found in repository

examples/map.rs (line 148)

    fn hover(&mut self, x: f32, y: f32, ctx: &mut TheContext) -> bool {
        if self.camera.id() == "orbit" {
            self.camera.set_parameter_vec2(
                "from_normalized",
                Vec2::new(x / ctx.width as f32, y / ctx.height as f32),
            );
        } else if self.camera.id() == "firstp" {
            self.entity
                .set_tilt_from_screen_coordinate(1.0 - y / ctx.height as f32);
        }
        true
    }

pub fn add_item(&mut self, item: Item) -> Result<usize, String>

Add an item to the entity’s inventory and track additions

pub fn remove_item_from_slot(&mut self, slot: usize) -> Option<Item>

Remove an item from the given slot.

pub fn remove_item(&mut self, id: u32) -> Option<Item>

Remove an item from the entity’s inventory and track removals

pub fn get_item_in_slot(&self, slot: usize) -> Option<&Item>

Get a reference to an item in a given slot.

pub fn get_item_in_slot_mut(&mut self, slot: usize) -> Option<&mut Item>

Get a mutable reference to an item in a given slot.

pub fn get_item(&self, item_id: u32) -> Option<&Item>

Get a reference to an item by its ID

pub fn get_item_mut(&mut self, item_id: u32) -> Option<&mut Item>

Get a mutable reference to an item by its ID

pub fn get_item_slot(&self, item_id: u32) -> Option<usize>

Get the slot index of an item by its ID

pub fn equip_item(&mut self, item_id: u32, slot: &str) -> Result<(), String>

Equip an item into a specific slot

pub fn unequip_item(&mut self, slot: &str) -> Result<Item, String>

Unequip an item from a specific slot

pub fn get_equipped_item(&self, slot: &str) -> Option<&Item>

Get a reference of an item equipped in a specific slot

pub fn get_equipped_item_mut(&mut self, slot: &str) -> Option<&mut Item>

Get the mutable reference of an item equipped in a specific slot

pub fn add_currency( &mut self, symbol: &str, amount: i64, currencies: &Currencies, ) -> Result<(), String>

Add the given currency to the wallet.

pub fn add_base_currency( &mut self, amount: i64, currencies: &Currencies, ) -> Result<(), String>

Add the given base currency to the wallet.

pub fn spend_currency( &mut self, base_amount: i64, currencies: &Currencies, ) -> Result<(), String>

Spend the given currency.

pub fn set_attribute(&mut self, key: &str, value: Value)

Set a dynamic attribute and mark it as dirty

pub fn get_attr_string(&self, key: &str) -> Option<String>

Get the given String

pub fn get_attr_uuid(&self, key: &str) -> Option<Uuid>

Get the given Uuid

pub fn is_player(&self) -> bool

Returns true if this entity is a player

pub fn mark_dirty_attribute(&mut self, key: &str)

Mark a dynamic attribute as dirty

pub fn mark_all_dirty(&mut self)

Mark all fields and attributes as dirty.

pub fn is_dirty(&mut self) -> bool

Check if the entity is dirty and generate item updates as needed.

pub fn set_static_dirty(&mut self)

Mark all static fields as dirty

pub fn clear_dirty(&mut self)

Clear all dirty flags and attributes

pub fn get_update(&self) -> EntityUpdate

Get a partial update containing only dirty fields and attributes

pub fn apply_update(&mut self, update: EntityUpdate) -> bool

Apply an update to the entity. Returns true if the entities appearance has changed and needs to be updated.

pub fn face_east(&mut self)

Sets the orientation to face east.

pub fn face_west(&mut self)

Sets the orientation to face west.

pub fn face_north(&mut self)

Sets the orientation to face north.

pub fn face_south(&mut self)

Sets the orientation to face south.

pub fn face_at(&mut self, target: Vec2<f32>)

Sets the orientation to face a specific point.

pub fn face_random(&mut self)

Sets the orientation to face a random direction.

pub fn iter_inventory(&self) -> impl Iterator<Item = (usize, &Item)>

Create an iterator over the inventory.

pub fn iter_inventory_mut(&mut self) -> impl Iterator<Item = (usize, &mut Item)>

Create a mutable iterator over the inventory.

Trait Implementations

impl Clone for Entity

fn clone(&self) -> Entity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Entity

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

Formats the value using the given formatter.

impl Default for Entity

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Entity

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Entity

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

where __S: Serializer,

Serialize this value into the given Serde serializer.