Struct Unit 

pub struct Unit { /* private fields */ }

A struct represents a character or other interactive item in a game scene.

Implementations

impl Unit

pub fn set_playable(&mut self, val: &dyn IPlayable)

Sets the property that references a “Playable” object for managing the animation state and playback of the “Unit”.

pub fn get_playable(&self) -> Playable

Gets the property that references a “Playable” object for managing the animation state and playback of the “Unit”.

pub fn set_detect_distance(&mut self, val: f32)

Sets the property that specifies the maximum distance at which the “Unit” can detect other “Unit” or objects.

pub fn get_detect_distance(&self) -> f32

Gets the property that specifies the maximum distance at which the “Unit” can detect other “Unit” or objects.

pub fn set_attack_range(&mut self, val: &Size)

Sets the property that specifies the size of the attack range for the “Unit”.

pub fn get_attack_range(&self) -> Size

Gets the property that specifies the size of the attack range for the “Unit”.

pub fn set_face_right(&mut self, val: bool)

Sets the boolean property that specifies whether the “Unit” is facing right or not.

pub fn is_face_right(&self) -> bool

Gets the boolean property that specifies whether the “Unit” is facing right or not.

pub fn set_receiving_decision_trace(&mut self, val: bool)

Sets the boolean property that specifies whether the “Unit” is receiving a trace of the decision tree for debugging purposes.

pub fn is_receiving_decision_trace(&self) -> bool

Gets the boolean property that specifies whether the “Unit” is receiving a trace of the decision tree for debugging purposes.

pub fn set_decision_tree(&mut self, val: &str)

Sets the string property that specifies the decision tree to use for the “Unit’s” AI behavior. the decision tree object will be searched in The singleton instance Data.store.

pub fn get_decision_tree(&self) -> String

Gets the string property that specifies the decision tree to use for the “Unit’s” AI behavior. the decision tree object will be searched in The singleton instance Data.store.

pub fn is_on_surface(&self) -> bool

Gets whether the “Unit” is currently on a surface or not.

pub fn get_ground_sensor(&self) -> Sensor

Gets the “Sensor” object for detecting ground surfaces.

pub fn get_detect_sensor(&self) -> Sensor

Gets the “Sensor” object for detecting other “Unit” objects or physics bodies in the game world.

pub fn get_attack_sensor(&self) -> Sensor

Gets the “Sensor” object for detecting other “Unit” objects within the attack senser area.

pub fn get_unit_def(&self) -> Dictionary

Gets the “Dictionary” object for defining the properties and behavior of the “Unit”.

pub fn get_current_action(&self) -> UnitAction

Gets the property that specifies the current action being performed by the “Unit”.

pub fn get_width(&self) -> f32

Gets the width of the “Unit”.

pub fn get_height(&self) -> f32

Gets the height of the “Unit”.

pub fn get_entity(&self) -> Entity

Gets the “Entity” object for representing the “Unit” in the ECS system.

pub fn attach_action(&mut self, name: &str) -> UnitAction

Adds a new UnitAction to the Unit with the specified name, and returns the new UnitAction.

Arguments

• name - The name of the new UnitAction.

Returns

• The newly created UnitAction.

pub fn remove_action(&mut self, name: &str)

Removes the UnitAction with the specified name from the Unit.

Arguments

• name - The name of the UnitAction to remove.

pub fn remove_all_actions(&mut self)

Removes all “UnitAction” objects from the “Unit”.

pub fn get_action(&mut self, name: &str) -> Option<UnitAction>

Returns the UnitAction with the specified name, or None if the UnitAction does not exist.

Arguments

• name - The name of the UnitAction to retrieve.

Returns

• The UnitAction with the specified name, or None.

pub fn each_action(&mut self, visitor_func: Box<dyn FnMut(&UnitAction)>)

Calls the specified function for each UnitAction attached to the Unit.

Arguments

• visitorFunc - A function to call for each UnitAction.

pub fn start(&mut self, name: &str) -> bool

Starts the UnitAction with the specified name, and returns true if the UnitAction was started successfully.

Arguments

• name - The name of the UnitAction to start.

Returns

• true if the UnitAction was started successfully, false otherwise.

pub fn stop(&mut self)

Stops the currently running “UnitAction”.

pub fn is_doing(&mut self, name: &str) -> bool

