Enum veloren_common::comp::character_state::CharacterState

pub enum CharacterState {
    Idle(Data),
    Climb(Data),
    Sit,
    Dance,
    Talk,
    Pet(Data),
    Glide(Data),
    GlideWield(Data),
    Stunned(Data),
    BasicBlock(Data),
    Equipping(Data),
    Wielding(Data),
    Roll(Data),
    BasicMelee(Data),
    BasicRanged(Data),
    Boost(Data),
    DashMelee(Data),
    ComboMelee2(Data),
    LeapMelee(Data),
    LeapShockwave(Data),
    ChargedRanged(Data),
    ChargedMelee(Data),
    RepeaterRanged(Data),
    Shockwave(Data),
    BasicBeam(Data),
    BasicAura(Data),
    StaticAura(Data),
    Blink(Data),
    BasicSummon(Data),
    SelfBuff(Data),
    SpriteSummon(Data),
    UseItem(Data),
    SpriteInteract(Data),
    Wallrun(Data),
    Skate(Data),
    Music(Data),
    FinisherMelee(Data),
    DiveMelee(Data),
    RiposteMelee(Data),
    RapidMelee(Data),
    Transform(Data),
    RegrowHead(Data),
}

Variants

Idle(Data)

Climb(Data)

Sit

Dance

Talk

Pet(Data)

Glide(Data)

GlideWield(Data)

Stunned(Data)

A stunned state

BasicBlock(Data)

A basic blocking state

Equipping(Data)

Player is busy equipping or unequipping weapons

Wielding(Data)

Player is holding a weapon and can perform other actions

Roll(Data)

A dodge where player can roll

BasicMelee(Data)

A basic melee attack (e.g. sword)

BasicRanged(Data)

A basic ranged attack (e.g. bow)

Boost(Data)

A force will boost you into a direction for some duration

DashMelee(Data)

Dash forward and then attack

ComboMelee2(Data)

A state where you progress through multiple melee attacks

LeapMelee(Data)

A leap followed by a small aoe ground attack

LeapShockwave(Data)

A leap followed by a shockwave

ChargedRanged(Data)

A charged ranged attack (e.g. bow)

ChargedMelee(Data)

A charged melee attack

RepeaterRanged(Data)

A repeating ranged attack

Shockwave(Data)

A ground shockwave attack

BasicBeam(Data)

A continuous attack that affects all creatures in a cone originating from the source

BasicAura(Data)

Creates an aura that persists as long as you are actively casting

StaticAura(Data)

Creates an aura that is attached to a pseudo entity, so it doesn’t move with you Optionally allows for sprites to be created as well

Blink(Data)

A short teleport that targets either a position or entity

BasicSummon(Data)

Summons creatures that fight for the caster

SelfBuff(Data)

Inserts a buff on the caster

SpriteSummon(Data)

Creates sprites around the caster

UseItem(Data)

Handles logic for using an item so it is not simply instant

SpriteInteract(Data)

Handles logic for interacting with a sprite, e.g. using a chest or picking a plant

Wallrun(Data)

Runs on the wall

Skate(Data)

Ice skating or skiing

Music(Data)

Play music instrument

FinisherMelee(Data)

Melee attack that scales off and consumes combo

DiveMelee(Data)

State entered when diving, melee attack triggered upon landing on the ground

RiposteMelee(Data)

Attack that attempts to parry, and if it parries moves to an attack

RapidMelee(Data)

A series of consecutive, identical attacks that only go through buildup and recover once for the entire state

Transform(Data)

Transforms an entity into another

RegrowHead(Data)

Regrow a missing head

Implementations

impl CharacterState

pub fn is_wield(&self) -> bool

pub fn was_wielded(&self) -> bool

pub fn is_glide_wielded(&self) -> bool

pub fn is_stealthy(&self) -> bool

pub fn should_follow_look(&self) -> bool

pub fn is_attack(&self) -> bool

pub fn is_aimed(&self) -> bool

pub fn is_using_hands(&self) -> bool

pub fn is_parry(&self, attack_source: AttackSource) -> bool

pub fn is_block(&self, attack_source: AttackSource) -> bool

pub fn block_angle(&self) -> f32

In radians

pub fn is_dodge(&self) -> bool

pub fn is_glide(&self) -> bool

pub fn is_skate(&self) -> bool

pub fn is_music(&self) -> bool

pub fn roll_attack_immunities(&self) -> Option<AttackFilters>

pub fn is_stunned(&self) -> bool

pub fn is_forced_movement(&self) -> bool

pub fn is_melee_attack(&self) -> bool

pub fn is_beam_attack(&self) -> bool

pub fn can_perform_mounted(&self) -> bool

pub fn is_sitting(&self) -> bool

pub fn same_variant(&self, other: &Self) -> bool

Compares for shallow equality (does not check internal struct equality)

pub fn behavior( &self, j: &JoinData<'_>, output_events: &mut OutputEvents<'_, '_>, ) -> StateUpdate

pub fn handle_event( &self, j: &JoinData<'_>, output_events: &mut OutputEvents<'_, '_>, action: ControlAction, ) -> StateUpdate

pub fn footwear(&self) -> Option<Friction>

pub fn ability_info(&self) -> Option<AbilityInfo>

pub fn stage_section(&self) -> Option<StageSection>

pub fn durations(&self) -> Option<DurationsInfo>

pub fn timer(&self) -> Option<Duration>

pub fn attack_kind(&self) -> Option<AttackSource>

Trait Implementations

impl Clone for CharacterState

fn clone(&self) -> CharacterState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for CharacterState

type Storage = DerefFlaggedStorage<CharacterState, VecStorage<CharacterState>>

Associated storage type for this component.

impl Debug for CharacterState

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

Formats the value using the given formatter.

impl Default for CharacterState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CharacterState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CharacterState

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

Formats the value using the given formatter.

impl From<&CharacterState> for CharacterAbilityType

fn from(state: &CharacterState) -> Self

Converts to this type from the input type.

impl From<(&CharacterAbility, AbilityInfo, &JoinData<'_>)> for CharacterState

fn from( (ability, ability_info, data): (&CharacterAbility, AbilityInfo, &JoinData<'_>), ) -> Self

Converts to this type from the input type.

impl PartialEq for CharacterState

fn eq(&self, other: &CharacterState) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CharacterState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CharacterState