From 8648641362e55d4d047ed87f4b58b57bc62898ee Mon Sep 17 00:00:00 2001 From: Adam Whitehurst Date: Tue, 7 Jan 2020 07:49:08 -0800 Subject: [PATCH] Grooming --- common/src/comp/ability.rs | 2 +- common/src/comp/states/basic_attack.rs | 4 +- common/src/comp/states/basic_block.rs | 6 +- common/src/comp/states/charge_attack.rs | 6 +- common/src/comp/states/climb.rs | 57 +++--- common/src/comp/states/fall.rs | 12 +- common/src/comp/states/glide.rs | 53 +++--- common/src/comp/states/idle.rs | 14 +- common/src/comp/states/jump.rs | 6 +- common/src/comp/states/mod.rs | 131 +++++++++---- common/src/comp/states/roll.rs | 3 +- common/src/comp/states/run.rs | 19 +- common/src/comp/states/sit.rs | 17 +- common/src/comp/states/stand.rs | 15 +- common/src/comp/states/swim.rs | 14 +- common/src/comp/states/wield.rs | 4 +- common/src/msg/ecs_packet.rs | 4 + common/src/state.rs | 2 + common/src/sys/ability.rs | 4 +- common/src/sys/character_state.rs | 26 +-- common/src/sys/movement.rs | 236 ------------------------ common/src/util/state_utils.rs | 19 +- voxygen/src/audio/sfx/event_mapper.rs | 48 ++--- voxygen/src/hud/skillbar.rs | 6 +- 24 files changed, 252 insertions(+), 456 deletions(-) delete mode 100644 common/src/sys/movement.rs diff --git a/common/src/comp/ability.rs b/common/src/comp/ability.rs index 53c1a0ce4e..baf6fe24af 100644 --- a/common/src/comp/ability.rs +++ b/common/src/comp/ability.rs @@ -30,5 +30,5 @@ pub struct AbilityPool { } impl Component for AbilityPool { - type Storage = HashMapStorage; + type Storage = FlaggedStorage>; } diff --git a/common/src/comp/states/basic_attack.rs b/common/src/comp/states/basic_attack.rs index 5b95693c16..725e8acc93 100644 --- a/common/src/comp/states/basic_attack.rs +++ b/common/src/comp/states/basic_attack.rs @@ -1,6 +1,6 @@ use crate::comp::{ - ActionState::Attack, AttackKind::BasicAttack, EcsStateData, ItemKind::Tool, MoveState, - StateHandler, StateUpdate, ToolData, + ActionState::Attack, AttackKind::BasicAttack, EcsStateData, ItemKind::Tool, StateHandler, + StateUpdate, ToolData, }; use crate::util::state_utils::*; use std::time::Duration; diff --git a/common/src/comp/states/basic_block.rs b/common/src/comp/states/basic_block.rs index a18e10ffc5..053c837015 100644 --- a/common/src/comp/states/basic_block.rs +++ b/common/src/comp/states/basic_block.rs @@ -1,9 +1,11 @@ -use super::{BLOCK_ACCEL, BLOCK_SPEED}; use crate::comp::{EcsStateData, StateHandler, StateUpdate}; use crate::util::state_utils::*; use std::time::Duration; use vek::Vec2; +const BLOCK_ACCEL: f32 = 30.0; +const BLOCK_SPEED: f32 = 75.0; + #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct BasicBlockState { /// How long the blocking state has been active @@ -11,7 +13,7 @@ pub struct BasicBlockState { } impl StateHandler for BasicBlockState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self { active_duration: Duration::default(), } diff --git a/common/src/comp/states/charge_attack.rs b/common/src/comp/states/charge_attack.rs index 9e977ab755..ea4420f3f9 100644 --- a/common/src/comp/states/charge_attack.rs +++ b/common/src/comp/states/charge_attack.rs @@ -1,13 +1,13 @@ use crate::comp::{ ActionState::Attack, AttackKind::Charge, EcsStateData, HealthChange, HealthSource, - ItemKind::Tool, MoveState::Run, RunState, StateHandler, StateUpdate, ToolData, + ItemKind::Tool, MoveState::Run, StateHandler, StateUpdate, ToolData, }; use crate::event::ServerEvent; use crate::util::state_utils::*; use std::time::Duration; use vek::Vec3; -use super::CHARGE_SPEED; +const CHARGE_SPEED: f32 = 20.0; #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct ChargeAttackState { @@ -37,7 +37,7 @@ impl StateHandler for ChargeAttackState { }; // Prevent move state handling, handled here - update.character.move_state = Run(Some(RunState)); + update.character.move_state = Run(None); // Move player update.vel.0 = Vec3::new(0.0, 0.0, update.vel.0.z) diff --git a/common/src/comp/states/climb.rs b/common/src/comp/states/climb.rs index 4901084947..9b1df0a52a 100644 --- a/common/src/comp/states/climb.rs +++ b/common/src/comp/states/climb.rs @@ -1,17 +1,16 @@ -use super::{ - ActionState::*, EcsStateData, FallState, IdleState, JumpState, MoveState::*, StandState, - StateHandler, StateUpdate, -}; -use super::{CLIMB_SPEED, HUMANOID_CLIMB_ACCEL, HUMANOID_SPEED}; +use super::{ActionState::*, EcsStateData, MoveState::*, StateHandler, StateUpdate}; use crate::sys::phys::GRAVITY; use vek::vec::{Vec2, Vec3}; use vek::Lerp; +const HUMANOID_CLIMB_ACCEL: f32 = 5.0; +const CLIMB_SPEED: f32 = 5.0; + #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct ClimbState; impl StateHandler for ClimbState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self {} } @@ -23,12 +22,33 @@ impl StateHandler for ClimbState { character: *ecs_data.character, }; - update.character.action_state = Idle(Some(IdleState)); + update.character.action_state = Idle(None); + + // If no wall is in front of character ... + if let None = ecs_data.physics.on_wall { + if ecs_data.inputs.jump.is_pressed() { + // They've climbed atop something, give them a boost + update.character.move_state = Jump(None); + + return update; + } else { + // Just fall off + update.character.move_state = Fall(None); + + return update; + } + } + + // Remove climb state on ground, otherwise character will get stuck + if ecs_data.physics.on_ground { + update.character.move_state = Stand(None); + return update; + } // Move player update.vel.0 += Vec2::broadcast(ecs_data.dt.0) * ecs_data.inputs.move_dir - * if update.vel.0.magnitude_squared() < HUMANOID_SPEED.powf(2.0) { + * if update.vel.0.magnitude_squared() < CLIMB_SPEED.powf(2.0) { HUMANOID_CLIMB_ACCEL } else { 0.0 @@ -78,27 +98,6 @@ impl StateHandler for ClimbState { } } - // If no wall is infront of character ... - if let None = ecs_data.physics.on_wall { - if ecs_data.inputs.jump.is_pressed() { - // They've climbed atop something, give them a boost - update.character.move_state = Jump(Some(JumpState)); - - return update; - } else { - // Just fall off - update.character.move_state = Fall(Some(FallState)); - - return update; - } - } - - // Remove climb state on ground, otherwise character will get stuck - if ecs_data.physics.on_ground { - update.character.move_state = Stand(Some(StandState)); - return update; - } - return update; } } diff --git a/common/src/comp/states/fall.rs b/common/src/comp/states/fall.rs index 252b208153..55c72c3e97 100644 --- a/common/src/comp/states/fall.rs +++ b/common/src/comp/states/fall.rs @@ -1,14 +1,16 @@ -use super::{HUMANOID_AIR_ACCEL, HUMANOID_AIR_SPEED}; -use crate::comp::{ClimbState, EcsStateData, GlideState, MoveState::*, StateHandler, StateUpdate}; +use crate::comp::{EcsStateData, MoveState::*, StateHandler, StateUpdate}; use crate::util::state_utils::*; use vek::{Vec2, Vec3}; +const HUMANOID_AIR_ACCEL: f32 = 10.0; +const HUMANOID_AIR_SPEED: f32 = 100.0; + #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct FallState; impl StateHandler for FallState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self {} } @@ -48,13 +50,13 @@ impl StateHandler for FallState { // Check to start climbing if can_climb(ecs_data.physics, ecs_data.inputs, ecs_data.body) { - update.character.move_state = Climb(Some(ClimbState)); + update.character.move_state = Climb(None); return update; } // Check gliding if ecs_data.inputs.glide.is_pressed() { - update.character.move_state = Glide(Some(GlideState)); + update.character.move_state = Glide(None); return update; } diff --git a/common/src/comp/states/glide.rs b/common/src/comp/states/glide.rs index 77ea626849..4060b6c4f4 100644 --- a/common/src/comp/states/glide.rs +++ b/common/src/comp/states/glide.rs @@ -1,15 +1,16 @@ -use super::{GLIDE_ACCEL, GLIDE_ANTIGRAV, GLIDE_SPEED}; -use crate::comp::{ - ActionState::*, ClimbState, EcsStateData, FallState, IdleState, MoveState::*, StandState, - StateHandler, StateUpdate, -}; +use crate::comp::{ActionState::*, EcsStateData, MoveState::*, StateHandler, StateUpdate}; use vek::{Vec2, Vec3}; +// Gravity is 9.81 * 4, so this makes gravity equal to .15 +const GLIDE_ANTIGRAV: f32 = crate::sys::phys::GRAVITY * 0.96; +const GLIDE_ACCEL: f32 = 15.0; +const GLIDE_SPEED: f32 = 45.0; + #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct GlideState; impl StateHandler for GlideState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self {} } @@ -22,8 +23,26 @@ impl StateHandler for GlideState { }; // Defaults for this state - update.character.action_state = Idle(Some(IdleState)); - update.character.move_state = Glide(Some(GlideState)); + update.character.action_state = Idle(None); + update.character.move_state = Glide(None); + + // If glide button isn't held, start falling + if !ecs_data.inputs.glide.is_pressed() { + update.character.move_state = Fall(None); + return update; + } + + // If there is a wall in front of character go to climb + if let Some(_wall_dir) = ecs_data.physics.on_wall { + update.character.move_state = Climb(None); + return update; + } + + // If on ground go to stand + if ecs_data.physics.on_ground { + update.character.move_state = Stand(None); + return update; + } // Move player according to movement direction vector update.vel.0 += Vec2::broadcast(ecs_data.dt.0) @@ -56,24 +75,6 @@ impl StateHandler for GlideState { .max(0.2); } - // If glide button isn't held, start falling - if !ecs_data.inputs.glide.is_pressed() { - update.character.move_state = Fall(Some(FallState)); - return update; - } - - // If there is a wall in front of character go to climb - if let Some(_wall_dir) = ecs_data.physics.on_wall { - update.character.move_state = Climb(Some(ClimbState)); - return update; - } - - // If on ground go to stand - if ecs_data.physics.on_ground { - update.character.move_state = Stand(Some(StandState)); - return update; - } - // Otherwise keep gliding return update; } diff --git a/common/src/comp/states/idle.rs b/common/src/comp/states/idle.rs index 6acb80357d..2cfa12ad91 100644 --- a/common/src/comp/states/idle.rs +++ b/common/src/comp/states/idle.rs @@ -1,14 +1,10 @@ -use super::TEMP_EQUIP_DELAY; -use crate::comp::{ - ActionState::Wield, EcsStateData, ItemKind::Tool, StateHandler, StateUpdate, WieldState, -}; -use std::time::Duration; +use crate::comp::{ActionState::Wield, EcsStateData, ItemKind::Tool, StateHandler, StateUpdate}; #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct IdleState; impl StateHandler for IdleState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self {} } @@ -26,10 +22,8 @@ impl StateHandler for IdleState { || (ecs_data.inputs.toggle_wield.is_just_pressed() && update.character.action_state.is_equip_finished()) { - if let Some(Tool(data)) = ecs_data.stats.equipment.main.as_ref().map(|i| &i.kind) { - update.character.action_state = Wield(Some(WieldState { - equip_delay: data.equip_time(), - })); + if let Some(Tool(_)) = ecs_data.stats.equipment.main.as_ref().map(|i| &i.kind) { + update.character.action_state = Wield(None); } // else unarmed stuff? diff --git a/common/src/comp/states/jump.rs b/common/src/comp/states/jump.rs index f2aea7e393..16bf65b534 100644 --- a/common/src/comp/states/jump.rs +++ b/common/src/comp/states/jump.rs @@ -1,11 +1,11 @@ -use super::{EcsStateData, FallState, MoveState::*, StateHandler, StateUpdate}; +use super::{EcsStateData, MoveState::*, StateHandler, StateUpdate}; use crate::event::LocalEvent; #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct JumpState; impl StateHandler for JumpState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self {} } @@ -23,7 +23,7 @@ impl StateHandler for JumpState { .emit(LocalEvent::Jump(*ecs_data.entity)); // Immediately go to falling state after jump impulse - update.character.move_state = Fall(Some(FallState)); + update.character.move_state = Fall(None); return update; } } diff --git a/common/src/comp/states/mod.rs b/common/src/comp/states/mod.rs index 90f0c56834..805c8e31dd 100644 --- a/common/src/comp/states/mod.rs +++ b/common/src/comp/states/mod.rs @@ -30,47 +30,106 @@ pub use stand::*; pub use swim::*; pub use wield::*; -// TODO: Attach these to racial components and/or ecs resources -pub const HUMANOID_ACCEL: f32 = 50.0; -pub const HUMANOID_SPEED: f32 = 120.0; -pub const HUMANOID_AIR_ACCEL: f32 = 10.0; -pub const HUMANOID_AIR_SPEED: f32 = 100.0; -pub const HUMANOID_WATER_ACCEL: f32 = 70.0; -pub const HUMANOID_WATER_SPEED: f32 = 120.0; -pub const HUMANOID_CLIMB_ACCEL: f32 = 5.0; -pub const ROLL_SPEED: f32 = 17.0; -pub const CHARGE_SPEED: f32 = 20.0; -pub const GLIDE_ACCEL: f32 = 15.0; -pub const GLIDE_SPEED: f32 = 45.0; -pub const BLOCK_ACCEL: f32 = 30.0; -pub const BLOCK_SPEED: f32 = 75.0; -pub const TEMP_EQUIP_DELAY: u64 = 100; -// Gravity is 9.81 * 4, so this makes gravity equal to .15 -pub const GLIDE_ANTIGRAV: f32 = crate::sys::phys::GRAVITY * 0.96; -pub const CLIMB_SPEED: f32 = 5.0; -pub const MOVEMENT_THRESHOLD_VEL: f32 = 3.0; - use super::{ ActionState, ActionState::*, AttackKind::*, BlockKind::*, DodgeKind::*, EcsStateData, MoveState, MoveState::*, StateUpdate, }; -/// #### A trait for implementing state `handle()`ing logic. -/// _Mimics the typical OOP style state machine pattern where states implement their own behavior, -/// exit conditions, and return new states to the state machine upon exit. -/// This is still performant and consistent with ECS data-behavior-separation constraint -/// since trait fn's are syntactic sugar for static fn's that accept their implementor's -/// object type as its first parameter. This allows for several benefits over implementing -/// each state's behavior within the `CharacterState` update `System` itself:_ -/// -/// 1. Less cognitive overhead: State's handling logic is next to the its data, and component (inside the state's .rs file). -/// 2. Separation of concerns (between states): all logic within a state's `handle()` is relevant only to that state. -/// States can be added/editted without concerns of affecting other state's logic. -/// 3. Clearly defined API and pattern: All states accept the same `EcsStateData` struct, which can be added to as necessary, -/// without the need for updating every state's implementation. All states return the same `StateUpdate` component. -/// `CharacterState` update `System` passes `EcsStateData` to `ActionState`/`MoveState` `handle()` which matches the character's -/// current state to its `handle()` fn, hiding the implementation details, since the System is only concerned with -/// how the update flow occurs and is in charge of updating the ECS components. +/// ## A type for implementing State Handling Behavior. +/// +/// Called by state machines' update functions to allow current states to handle updating +/// their parent machine's current state. +/// +/// Structures must implement a `handle()` fn to handle update behavior, and a `new()` for +/// instantiating new instances of a state. `handle()` function recieves `EcsStateData`, a struct +/// of readonly ECS Component data, and returns a `StateUpdate` tuple, with new components that will +/// overwrite an entitie's old components. +/// +/// ## Example Implementation: +/// ``` +/// use crate::comp::{ +/// ClimbState, EcsStateData, GlideState, JumpState, MoveState::*, SitState, StateHandler, +/// StateUpdate, +/// }; +/// use crate::util::state_utils::* +/// #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] +/// pub struct RunState { +/// active_duration: Duration, +/// } +/// +/// impl StateHandler for RunState { +/// fn new(ecs_data: &EcsStateData) -> Self { +/// Self { +/// active_duration: Duration::default(), +/// } +/// } +/// +/// fn handle(&self, ecs_data: &EcsStateData) -> StateUpdate { +/// let mut update = StateUpdate { +/// character: *ecs_data.character, +/// pos: *ecs_data.pos, +/// vel: *ecs_data.vel, +/// ori: *ecs_data.ori, +/// }; +/// +/// // Move player according to move_dir +/// update.vel.0 += Vec2::broadcast(ecs_data.dt.0) +/// * ecs_data.inputs.move_dir +/// * if update.vel.0.magnitude_squared() < HUMANOID_SPEED.powf(2.0) { +/// HUMANOID_ACCEL +/// } else { +/// 0.0 +/// }; +/// +/// // Set direction based on move direction when on the ground +/// let ori_dir = if update.character.action_state.is_attacking() +/// || update.character.action_state.is_blocking() +/// { +/// Vec2::from(ecs_data.inputs.look_dir).normalized() +/// } else { +/// Vec2::from(update.vel.0) +/// }; +/// +/// if ori_dir.magnitude_squared() > 0.0001 +/// && (update.ori.0.normalized() - Vec3::from(ori_dir).normalized()).magnitude_squared() +/// > 0.001 +/// { +/// update.ori.0 = +/// vek::ops::Slerp::slerp(update.ori.0, ori_dir.into(), 9.0 * ecs_data.dt.0); +/// } +/// +/// // Try to sit +/// if can_sit(ecs_data.physics, ecs_data.inputs, ecs_data.body) { +/// update.character.move_state = Sit(Some(SitState)); +/// return update; +/// } +/// +/// // Try to climb +/// if can_climb(ecs_data.physics, ecs_data.inputs, ecs_data.body) { +/// update.character.move_state = Climb(Some(ClimbState)); +/// return update; +/// } +/// +/// // Try to jump +/// if can_jump(ecs_data.physics, ecs_data.inputs) { +/// update.character.move_state = Jump(Some(JumpState)); +/// return update; +/// } +/// +/// // Try to glide +/// if can_glide(ecs_data.physics, ecs_data.inputs, ecs_data.body) { +/// update.character.move_state = Glide(Some(GlideState)); +/// return update; +/// } +/// +/// // Update based on groundedness +/// update.character.move_state = +/// determine_move_from_grounded_state(ecs_data.physics, ecs_data.inputs); +/// +/// return update; +/// } +/// } +/// ``` pub trait StateHandler: Default { fn handle(&self, ecs_data: &EcsStateData) -> StateUpdate; fn new(ecs_data: &EcsStateData) -> Self; diff --git a/common/src/comp/states/roll.rs b/common/src/comp/states/roll.rs index 560fbd7e36..63e1e29c78 100644 --- a/common/src/comp/states/roll.rs +++ b/common/src/comp/states/roll.rs @@ -1,4 +1,3 @@ -use super::ROLL_SPEED; use crate::comp::{ ActionState::*, DodgeKind::*, EcsStateData, ItemKind::Tool, StateHandler, StateUpdate, ToolData, }; @@ -6,6 +5,8 @@ use crate::util::state_utils::*; use std::time::Duration; use vek::Vec3; +const ROLL_SPEED: f32 = 17.0; + #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct RollState { /// How long the state has until exitting diff --git a/common/src/comp/states/run.rs b/common/src/comp/states/run.rs index 94bdf7dc85..598eb5dbb7 100644 --- a/common/src/comp/states/run.rs +++ b/common/src/comp/states/run.rs @@ -1,16 +1,15 @@ -use super::{HUMANOID_ACCEL, HUMANOID_SPEED}; -use crate::comp::{ - ClimbState, EcsStateData, GlideState, JumpState, MoveState::*, SitState, StateHandler, - StateUpdate, -}; +use crate::comp::{EcsStateData, MoveState::*, StateHandler, StateUpdate}; use crate::util::state_utils::*; use vek::vec::{Vec2, Vec3}; +const HUMANOID_ACCEL: f32 = 50.0; +const HUMANOID_SPEED: f32 = 120.0; + #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct RunState; impl StateHandler for RunState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self {} } @@ -50,25 +49,25 @@ impl StateHandler for RunState { // Try to sit if can_sit(ecs_data.physics, ecs_data.inputs, ecs_data.body) { - update.character.move_state = Sit(Some(SitState)); + update.character.move_state = Sit(None); return update; } // Try to climb if can_climb(ecs_data.physics, ecs_data.inputs, ecs_data.body) { - update.character.move_state = Climb(Some(ClimbState)); + update.character.move_state = Climb(None); return update; } // Try to jump if can_jump(ecs_data.physics, ecs_data.inputs) { - update.character.move_state = Jump(Some(JumpState)); + update.character.move_state = Jump(None); return update; } // Try to glide if can_glide(ecs_data.physics, ecs_data.inputs, ecs_data.body) { - update.character.move_state = Glide(Some(GlideState)); + update.character.move_state = Glide(None); return update; } diff --git a/common/src/comp/states/sit.rs b/common/src/comp/states/sit.rs index 99f567bdec..2e47c8d4f5 100644 --- a/common/src/comp/states/sit.rs +++ b/common/src/comp/states/sit.rs @@ -1,14 +1,11 @@ -use crate::comp::{ - ActionState::*, EcsStateData, IdleState, JumpState, MoveState::*, RunState, StandState, - StateHandler, StateUpdate, -}; +use crate::comp::{ActionState::*, EcsStateData, MoveState::*, StateHandler, StateUpdate}; use crate::util::state_utils::*; #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct SitState; impl StateHandler for SitState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self {} } @@ -21,8 +18,8 @@ impl StateHandler for SitState { }; // Prevent action state handling - update.character.action_state = Idle(Some(IdleState)); - update.character.move_state = Sit(Some(SitState)); + update.character.action_state = Idle(None); + update.character.move_state = Sit(None); // Try to Fall // ... maybe the ground disappears, @@ -34,19 +31,19 @@ impl StateHandler for SitState { } // Try to jump if ecs_data.inputs.jump.is_pressed() { - update.character.move_state = Jump(Some(JumpState)); + update.character.move_state = Jump(None); return update; } // Try to Run if ecs_data.inputs.move_dir.magnitude_squared() > 0.0 { - update.character.move_state = Run(Some(RunState)); + update.character.move_state = Run(None); return update; } // Try to Stand if ecs_data.inputs.sit.is_just_pressed() { - update.character.move_state = Stand(Some(StandState)); + update.character.move_state = Stand(None); return update; } diff --git a/common/src/comp/states/stand.rs b/common/src/comp/states/stand.rs index 7c81839f2c..b3372c8721 100644 --- a/common/src/comp/states/stand.rs +++ b/common/src/comp/states/stand.rs @@ -1,14 +1,11 @@ -use crate::comp::{ - ClimbState, EcsStateData, GlideState, JumpState, MoveState::*, SitState, StateHandler, - StateUpdate, -}; +use crate::comp::{EcsStateData, MoveState::*, StateHandler, StateUpdate}; use crate::util::state_utils::*; #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct StandState; impl StateHandler for StandState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self {} } @@ -22,25 +19,25 @@ impl StateHandler for StandState { // Try to sit if can_sit(ecs_data.physics, ecs_data.inputs, ecs_data.body) { - update.character.move_state = Sit(Some(SitState)); + update.character.move_state = Sit(None); return update; } // Try to climb if can_climb(ecs_data.physics, ecs_data.inputs, ecs_data.body) { - update.character.move_state = Climb(Some(ClimbState)); + update.character.move_state = Climb(None); return update; } // Try to jump if can_jump(ecs_data.physics, ecs_data.inputs) { - update.character.move_state = Jump(Some(JumpState)); + update.character.move_state = Jump(None); return update; } // Check gliding if can_glide(ecs_data.physics, ecs_data.inputs, ecs_data.body) { - update.character.move_state = Glide(Some(GlideState)); + update.character.move_state = Glide(None); return update; } diff --git a/common/src/comp/states/swim.rs b/common/src/comp/states/swim.rs index ccb3022e5d..29d1512bfe 100644 --- a/common/src/comp/states/swim.rs +++ b/common/src/comp/states/swim.rs @@ -1,13 +1,15 @@ -use super::{HUMANOID_WATER_ACCEL, HUMANOID_WATER_SPEED}; -use crate::comp::{EcsStateData, MoveState::*, RunState, StandState, StateHandler, StateUpdate}; +use crate::comp::{EcsStateData, MoveState::*, StateHandler, StateUpdate}; use crate::sys::phys::GRAVITY; use vek::{Vec2, Vec3}; #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] pub struct SwimState; +const HUMANOID_WATER_ACCEL: f32 = 70.0; +const HUMANOID_WATER_SPEED: f32 = 120.0; + impl StateHandler for SwimState { - fn new(ecs_data: &EcsStateData) -> Self { + fn new(_ecs_data: &EcsStateData) -> Self { Self {} } @@ -55,16 +57,16 @@ impl StateHandler for SwimState { // Not on ground if !ecs_data.physics.on_ground { - update.character.move_state = Swim(Some(SwimState)); + update.character.move_state = Swim(None); return update; } // On ground else { // Return to running or standing based on move inputs update.character.move_state = if ecs_data.inputs.move_dir.magnitude_squared() > 0.0 { - Run(Some(RunState)) + Run(None) } else { - Stand(Some(StandState)) + Stand(None) }; return update; diff --git a/common/src/comp/states/wield.rs b/common/src/comp/states/wield.rs index d2462193a9..06f55afb1c 100644 --- a/common/src/comp/states/wield.rs +++ b/common/src/comp/states/wield.rs @@ -1,8 +1,6 @@ use crate::comp::{ - AbilityAction, AbilityActionKind::*, ActionState::*, EcsStateData, IdleState, ItemKind::Tool, - StateHandler, StateUpdate, ToolData, + ActionState::*, EcsStateData, IdleState, ItemKind::Tool, StateHandler, StateUpdate, ToolData, }; -use crate::util::state_utils::*; use std::time::Duration; #[derive(Clone, Copy, Default, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)] diff --git a/common/src/msg/ecs_packet.rs b/common/src/msg/ecs_packet.rs index 7f4a4f792b..6ee78280c3 100644 --- a/common/src/msg/ecs_packet.rs +++ b/common/src/msg/ecs_packet.rs @@ -36,6 +36,8 @@ sphynx::sum_type! { OverrideAction(comp::OverrideAction), OverrideMove(comp::OverrideMove), OverrideState(comp::OverrideState), + AbilityAction(comp::AbilityAction), + AbilityPool(comp::AbilityPool), } } // Automatically derive From for EcsCompPhantom @@ -62,6 +64,8 @@ sphynx::sum_type! { OverrideAction(PhantomData), OverrideMove(PhantomData), OverrideState(PhantomData), + AbilityAction(PhantomData), + AbilityPool(PhantomData), } } impl sphynx::CompPacket for EcsCompPacket { diff --git a/common/src/state.rs b/common/src/state.rs index b3aa25af8e..bf4b7e9814 100644 --- a/common/src/state.rs +++ b/common/src/state.rs @@ -123,6 +123,8 @@ impl State { // TODO: Split up registering into server and client (e.g. move EventBus to the server) fn setup_sphynx_world(ecs: &mut sphynx::World) { // Register server -> all clients synced components. + ecs.register_synced::(); + ecs.register_synced::(); ecs.register_synced::(); ecs.register_synced::(); ecs.register_synced::(); diff --git a/common/src/sys/ability.rs b/common/src/sys/ability.rs index 25982ac854..99b173c89d 100644 --- a/common/src/sys/ability.rs +++ b/common/src/sys/ability.rs @@ -25,13 +25,13 @@ impl<'a> System<'a> for Sys { &mut self, ( entities, - updater, + _updater, mut character_state_storage, ability_action_storage, ability_pool_storage, ): Self::SystemData, ) { - for (entity, mut character, ability_action, ability_pool) in ( + for (_entity, mut _character, _ability_action, _ability_pool) in ( &entities, &mut character_state_storage, &ability_action_storage, diff --git a/common/src/sys/character_state.rs b/common/src/sys/character_state.rs index 82b85f2eb3..54ce8de3dd 100644 --- a/common/src/sys/character_state.rs +++ b/common/src/sys/character_state.rs @@ -1,8 +1,7 @@ use crate::{ comp::{ - states::*, Body, CharacterState, Controller, EcsStateData, Mounting, MoveState::*, Ori, - OverrideAction, OverrideMove, OverrideState, PhysicsState, Pos, SitState, StateHandler, - Stats, Vel, + Body, CharacterState, Controller, EcsStateData, Mounting, MoveState::*, Ori, + OverrideAction, OverrideMove, OverrideState, PhysicsState, Pos, Stats, Vel, }, event::{EventBus, LocalEvent, ServerEvent}, state::DeltaTime, @@ -11,18 +10,11 @@ use crate::{ use specs::{Entities, Join, LazyUpdate, Read, ReadStorage, System, WriteStorage}; use sphynx::{Uid, UidAllocator}; -/// # Character State System -/// #### Updates tuples of ( `CharacterState`, `Pos`, `Vel`, and `Ori` ) in parallel. -/// _Each update for a single character involves first passing an `EcsStateData` struct of ECS components -/// to the character's `MoveState`, then the character's `ActionState`. State update logic is -/// is encapsulated in state's `handle()` fn, impl'd by the `StateHandle` trait. `handle()` fn's -/// return a `StateUpdate` tuple containing new ( `CharacterState`, `Pos`, `Vel`, and `Ori` ) components. -/// Since `handle()` accepts readonly components, component updates are contained within this system and ECS -/// behavior constraints are satisfied._ +/// ## Character State System +/// #### Calls updates to `CharacterState`s. Acts on tuples of ( `CharacterState`, `Pos`, `Vel`, and `Ori` ). /// -/// _This mimics the typical OOP style state machine pattern, but remains performant -/// under ECS since trait fn's are syntactic sugar for static fn's that accept their implementor's -/// object type as its first parameter. See `StateHandle` for more information._ +/// _System forms `EcsStateData` tuples and passes those to `ActionState` `update()` fn, +/// then does the same for `MoveState` `update`_ pub struct Sys; impl<'a> System<'a> for Sys { @@ -102,14 +94,14 @@ impl<'a> System<'a> for Sys { // If mounted, character state is controlled by mount // TODO: Make mounting a state if let Some(Mounting(_)) = mountings.get(entity) { - character.move_state = Sit(Some(SitState)); + character.move_state = Sit(None); return; } // Determine new action if character can act if let (None, false) = ( action_overrides.get(entity), - character.action_state.overrides_move_state(), + character.move_state.overrides_action_state(), ) { let state_update = character.action_state.update(&EcsStateData { entity: &entity, @@ -137,7 +129,7 @@ impl<'a> System<'a> for Sys { // Determine new move state if character can move if let (None, false) = ( move_overrides.get(entity), - character.move_state.overrides_action_state(), + character.action_state.overrides_move_state(), ) { let state_update = character.move_state.update(&EcsStateData { entity: &entity, diff --git a/common/src/sys/movement.rs b/common/src/sys/movement.rs deleted file mode 100644 index 9b8da17f1b..0000000000 --- a/common/src/sys/movement.rs +++ /dev/null @@ -1,236 +0,0 @@ -use super::phys::GRAVITY; -use crate::{ - comp::{ - CharacterState, Controller, Mounting, MoveState::*, Ori, PhysicsState, Pos, RunState, - StandState, Stats, Vel, - }, - event::{EventBus, ServerEvent}, - state::DeltaTime, - terrain::TerrainGrid, -}; -use specs::prelude::*; -use sphynx::Uid; -use std::time::Duration; -use vek::*; - -pub const ROLL_DURATION: Duration = Duration::from_millis(600); - -const HUMANOID_ACCEL: f32 = 50.0; -const HUMANOID_SPEED: f32 = 120.0; -const HUMANOID_AIR_ACCEL: f32 = 10.0; -const HUMANOID_AIR_SPEED: f32 = 100.0; -const HUMANOID_WATER_ACCEL: f32 = 70.0; -const HUMANOID_WATER_SPEED: f32 = 120.0; -const HUMANOID_CLIMB_ACCEL: f32 = 5.0; -const ROLL_SPEED: f32 = 17.0; -const CHARGE_SPEED: f32 = 20.0; -const GLIDE_ACCEL: f32 = 15.0; -const GLIDE_SPEED: f32 = 45.0; -const BLOCK_ACCEL: f32 = 30.0; -const BLOCK_SPEED: f32 = 75.0; -// Gravity is 9.81 * 4, so this makes gravity equal to .15 -const GLIDE_ANTIGRAV: f32 = GRAVITY * 0.96; -const CLIMB_SPEED: f32 = 5.0; - -pub const MOVEMENT_THRESHOLD_VEL: f32 = 3.0; - -/// # Movement System -/// #### Applies forces, calculates new positions and velocities,7 -/// #### based on Controller(Inputs) and CharacterState. -/// ---- -/// -/// **Writes:** -/// Pos, Vel, Ori -/// -/// **Reads:** -/// Uid, Stats, Controller, PhysicsState, CharacterState, Mounting -pub struct Sys; -impl<'a> System<'a> for Sys { - type SystemData = ( - Entities<'a>, - ReadExpect<'a, TerrainGrid>, - Read<'a, EventBus>, - Read<'a, DeltaTime>, - WriteStorage<'a, Pos>, - WriteStorage<'a, Vel>, - WriteStorage<'a, Ori>, - ReadStorage<'a, Uid>, - ReadStorage<'a, Stats>, - ReadStorage<'a, Controller>, - ReadStorage<'a, PhysicsState>, - ReadStorage<'a, CharacterState>, - ReadStorage<'a, Mounting>, - ); - - fn run( - &mut self, - ( - entities, - _terrain, - _server_bus, - dt, - mut positions, - mut velocities, - mut orientations, - uids, - stats, - controllers, - physics_states, - character_states, - mountings, - ): Self::SystemData, - ) { - // Apply movement inputs - for ( - _entity, - mut _pos, - mut vel, - mut ori, - _uid, - stats, - controller, - physics, - character, - mount, - ) in ( - &entities, - &mut positions, - &mut velocities, - &mut orientations, - &uids, - &stats, - &controllers, - &physics_states, - &character_states, - mountings.maybe(), - ) - .join() - { - // if character.movement == Run(RunState) || character.movement == Stand(StandState) { - // continue; - // } - - // if stats.is_dead { - // continue; - // } - - // if mount.is_some() { - // continue; - // } - - // let inputs = &controller.inputs; - - // if character.action.is_roll() { - // vel.0 = Vec3::new(0.0, 0.0, vel.0.z) - // + (vel.0 * Vec3::new(1.0, 1.0, 0.0) - // + 1.5 * inputs.move_dir.try_normalized().unwrap_or_default()) - // .try_normalized() - // .unwrap_or_default() - // * ROLL_SPEED; - // } else if character.action.is_charge() { - // vel.0 = Vec3::new(0.0, 0.0, vel.0.z) - // + (vel.0 * Vec3::new(1.0, 1.0, 0.0) - // + 1.5 * inputs.move_dir.try_normalized().unwrap_or_default()) - // .try_normalized() - // .unwrap_or_default() - // * CHARGE_SPEED; - // } else if character.action.is_block() { - // vel.0 += Vec2::broadcast(dt.0) - // * inputs.move_dir - // * match physics.on_ground { - // true if vel.0.magnitude_squared() < BLOCK_SPEED.powf(2.0) => BLOCK_ACCEL, - // _ => 0.0, - // } - // } else { - // // Move player according to move_dir - // vel.0 += Vec2::broadcast(dt.0) - // * inputs.move_dir - // * match (physics.on_ground, &character.movement) { - // (true, Run(_)) if vel.0.magnitude_squared() < HUMANOID_SPEED.powf(2.0) => { - // HUMANOID_ACCEL - // } - // (false, Climb) if vel.0.magnitude_squared() < HUMANOID_SPEED.powf(2.0) => { - // HUMANOID_CLIMB_ACCEL - // } - // (false, Glide) if vel.0.magnitude_squared() < GLIDE_SPEED.powf(2.0) => { - // GLIDE_ACCEL - // } - // (false, Fall) | (false, Jump) - // if vel.0.magnitude_squared() < HUMANOID_AIR_SPEED.powf(2.0) => - // { - // HUMANOID_AIR_ACCEL - // } - // (false, Swim) - // if vel.0.magnitude_squared() < HUMANOID_WATER_SPEED.powf(2.0) => - // { - // HUMANOID_WATER_ACCEL - // } - // _ => 0.0, - // }; - // } - - // // Set direction based on move direction when on the ground - // let ori_dir = if - // //character.action.is_wield() || - // character.action.is_attack() || character.action.is_block() { - // Vec2::from(inputs.look_dir).normalized() - // } else if let (Climb, Some(wall_dir)) = (character.movement, physics.on_wall) { - // if Vec2::::from(wall_dir).magnitude_squared() > 0.001 { - // Vec2::from(wall_dir).normalized() - // } else { - // Vec2::from(vel.0) - // } - // } else { - // Vec2::from(vel.0) - // }; - - // if ori_dir.magnitude_squared() > 0.0001 - // && (ori.0.normalized() - Vec3::from(ori_dir).normalized()).magnitude_squared() - // > 0.001 - // { - // ori.0 = vek::ops::Slerp::slerp( - // ori.0, - // ori_dir.into(), - // if physics.on_ground { 9.0 } else { 2.0 } * dt.0, - // ); - // } - - // // Glide - // if character.movement == Glide - // && Vec2::::from(vel.0).magnitude_squared() < GLIDE_SPEED.powf(2.0) - // && vel.0.z < 0.0 - // { - // let lift = GLIDE_ANTIGRAV + vel.0.z.abs().powf(2.0) * 0.15; - // vel.0.z += dt.0 - // * lift - // * (Vec2::::from(vel.0).magnitude() * 0.075) - // .min(1.0) - // .max(0.2); - // } - - // // Climb - // if let (true, Some(_wall_dir)) = ( - // (inputs.climb.is_pressed() | inputs.climb_down.is_pressed()) - // && vel.0.z <= CLIMB_SPEED, - // physics.on_wall, - // ) { - // if inputs.climb_down.is_pressed() && !inputs.climb.is_pressed() { - // vel.0 -= dt.0 * vel.0.map(|e| e.abs().powf(1.5) * e.signum() * 6.0); - // } else if inputs.climb.is_pressed() && !inputs.climb_down.is_pressed() { - // vel.0.z = (vel.0.z + dt.0 * GRAVITY * 1.25).min(CLIMB_SPEED); - // } else { - // vel.0.z = vel.0.z + dt.0 * GRAVITY * 1.5; - // vel.0 = Lerp::lerp( - // vel.0, - // Vec3::zero(), - // 30.0 * dt.0 / (1.0 - vel.0.z.min(0.0) * 5.0), - // ); - // } - // } - - // if character.movement == Swim && inputs.jump.is_pressed() { - // vel.0.z = (vel.0.z + dt.0 * GRAVITY * 1.25).min(HUMANOID_WATER_SPEED); - // } - } - } -} diff --git a/common/src/util/state_utils.rs b/common/src/util/state_utils.rs index 02fd2de6f4..e303e102e5 100644 --- a/common/src/util/state_utils.rs +++ b/common/src/util/state_utils.rs @@ -1,8 +1,7 @@ -use crate::comp::TEMP_EQUIP_DELAY; use crate::comp::{ ActionState, ActionState::*, AttackKind::*, BasicAttackState, BasicBlockState, BlockKind::*, Body, ControllerInputs, FallState, IdleState, ItemKind::Tool, MoveState, MoveState::*, - PhysicsState, RunState, StandState, Stats, SwimState, ToolData, WieldState, + PhysicsState, RunState, StandState, Stats, SwimState, WieldState, }; use std::time::Duration; @@ -23,7 +22,7 @@ pub fn determine_primary_ability(stats: &Stats) -> ActionState { /// and returns the corresponding `ActionState` /// ... or Idle if nothing it possible?_ pub fn determine_secondary_ability(stats: &Stats) -> ActionState { - if let Some(Tool(data)) = stats.equipment.main.as_ref().map(|i| &i.kind) { + if let Some(Tool(_data)) = stats.equipment.main.as_ref().map(|i| &i.kind) { Block(BasicBlock(Some(BasicBlockState { active_duration: Duration::default(), }))) @@ -32,7 +31,7 @@ pub fn determine_secondary_ability(stats: &Stats) -> ActionState { } } -/// __Returns a `MoveState` based on `in_fluid` condition__ +/// _Returns a `MoveState` based on `in_fluid` condition_ pub fn determine_fall_or_swim(physics: &PhysicsState) -> MoveState { // Check if in fluid to go to swimming or back to falling if physics.in_fluid { @@ -41,7 +40,7 @@ pub fn determine_fall_or_swim(physics: &PhysicsState) -> MoveState { Fall(Some(FallState)) } } -/// __Returns a `MoveState` based on `move_dir` magnitude__ +/// _Returns a `MoveState` based on `move_dir` magnitude_ pub fn determine_stand_or_run(inputs: &ControllerInputs) -> MoveState { // Return to running or standing based on move inputs if inputs.move_dir.magnitude_squared() > 0.0 { @@ -51,7 +50,7 @@ pub fn determine_stand_or_run(inputs: &ControllerInputs) -> MoveState { } } -/// __Returns a `MoveState` based on `on_ground` state.__ +/// _Returns a `MoveState` based on `on_ground` state._ /// /// _`FallState`, or `SwimState` if not `on_ground`, /// `StandState` or `RunState` if is `on_ground`_ @@ -69,11 +68,11 @@ pub fn determine_move_from_grounded_state( } } -/// __Returns an ActionState based on whether character has a weapon equipped.__ +/// _Returns an ActionState based on whether character has a weapon equipped._ pub fn attempt_wield(stats: &Stats) -> ActionState { - if let Some(Tool { .. }) = stats.equipment.main.as_ref().map(|i| &i.kind) { + if let Some(Tool(data)) = stats.equipment.main.as_ref().map(|i| &i.kind) { Wield(Some(WieldState { - equip_delay: Duration::from_millis(TEMP_EQUIP_DELAY), + equip_delay: data.equip_time(), })) } else { Idle(Some(IdleState)) @@ -82,7 +81,7 @@ pub fn attempt_wield(stats: &Stats) -> ActionState { pub fn can_climb(physics: &PhysicsState, inputs: &ControllerInputs, body: &Body) -> bool { if let (true, Some(_wall_dir)) = ( - inputs.climb.is_pressed() | inputs.climb_down.is_pressed() && body.is_humanoid(), + (inputs.climb.is_pressed() | inputs.climb_down.is_pressed()) && body.is_humanoid(), physics.on_wall, ) { true diff --git a/voxygen/src/audio/sfx/event_mapper.rs b/voxygen/src/audio/sfx/event_mapper.rs index 11285bb637..46c32fd7d5 100644 --- a/voxygen/src/audio/sfx/event_mapper.rs +++ b/voxygen/src/audio/sfx/event_mapper.rs @@ -277,10 +277,8 @@ mod tests { let result = SfxEventMapper::map_character_event( &CharacterState { - move_state: MoveState::Stand(StandState), - action_state: ActionState::Idle(IdleState), - action_disabled_this_tick: false, - move_disabled_this_tick: false, + move_state: MoveState::Stand(None), + action_state: ActionState::Idle(None), }, SfxEvent::Idle, &stats, @@ -295,10 +293,8 @@ mod tests { let result = SfxEventMapper::map_character_event( &CharacterState { - move_state: MoveState::Run(RunState), - action_state: ActionState::Idle(IdleState), - action_disabled_this_tick: false, - move_disabled_this_tick: false, + move_state: MoveState::Run(None), + action_state: ActionState::Idle(None), }, SfxEvent::Idle, &stats, @@ -313,10 +309,8 @@ mod tests { let result = SfxEventMapper::map_character_event( &CharacterState { - action_state: ActionState::Dodge(Roll(RollState::default())), - move_state: MoveState::Run(RunState), - action_disabled_this_tick: false, - move_disabled_this_tick: true, + action_state: ActionState::Dodge(Roll(None)), + move_state: MoveState::Run(None), }, SfxEvent::Run, &stats, @@ -331,10 +325,8 @@ mod tests { let result = SfxEventMapper::map_character_event( &CharacterState { - move_state: MoveState::Fall(FallState), - action_state: ActionState::Idle(IdleState), - action_disabled_this_tick: false, - move_disabled_this_tick: false, + move_state: MoveState::Fall((None)), + action_state: ActionState::Idle((None)), }, SfxEvent::Idle, &stats, @@ -349,10 +341,8 @@ mod tests { let result = SfxEventMapper::map_character_event( &CharacterState { - move_state: MoveState::Glide(GlideState), - action_state: ActionState::Idle(IdleState), - action_disabled_this_tick: true, - move_disabled_this_tick: false, + move_state: MoveState::Glide(None), + action_state: ActionState::Idle(None), }, SfxEvent::Jump, &stats, @@ -367,10 +357,8 @@ mod tests { let result = SfxEventMapper::map_character_event( &CharacterState { - move_state: MoveState::Glide(GlideState), - action_state: ActionState::Idle(IdleState), - action_disabled_this_tick: true, - move_disabled_this_tick: false, + move_state: MoveState::Glide(None), + action_state: ActionState::Idle(None), }, SfxEvent::Glide, &stats, @@ -385,10 +373,8 @@ mod tests { let result = SfxEventMapper::map_character_event( &CharacterState { - move_state: MoveState::Fall(FallState), - action_state: ActionState::Idle(IdleState), - move_disabled_this_tick: false, - action_disabled_this_tick: false, + move_state: MoveState::Fall(None), + action_state: ActionState::Idle(None), }, SfxEvent::Glide, &stats, @@ -408,10 +394,8 @@ mod tests { let result = SfxEventMapper::map_character_event( &CharacterState { - move_state: MoveState::Stand(StandState), - action_state: ActionState::Attack(BasicAttack(BasicAttackState::default())), - move_disabled_this_tick: false, - action_disabled_this_tick: false, + move_state: MoveState::Stand(None), + action_state: ActionState::Attack(BasicAttack(None)), }, SfxEvent::Idle, &stats, diff --git a/voxygen/src/hud/skillbar.rs b/voxygen/src/hud/skillbar.rs index 8e6d3855c6..d9d4fff5eb 100644 --- a/voxygen/src/hud/skillbar.rs +++ b/voxygen/src/hud/skillbar.rs @@ -1,9 +1,9 @@ use super::{ - img_ids::Imgs, BarNumbers, Fonts, ShortcutNumbers, XpBar, CRITICAL_HP_COLOR, - /*FOCUS_COLOR, RAGE_COLOR,*/ HP_COLOR, LOW_HP_COLOR, MANA_COLOR, TEXT_COLOR, XP_COLOR, + img_ids::Imgs, BarNumbers, Fonts, ShortcutNumbers, XpBar, CRITICAL_HP_COLOR, HP_COLOR, + LOW_HP_COLOR, MANA_COLOR, TEXT_COLOR, XP_COLOR, }; use crate::GlobalState; -use common::comp::{item::Debug, item::ToolData, item::ToolKind, Equipment, ItemKind, Stats}; +use common::comp::{item::Debug, item::ToolData, item::ToolKind, ItemKind, Stats}; use conrod_core::{ color, widget::{self, Button, Image, Rectangle, Text},