Returns true if the Unit is currently performing the specified UnitAction, false otherwise.

Arguments

• name - The name of the UnitAction to check.

Returns

• true if the Unit is currently performing the specified UnitAction, false otherwise.

pub fn new( unit_def: &Dictionary, physics_world: &dyn IPhysicsWorld, entity: &Entity, pos: &Vec2, rot: f32, ) -> Unit

A method that creates a new Unit object.

Arguments

• unit_def - A Dictionary object that defines the properties and behavior of the Unit.
• physics_world - A PhysicsWorld object that represents the physics simulation world.
• entity - An Entity object that represents the Unit in ECS system.
• pos - A Vec2 object that specifies the initial position of the Unit.
• rot - A number that specifies the initial rotation of the Unit.

Returns

• The newly created Unit object.

pub fn with_store( unit_def_name: &str, physics_world_name: &str, entity: &Entity, pos: &Vec2, rot: f32, ) -> Unit

A method that creates a new Unit object.

Arguments

• unit_def_name - A string that specifies the name of the Unit definition to retrieve from Data.store table.
• physics_world_name - A string that specifies the name of the PhysicsWorld object to retrieve from Data.store table.
• entity - An Entity object that represents the Unit in ECS system.
• pos - A Vec2 object that specifies the initial position of the Unit.
• rot - An optional number that specifies the initial rotation of the Unit (default is 0.0).

Returns

• The newly created Unit object.

Trait Implementations

impl Clone for Unit

fn clone(&self) -> Unit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Drop for Unit

fn drop(&mut self)

Executes the destructor for this type.

impl IBody for Unit

fn get_world(&self) -> PhysicsWorld

Gets the physics world that the body belongs to.

fn get_body_def(&self) -> BodyDef

Gets the definition of the body.

fn get_mass(&self) -> f32

Gets the mass of the body.

fn is_sensor(&self) -> bool

Gets whether the body is used as a sensor or not.

fn set_velocity_x(&mut self, val: f32)

Sets the x-axis velocity of the body.

fn get_velocity_x(&self) -> f32

Gets the x-axis velocity of the body.

fn set_velocity_y(&mut self, val: f32)

Sets the y-axis velocity of the body.

fn get_velocity_y(&self) -> f32

Gets the y-axis velocity of the body.

fn set_velocity(&mut self, val: &Vec2)

Sets the velocity of the body as a Vec2.

fn get_velocity(&self) -> Vec2

Gets the velocity of the body as a Vec2.

fn set_angular_rate(&mut self, val: f32)

Sets the angular rate of the body.

fn get_angular_rate(&self) -> f32

Gets the angular rate of the body.

fn set_group(&mut self, val: i32)

Sets the collision group that the body belongs to.

fn get_group(&self) -> i32

Gets the collision group that the body belongs to.

fn set_linear_damping(&mut self, val: f32)

Sets the linear damping of the body.

fn get_linear_damping(&self) -> f32

Gets the linear damping of the body.

fn set_angular_damping(&mut self, val: f32)

Sets the angular damping of the body.

fn get_angular_damping(&self) -> f32

Gets the angular damping of the body.

fn set_owner(&mut self, val: &dyn IObject)

Sets the reference for an owner of the body.

fn get_owner(&self) -> Object

Gets the reference for an owner of the body.

fn set_receiving_contact(&mut self, val: bool)

Sets whether the body is currently receiving contact events or not.

fn is_receiving_contact(&self) -> bool

Gets whether the body is currently receiving contact events or not.

fn apply_linear_impulse(&mut self, impulse: &Vec2, pos: &Vec2)

Applies a linear impulse to the body at a specified position.

fn apply_angular_impulse(&mut self, impulse: f32)

Applies an angular impulse to the body.

fn get_sensor_by_tag(&mut self, tag: i32) -> Sensor

Returns the sensor with the given tag.

fn remove_sensor_by_tag(&mut self, tag: i32) -> bool

Removes the sensor with the specified tag from the body.

fn remove_sensor(&mut self, sensor: &Sensor) -> bool

Removes the given sensor from the body’s sensor list.

fn attach(&mut self, fixture_def: &FixtureDef)

Attaches a fixture to the body.

fn attach_sensor(&mut self, tag: i32, fixture_def: &FixtureDef) -> Sensor

