Struct sulis_state::ActorState

pub struct ActorState {
    pub actor: Rc<Actor>,
    pub stats: StatList,
    pub listeners: ChangeListenerList<ActorState>,
    // some fields omitted
}

Fields

actor: Rc<Actor>

stats: StatList

listeners: ChangeListenerList<ActorState>

Implementations

impl ActorState

pub fn load(
    save: ActorSaveState,
    base: Option<ActorBuilder>
) -> Result<ActorState, Error>

pub fn new(actor: Rc<Actor>) -> ActorState

pub fn started_turn_with_no_ap_for_actions(&self) -> bool

pub fn add_anim_image_layers(
    &mut self,
    images: &HashMap<ImageLayer, Rc<dyn Image>>
)

pub fn remove_anim_image_layers(
    &mut self,
    images: &HashMap<ImageLayer, Rc<dyn Image>>
)

pub fn p_stats(&self) -> &PStats

pub fn is_inventory_locked(&self) -> bool

pub fn set_inventory_locked(&mut self, locked: bool)

pub fn is_threatened(&self) -> bool

pub fn add_threatening(&mut self, index: usize)

pub fn remove_threatening(&mut self, index: usize)

pub fn add_threatener(&mut self, index: usize)

pub fn remove_threatener(&mut self, index: usize)

pub fn faction(&self) -> Faction

pub fn set_faction(&mut self, faction: Faction)

pub fn clone_p_stats(&self) -> PStats

pub fn check_texture_cache_invalid(&mut self) -> bool

pub fn current_class_stat(&self, id: &str) -> ExtInt

pub fn current_uses_per_day(&self, ability_group: &str) -> ExtInt

pub fn current_uses_per_encounter(&self, ability_group: &str) -> ExtInt

pub fn ability_state(&mut self, id: &str) -> Option<&mut AbilityState>

pub fn can_swap_weapons(&self) -> bool

Returns true if the parent can swap weapons, false otherwise

pub fn can_use_quick(&self, slot: QuickSlot) -> bool

Returns true if this actor can use the item in the specified quick slot now - which includes having sufficient AP, false otherwise

pub fn can_use_sometime(&self, item_state: &ItemState) -> bool

Returns true if this actor can use the item at some point - not taking AP into consideration, false otherwise

pub fn can_use(&self, item_state: &ItemState) -> bool

Returns true if the specified item can be used now - which includes having sufficient AP, false otherwise

pub fn can_toggle(&self, id: &str) -> DisabledReason

Returns an enum with the reason the ability cannot be activted, or DisabledReason::Enabled if it can. For modes, if it can be activated or deactivated.

pub fn can_activate(&self, id: &str) -> bool

pub fn deactivate_ability_state(&mut self, id: &str)

pub fn activate_ability_state(&mut self, id: &str)

pub fn current_active_modes(&self) -> Vec<&str>

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

pub fn replace_actor(&mut self, new_actor: Actor)

pub fn draw(
    &self,
    renderer: &mut dyn GraphicsRenderer,
    offset: Offset,
    scale: Scale,
    millis: u32
)

pub fn draw_to_texture(
    &self,
    renderer: &mut dyn GraphicsRenderer,
    texture_id: &str,
    offset: Offset,
    scale: Scale
)

pub fn has_ap_to_attack(&self) -> bool

pub fn has_ap_for_any_action(&self) -> bool

#[must_use]pub fn set_quick(
    &mut self,
    item: ItemState,
    slot: QuickSlot
) -> Option<ItemState>

Sets the specified item as the item at the quick slot. Returns the item that was previously there, if it was present

#[must_use]pub fn clear_quick(&mut self, slot: QuickSlot) -> Option<ItemState>

Clears any item at the specified quick slot. Returns the item if it is present

#[must_use]pub fn equip(
    &mut self,
    item: ItemState,
    preferred_slot: Option<Slot>
) -> Vec<ItemState>

Attempts to equip the specified item to this actor's inventory. Returns a list of free items that need to be placed somewhere. If the equip action was not possible, this will include the item that was passed in. Otherwise, it will include any items that were unequipped in order to equip the new item. This will frequently be an empty list

pub fn can_equip(&self, item: &ItemState) -> bool

pub fn can_unequip(&self, _slot: Slot) -> bool

#[must_use]pub fn unequip(&mut self, slot: Slot) -> Option<ItemState>

pub fn inventory(&self) -> &Inventory

pub fn is_dead(&self) -> bool

pub fn check_death(
    parent: &Rc<RefCell<EntityState>>,
    target: &Rc<RefCell<EntityState>>
)

pub fn is_disabled(&self) -> bool

pub fn set_disabled(&mut self, disabled: bool)

pub fn has_level_up(&self) -> bool

pub fn add_xp(&mut self, xp: u32)

pub fn xp(&self) -> u32

pub fn hp(&self) -> i32

pub fn overflow_ap(&self) -> i32

pub fn ap(&self) -> u32

pub fn get_move_ap_cost(&self, squares: u32) -> u32

pub fn set_overflow_ap(&mut self, ap: i32)

pub fn change_overflow_ap(&mut self, ap: i32)

pub fn elapse_time(
    &mut self,
    millis_elapsed: u32,
    all_effects: &[Option<Effect>]
)

pub fn add_effect(&mut self, index: usize, bonuses: BonusList)

pub fn init_day(&mut self)

pub fn end_encounter(&mut self)

pub fn init_turn(&mut self)

pub fn end_turn(&mut self)

pub fn compute_stats(&mut self)