Attaches a new sensor with the given tag and fixture definition to the body.

fn on_contact_filter(&mut self, filter: Box<dyn FnMut(&dyn IBody) -> bool>)

Registers a function to be called when the body begins to receive contact events. Return false from this function to prevent colliding.

impl INode for Unit

fn set_order(&mut self, val: i32)

Sets the order of the node in the parent’s children array.

fn get_order(&self) -> i32

Gets the order of the node in the parent’s children array.

fn set_angle(&mut self, val: f32)

Sets the rotation angle of the node in degrees.

fn get_angle(&self) -> f32

Gets the rotation angle of the node in degrees.

fn set_angle_x(&mut self, val: f32)

Sets the X-axis rotation angle of the node in degrees.

fn get_angle_x(&self) -> f32

Gets the X-axis rotation angle of the node in degrees.

fn set_angle_y(&mut self, val: f32)

Sets the Y-axis rotation angle of the node in degrees.

fn get_angle_y(&self) -> f32

Gets the Y-axis rotation angle of the node in degrees.

fn set_scale_x(&mut self, val: f32)

Sets the X-axis scale factor of the node.

fn get_scale_x(&self) -> f32

Gets the X-axis scale factor of the node.

fn set_scale_y(&mut self, val: f32)

Sets the Y-axis scale factor of the node.

fn get_scale_y(&self) -> f32

Gets the Y-axis scale factor of the node.

fn set_x(&mut self, val: f32)

Sets the X-axis position of the node.

fn get_x(&self) -> f32

Gets the X-axis position of the node.

fn set_y(&mut self, val: f32)

Sets the Y-axis position of the node.

fn get_y(&self) -> f32

Gets the Y-axis position of the node.

fn set_z(&mut self, val: f32)

Sets the Z-axis position of the node.

fn get_z(&self) -> f32

Gets the Z-axis position of the node.

fn set_position(&mut self, val: &Vec2)

Sets the position of the node as a Vec2 object.

fn get_position(&self) -> Vec2

Gets the position of the node as a Vec2 object.

fn set_skew_x(&mut self, val: f32)

Sets the X-axis skew angle of the node in degrees.

fn get_skew_x(&self) -> f32

Gets the X-axis skew angle of the node in degrees.

fn set_skew_y(&mut self, val: f32)

Sets the Y-axis skew angle of the node in degrees.

fn get_skew_y(&self) -> f32

Gets the Y-axis skew angle of the node in degrees.

fn set_visible(&mut self, val: bool)

Sets whether the node is visible.

fn is_visible(&self) -> bool

Gets whether the node is visible.

fn set_anchor(&mut self, val: &Vec2)

Sets the anchor point of the node as a Vec2 object.

fn get_anchor(&self) -> Vec2

Gets the anchor point of the node as a Vec2 object.

fn set_width(&mut self, val: f32)

Sets the width of the node.

fn get_width(&self) -> f32

Gets the width of the node.

fn set_height(&mut self, val: f32)

Sets the height of the node.

fn get_height(&self) -> f32

Gets the height of the node.

fn set_size(&mut self, val: &Size)

Sets the size of the node as a Size object.

fn get_size(&self) -> Size

Gets the size of the node as a Size object.

fn set_tag(&mut self, val: &str)

Sets the tag of the node as a string.

fn get_tag(&self) -> String

Gets the tag of the node as a string.

fn set_opacity(&mut self, val: f32)

Sets the opacity of the node, should be 0 to 1.0.

fn get_opacity(&self) -> f32

Gets the opacity of the node, should be 0 to 1.0.

fn set_color(&mut self, val: &Color)

Sets the color of the node as a Color object.

fn get_color(&self) -> Color

Gets the color of the node as a Color object.

fn set_color3(&mut self, val: &Color3)

Sets the color of the node as a Color3 object.

fn get_color3(&self) -> Color3

Gets the color of the node as a Color3 object.

fn set_pass_opacity(&mut self, val: bool)

Sets whether to pass the opacity value to child nodes.

fn is_pass_opacity(&self) -> bool

Gets whether to pass the opacity value to child nodes.

fn set_pass_color3(&mut self, val: bool)

Sets whether to pass the color value to child nodes.

fn is_pass_color3(&self) -> bool

Gets whether to pass the color value to child nodes.

fn set_transform_target(&mut self, val: &dyn INode)

Sets the target node acts as a parent node for transforming this node.

fn get_transform_target(&self) -> Option<Node>

Gets the target node acts as a parent node for transforming this node.

fn set_scheduler(&mut self, val: &Scheduler)

Sets the scheduler used for scheduling update and action callbacks.

fn get_scheduler(&self) -> Scheduler

Gets the scheduler used for scheduling update and action callbacks.

fn get_children(&self) -> Option<Array>

Gets the children of the node as an Array object, could be None.

fn get_parent(&self) -> Option<Node>

Gets the parent of the node, could be None.

fn is_running(&self) -> bool

Gets whether the node is currently running in a scene tree.

fn is_scheduled(&self) -> bool

Gets whether the node is currently scheduling a function for updates.

fn get_action_count(&self) -> i32

Gets the number of actions currently running on the node.

fn get_data(&self) -> Dictionary

Gets additional data stored on the node as a Dictionary object.

fn set_touch_enabled(&mut self, val: bool)

Sets whether touch events are enabled on the node.

fn is_touch_enabled(&self) -> bool

Gets whether touch events are enabled on the node.

fn set_swallow_touches(&mut self, val: bool)

Sets whether the node should swallow touch events.

fn is_swallow_touches(&self) -> bool

Gets whether the node should swallow touch events.

fn set_swallow_mouse_wheel(&mut self, val: bool)

Sets whether the node should swallow mouse wheel events.

fn is_swallow_mouse_wheel(&self) -> bool

Gets whether the node should swallow mouse wheel events.

fn set_keyboard_enabled(&mut self, val: bool)

Sets whether keyboard events are enabled on the node.

fn is_keyboard_enabled(&self) -> bool

Gets whether keyboard events are enabled on the node.

fn set_controller_enabled(&mut self, val: bool)

Sets whether controller events are enabled on the node.

fn is_controller_enabled(&self) -> bool

Gets whether controller events are enabled on the node.

fn set_render_group(&mut self, val: bool)

Sets whether to group the node’s rendering with all its recursive children.

fn is_render_group(&self) -> bool

Gets whether to group the node’s rendering with all its recursive children.

fn set_show_debug(&mut self, val: bool)

Sets whether debug graphic should be displayed for the node.

fn is_show_debug(&self) -> bool

Gets whether debug graphic should be displayed for the node.

fn set_render_order(&mut self, val: i32)

Sets the rendering order number for group rendering. Nodes with lower rendering orders are rendered earlier.

fn get_render_order(&self) -> i32

Gets the rendering order number for group rendering. Nodes with lower rendering orders are rendered earlier.

fn add_child_with_order_tag(&mut self, child: &dyn INode, order: i32, tag: &str)

Adds a child node to the current node.

fn add_child_with_order(&mut self, child: &dyn INode, order: i32)

Adds a child node to the current node.

fn add_child(&mut self, child: &dyn INode)

Adds a child node to the current node.

fn add_to_with_order_tag( &mut self, parent: &dyn INode, order: i32, tag: &str, ) -> Node

Adds the current node to a parent node.

fn add_to_with_order(&mut self, parent: &dyn INode, order: i32) -> Node

Adds the current node to a parent node.

fn add_to(&mut self, parent: &dyn INode) -> Node

Adds the current node to a parent node.

fn remove_child(&mut self, child: &dyn INode, cleanup: bool)

Removes a child node from the current node.

fn remove_child_by_tag(&mut self, tag: &str, cleanup: bool)

Removes a child node from the current node by tag.

fn remove_all_children(&mut self, cleanup: bool)

Removes all child nodes from the current node.

fn remove_from_parent(&mut self, cleanup: bool)

Removes the current node from its parent node.

fn move_to_parent(&mut self, parent: &dyn INode)

Moves the current node to a new parent node without triggering node events.

fn cleanup(&mut self)

Cleans up the current node.

fn get_child_by_tag(&mut self, tag: &str) -> Option<Node>

Gets a child node by tag.

fn schedule(&mut self, update_func: Box<dyn FnMut(f64) -> bool>)

Schedules a main function to run every frame. Call this function again to replace the previous scheduled main function or coroutine.

fn unschedule(&mut self)

Unschedules the current node’s scheduled main function.

fn convert_to_node_space(&mut self, world_point: &Vec2) -> Vec2

Converts a point from world space to node space.

fn convert_to_world_space(&mut self, node_point: &Vec2) -> Vec2

Converts a point from node space to world space.

fn convert_to_window_space( &mut self, node_point: &Vec2, callback: Box<dyn FnMut(&Vec2)>, )

Converts a point from node space to world space.

fn each_child( &mut self, visitor_func: Box<dyn FnMut(&dyn INode) -> bool>, ) -> bool

Calls the given function for each child node of this node.

fn traverse(&mut self, visitor_func: Box<dyn FnMut(&dyn INode) -> bool>) -> bool

Traverses the node hierarchy starting from this node and calls the given function for each visited node. The nodes without TraverseEnabled flag are not visited.

fn traverse_all( &mut self, visitor_func: Box<dyn FnMut(&dyn INode) -> bool>, ) -> bool

Traverses the entire node hierarchy starting from this node and calls the given function for each visited node.

fn run_action_def(&mut self, def: ActionDef, looped: bool) -> f32

Runs an action defined by the given action definition on this node.

fn run_action(&mut self, action: &Action, looped: bool) -> f32

Runs an action on this node.

fn stop_all_actions(&mut self)

Stops all actions running on this node.

fn perform_def(&mut self, action_def: ActionDef, looped: bool) -> f32

Runs an action defined by the given action definition right after clearing all the previous running actions.

fn perform(&mut self, action: &Action, looped: bool) -> f32

Runs an action on this node right after clearing all the previous running actions.

fn stop_action(&mut self, action: &Action)

Stops the given action running on this node.

fn align_items_vertically(&mut self, padding: f32) -> Size

Vertically aligns all child nodes within the node using the given size and padding.

fn align_items_vertically_with_size( &mut self, size: &Size, padding: f32, ) -> Size

Vertically aligns all child nodes within the node using the given size and padding.

fn align_items_horizontally(&mut self, padding: f32) -> Size

Horizontally aligns all child nodes within the node using the given size and padding.

fn align_items_horizontally_with_size( &mut self, size: &Size, padding: f32, ) -> Size

Horizontally aligns all child nodes within the node using the given size and padding.

fn align_items(&mut self, padding: f32) -> Size

Aligns all child nodes within the node using the given size and padding.

fn align_items_with_size(&mut self, size: &Size, padding: f32) -> Size

Aligns all child nodes within the node using the given size and padding.

fn move_and_cull_items(&mut self, delta: &Vec2)

Moves and changes child nodes’ visibility based on their position in parent’s area.

fn attach_ime(&mut self)

Attaches the input method editor (IME) to the node. Makes node recieving “AttachIME”, “DetachIME”, “TextInput”, “TextEditing” events.

fn detach_ime(&mut self)

Detaches the input method editor (IME) from the node.

fn grab(&mut self) -> Grabber

Creates a texture grabber for the specified node.

fn grab_with_size(&mut self, grid_x: i32, grid_y: i32) -> Grabber

Creates a texture grabber for the specified node with a specified grid size.

fn stop_grab(&mut self)

Removes the texture grabber for the specified node.

fn set_transform_target_null(&mut self)

Removes the transform target for the specified node.

fn slot(&mut self, event_name: &str, handler: Box<dyn FnMut(&mut CallStack)>)

Associates the given handler function with the node event.

fn gslot(&mut self, event_name: &str, handler: Box<dyn FnMut(&mut CallStack)>)

Associates the given handler function with a global event.

fn emit(&mut self, name: &str, stack: &CallStack)

Emits an event to a node, triggering the event handler associated with the event name.

fn on_update(&mut self, update_func: Box<dyn FnMut(f64) -> bool>)

Schedules a function to run every frame. Call this function again to schedule multiple functions.

fn on_render(&mut self, render_func: Box<dyn FnMut(f64) -> bool>)

Registers a callback for event triggered when the node is entering the rendering phase. The callback is called every frame, and ensures that its call order is consistent with the rendering order of the scene tree, such as rendering child nodes after their parent nodes. Recommended for calling vector drawing functions.

impl IObject for Unit

fn raw(&self) -> i64

fn obj(&self) -> &dyn IObject

fn as_any(&self) -> &dyn Any

fn get_id(&self) -> i32