Mirrored_Repos/veloren
1
0
Fork 0
mirror of https://gitlab.com/veloren/veloren.git synced 2024-08-30 18:12:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Completely purged old method of inputs

Browse Source
This commit is contained in:
Sam 2021-03-14 14:42:39 -04:00
parent be27289a7f
commit ac6e192db4
26 changed files with 592 additions and 510 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

171
common/src/comp/controller.rs
View File

@ -11,12 +11,9 @@ use crate::{
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use specs::{Component, DerefFlaggedStorage}; use specs::{Component, DerefFlaggedStorage};
use specs_idvs::IdvStorage; use specs_idvs::IdvStorage;
use std::{collections::BTreeSet, time::Duration}; use std::collections::BTreeSet;
use vek::*; use vek::*;
/// Default duration before an input is considered 'held'.
pub const DEFAULT_HOLD_DURATION: Duration = Duration::from_millis(200);
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum InventoryEvent { pub enum InventoryEvent {
Pickup(Uid), Pickup(Uid),
@ -123,115 +120,11 @@ pub enum ControlAction {
pub enum InputKind { pub enum InputKind {
Primary = 0, Primary = 0,
Secondary = 1, Secondary = 1,
/* Ability(usize) = 2, Ability(usize) = 2,
* Jump = 3, Roll = 3,
* Roll = 4, Jump = 4,
* Glide = 5, Glide = 5,
* Fly = 6, Fly = 6,
* WallLeap = 7, */
}
#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
enum Freshness {
New,
TickedOnce,
Old,
}
/// Whether a key is pressed or unpressed
/// and how long it has been in that state
#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Input {
/// Should not be pub because duration should
/// always be reset when state is updated
pressed: bool,
/// Should only be updated by npc agents
/// through appropriate fn
duration: Duration,
/// How fresh is the last change to the input state
freshness: Freshness,
}
impl Input {
fn tick(&mut self, dt: Duration) {
// Increase how long input has been in current state
self.duration = self.duration.checked_add(dt).unwrap_or_default();
self.tick_freshness();
}
fn tick_freshness(&mut self) {
self.freshness = match self.freshness {
Freshness::New => Freshness::TickedOnce,
Freshness::TickedOnce => Freshness::Old,
Freshness::Old => Freshness::Old,
};
}
/// Update input with newer version
/// Used to update inputs with input received from clients
pub fn update_with_new(&mut self, new: Self) {
if self.pressed != new.pressed {
self.freshness = Freshness::New;
}
self.pressed = new.pressed;
self.duration = new.duration;
}
/// Whether input is being pressed down
pub fn is_pressed(&self) -> bool { self.pressed }
/// Whether it's the first frame this input has been pressed
pub fn is_just_pressed(&self) -> bool { self.is_pressed() && self.freshness != Freshness::Old }
/// Whether it's the first frame this input has been unpressed
pub fn is_just_unpressed(&self) -> bool {
!self.is_pressed() && self.freshness != Freshness::Old
}
/// Whether input has been pressed longer than
/// `DEFAULT_HOLD_DURATION`
pub fn is_held_down(&self) -> bool {
self.is_pressed() && self.duration >= DEFAULT_HOLD_DURATION
}
/// Whether input has been unpressed longer than
/// `DEFAULT_HOLD_DURATION`
pub fn is_held_up(&self) -> bool {
!self.is_pressed() && self.duration >= DEFAULT_HOLD_DURATION
}
/// Whether input has been pressed for longer than `threshold` duration
pub fn held_for_dur(&self, threshold: Duration) -> bool {
self.is_pressed() && self.duration >= threshold
}
/// Handles logic of updating state of Input
pub fn set_state(&mut self, pressed: bool) {
if self.pressed != pressed {
self.pressed = pressed;
self.duration = Duration::default();
self.freshness = Freshness::New;
}
}
/// Increases `input.duration` by `dur`
pub fn inc_dur(&mut self, dur: Duration) {
self.duration = self.duration.checked_add(dur).unwrap_or_default();
}
/// Returns `input.duration`
pub fn get_dur(&self) -> Duration { self.duration }
}
impl Default for Input {
fn default() -> Self {
Self {
pressed: false,
duration: Duration::default(),
freshness: Freshness::New,
}
}
} }
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
@ -243,16 +136,6 @@ pub enum Climb {
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct ControllerInputs { pub struct ControllerInputs {
//pub primary: Input,
//pub secondary: Input,
pub ability3: Input,
pub ability4: Input,
pub jump: Input,
pub roll: Input,
pub glide: Input,
pub fly: Input, // Flying entities only
pub wall_leap: Input,
pub charge: Input,
pub climb: Option<Climb>, pub climb: Option<Climb>,
pub move_dir: Vec2<f32>, pub move_dir: Vec2<f32>,
pub move_z: f32, /* z axis (not combined with move_dir because they may have independent pub move_z: f32, /* z axis (not combined with move_dir because they may have independent
@ -270,55 +153,13 @@ pub struct Controller {
} }
impl ControllerInputs { impl ControllerInputs {
/// Updates all inputs, accounting for delta time
pub fn tick(&mut self, dt: Duration) {
//self.primary.tick(dt);
// self.secondary.tick(dt);
self.ability3.tick(dt);
self.ability4.tick(dt);
self.jump.tick(dt);
self.roll.tick(dt);
self.glide.tick(dt);
self.fly.tick(dt);
self.wall_leap.tick(dt);
self.charge.tick(dt);
}
pub fn tick_freshness(&mut self) {
//self.primary.tick_freshness();
// self.secondary.tick_freshness();
self.ability3.tick_freshness();
self.ability4.tick_freshness();
self.jump.tick_freshness();
self.roll.tick_freshness();
self.glide.tick_freshness();
self.fly.tick_freshness();
self.wall_leap.tick_freshness();
self.charge.tick_freshness();
}
/// Updates Controller inputs with new version received from the client /// Updates Controller inputs with new version received from the client
pub fn update_with_new(&mut self, new: Self) { pub fn update_with_new(&mut self, new: Self) {
//self.primary.update_with_new(new.primary);
// self.secondary.update_with_new(new.secondary);
self.ability3.update_with_new(new.ability3);
self.ability4.update_with_new(new.ability4);
self.jump.update_with_new(new.jump);
self.roll.update_with_new(new.roll);
self.glide.update_with_new(new.glide);
self.fly.update_with_new(new.fly);
self.wall_leap.update_with_new(new.wall_leap);
self.charge.update_with_new(new.charge);
self.climb = new.climb; self.climb = new.climb;
self.move_dir = new.move_dir; self.move_dir = new.move_dir;
self.move_z = new.move_z; self.move_z = new.move_z;
self.look_dir = new.look_dir; self.look_dir = new.look_dir;
} }
pub fn holding_ability_key(&self) -> bool {
//self.primary.is_pressed() || self.secondary.is_pressed() ||
self.ability3.is_pressed() || self.ability4.is_pressed()
}
} }
impl Controller { impl Controller {

4
common/src/comp/mod.rs
View File

@ -61,8 +61,8 @@ pub use self::{
}, },
combo::Combo, combo::Combo,
controller::{ controller::{
Climb, ControlAction, ControlEvent, Controller, ControllerInputs, GroupManip, Input, Climb, ControlAction, ControlEvent, Controller, ControllerInputs, GroupManip, InputKind,
InputKind, InventoryAction, InventoryEvent, InventoryManip, MountState, Mounting, InventoryAction, InventoryEvent, InventoryManip, MountState, Mounting,
}, },
energy::{Energy, EnergyChange, EnergySource}, energy::{Energy, EnergyChange, EnergySource},
group::Group, group::Group,

18
common/src/states/basic_aura.rs
View File

@ -51,15 +51,15 @@ impl CharacterBehavior for Data {
handle_move(data, &mut update, 0.8); handle_move(data, &mut update, 0.8);
handle_jump(data, &mut update); handle_jump(data, &mut update);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::BasicAura(_) => {}, // CharacterState::BasicAura(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Buildup => { StageSection::Buildup => {

20
common/src/states/basic_beam.rs
View File

@ -71,15 +71,15 @@ impl CharacterBehavior for Data {
handle_move(data, &mut update, 0.4); handle_move(data, &mut update, 0.4);
handle_jump(data, &mut update); handle_jump(data, &mut update);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::BasicBeam(_) => {}, // CharacterState::BasicBeam(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Buildup => { StageSection::Buildup => {
@ -110,7 +110,7 @@ impl CharacterBehavior for Data {
StageSection::Cast => { StageSection::Cast => {
if if
/* ability_key_is_pressed(data, self.static_data.ability_info.key) */ /* ability_key_is_pressed(data, self.static_data.ability_info.key) */
input_is_pressed(data, self.static_data.ability_info) input_is_pressed(data, self.static_data.ability_info.input)
&& (self.static_data.energy_drain <= f32::EPSILON && (self.static_data.energy_drain <= f32::EPSILON
|| update.energy.current() > 0) || update.energy.current() > 0)
{ {

22
common/src/states/basic_melee.rs
View File

@ -52,15 +52,15 @@ impl CharacterBehavior for Data {
handle_move(data, &mut update, 0.7); handle_move(data, &mut update, 0.7);
handle_jump(data, &mut update); handle_jump(data, &mut update);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::BasicMelee(_) => {}, // CharacterState::BasicMelee(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Buildup => { StageSection::Buildup => {
@ -162,7 +162,7 @@ impl CharacterBehavior for Data {
}); });
} else { } else {
// Done // Done
if input_is_pressed(data, self.static_data.ability_info) { if input_is_pressed(data, self.static_data.ability_info.input) {
reset_state(self, data, &mut update); reset_state(self, data, &mut update);
} else { } else {
update.character = CharacterState::Wielding; update.character = CharacterState::Wielding;
@ -182,5 +182,5 @@ impl CharacterBehavior for Data {
} }
fn reset_state(data: &Data, join: &JoinData, update: &mut StateUpdate) { fn reset_state(data: &Data, join: &JoinData, update: &mut StateUpdate) {
handle_input(join, update, data.static_data.ability_info.input.unwrap()); handle_input(join, update, data.static_data.ability_info.input);
} }

22
common/src/states/basic_ranged.rs
View File

@ -45,15 +45,15 @@ impl CharacterBehavior for Data {
handle_move(data, &mut update, 0.3); handle_move(data, &mut update, 0.3);
handle_jump(data, &mut update); handle_jump(data, &mut update);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::BasicRanged(_) => {}, // CharacterState::BasicRanged(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Buildup => { StageSection::Buildup => {
@ -111,7 +111,7 @@ impl CharacterBehavior for Data {
}); });
} else { } else {
// Done // Done
if input_is_pressed(data, self.static_data.ability_info) { if input_is_pressed(data, self.static_data.ability_info.input) {
reset_state(self, data, &mut update); reset_state(self, data, &mut update);
} else { } else {
update.character = CharacterState::Wielding; update.character = CharacterState::Wielding;
@ -129,5 +129,5 @@ impl CharacterBehavior for Data {
} }
fn reset_state(data: &Data, join: &JoinData, update: &mut StateUpdate) { fn reset_state(data: &Data, join: &JoinData, update: &mut StateUpdate) {
handle_input(join, update, data.static_data.ability_info.input.unwrap()); handle_input(join, update, data.static_data.ability_info.input);
} }

4
common/src/states/boost.rs
View File

@ -47,7 +47,7 @@ impl CharacterBehavior for Data {
}); });
} else { } else {
// Done // Done
if input_is_pressed(data, self.static_data.ability_info) { if input_is_pressed(data, self.static_data.ability_info.input) {
reset_state(self, data, &mut update); reset_state(self, data, &mut update);
} else { } else {
update.character = CharacterState::Wielding; update.character = CharacterState::Wielding;
@ -59,5 +59,5 @@ impl CharacterBehavior for Data {
} }
fn reset_state(data: &Data, join: &JoinData, update: &mut StateUpdate) { fn reset_state(data: &Data, join: &JoinData, update: &mut StateUpdate) {
handle_input(join, update, data.static_data.ability_info.input.unwrap()); handle_input(join, update, data.static_data.ability_info.input);
} }

22
common/src/states/charged_melee.rs
View File

@ -68,21 +68,21 @@ impl CharacterBehavior for Data {
handle_move(data, &mut update, 0.7); handle_move(data, &mut update, 0.7);
handle_jump(data, &mut update); handle_jump(data, &mut update);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::ChargedMelee(_) => {}, // CharacterState::ChargedMelee(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Charge => { StageSection::Charge => {
if if
/* ability_key_is_pressed(data, self.static_data.ability_info.key) */ /* ability_key_is_pressed(data, self.static_data.ability_info.key) */
input_is_pressed(data, self.static_data.ability_info) input_is_pressed(data, self.static_data.ability_info.input)
&& update.energy.current() as f32 >= self.static_data.energy_cost && update.energy.current() as f32 >= self.static_data.energy_cost
&& self.timer < self.static_data.charge_duration && self.timer < self.static_data.charge_duration
{ {
@ -111,7 +111,7 @@ impl CharacterBehavior for Data {
}); });
} else if } else if
/* ability_key_is_pressed(data, self.static_data.ability_info.key) */ /* ability_key_is_pressed(data, self.static_data.ability_info.key) */
input_is_pressed(data, self.static_data.ability_info) input_is_pressed(data, self.static_data.ability_info.input)
&& update.energy.current() as f32 >= self.static_data.energy_cost && update.energy.current() as f32 >= self.static_data.energy_cost
{ {
// Maintains charge // Maintains charge

24
common/src/states/charged_ranged.rs
View File

@ -68,15 +68,15 @@ impl CharacterBehavior for Data {
handle_move(data, &mut update, self.static_data.move_speed); handle_move(data, &mut update, self.static_data.move_speed);
handle_jump(data, &mut update); handle_jump(data, &mut update);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::ChargedRanged(_) => {}, // CharacterState::ChargedRanged(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Buildup => { StageSection::Buildup => {
@ -101,7 +101,7 @@ impl CharacterBehavior for Data {
StageSection::Charge => { StageSection::Charge => {
if if
/* \!ability_key_is_pressed(data, self.static_data.ability_info.key) */ /* \!ability_key_is_pressed(data, self.static_data.ability_info.key) */
!input_is_pressed(data, self.static_data.ability_info) && !self.exhausted { !input_is_pressed(data, self.static_data.ability_info.input) && !self.exhausted {
let charge_frac = (self.timer.as_secs_f32() let charge_frac = (self.timer.as_secs_f32()
/ self.static_data.charge_duration.as_secs_f32()) / self.static_data.charge_duration.as_secs_f32())
.min(1.0); .min(1.0);
@ -162,7 +162,7 @@ impl CharacterBehavior for Data {
..*self ..*self
}); });
} else if self.timer < self.static_data.charge_duration } else if self.timer < self.static_data.charge_duration
&& /*ability_key_is_pressed(data, self.static_data.ability_info.key)*/ input_is_pressed(data, self.static_data.ability_info) && /*ability_key_is_pressed(data, self.static_data.ability_info.key)*/ input_is_pressed(data, self.static_data.ability_info.input)
{ {
// Charges // Charges
update.character = CharacterState::ChargedRanged(Data { update.character = CharacterState::ChargedRanged(Data {
@ -184,7 +184,7 @@ impl CharacterBehavior for Data {
}); });
} else if } else if
/* ability_key_is_pressed(data, self.static_data.ability_info.key) */ /* ability_key_is_pressed(data, self.static_data.ability_info.key) */
input_is_pressed(data, self.static_data.ability_info) { input_is_pressed(data, self.static_data.ability_info.input) {
// Holds charge // Holds charge
update.character = CharacterState::ChargedRanged(Data { update.character = CharacterState::ChargedRanged(Data {
timer: self timer: self

11
common/src/states/climb.rs
View File

@ -1,8 +1,11 @@
use crate::{ use crate::{
comp::{CharacterState, Climb, EnergySource, Ori, StateUpdate}, comp::{CharacterState, Climb, EnergySource, InputKind, Ori, StateUpdate},
consts::GRAVITY, consts::GRAVITY,
event::LocalEvent, event::LocalEvent,
states::behavior::{CharacterBehavior, JoinData}, states::{
behavior::{CharacterBehavior, JoinData},
utils::*,
},
util::Dir, util::Dir,
}; };
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -29,7 +32,9 @@ impl CharacterBehavior for Data {
) { ) {
(wall_dir, climb) (wall_dir, climb)
} else { } else {
if data.inputs.jump.is_pressed() { if
/* data.inputs.jump.is_pressed() */
input_is_pressed(data, InputKind::Jump) {
// They've climbed atop something, give them a boost // They've climbed atop something, give them a boost
update update
.local_events .local_events

22
common/src/states/combo_melee.rs
View File

@ -121,15 +121,15 @@ impl CharacterBehavior for Data {
handle_orientation(data, &mut update, 1.0); handle_orientation(data, &mut update, 1.0);
handle_move(data, &mut update, 0.3); handle_move(data, &mut update, 0.3);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, self.static_data.is_interruptible); // handle_interrupt(data, &mut update, self.static_data.is_interruptible);
match update.character { // match update.character {
CharacterState::ComboMelee(_) => {}, // CharacterState::ComboMelee(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
let stage_index = (self.stage - 1) as usize; let stage_index = (self.stage - 1) as usize;
@ -269,7 +269,7 @@ impl CharacterBehavior for Data {
}); });
} else { } else {
// Done // Done
if input_is_pressed(data, self.static_data.ability_info) { if input_is_pressed(data, self.static_data.ability_info.input) {
reset_state(self, data, &mut update); reset_state(self, data, &mut update);
} else { } else {
update.character = CharacterState::Wielding; update.character = CharacterState::Wielding;
@ -289,7 +289,7 @@ impl CharacterBehavior for Data {
} }
fn reset_state(data: &Data, join: &JoinData, update: &mut StateUpdate) { fn reset_state(data: &Data, join: &JoinData, update: &mut StateUpdate) {
handle_input(join, update, data.static_data.ability_info.input.unwrap()); handle_input(join, update, data.static_data.ability_info.input);
if let CharacterState::ComboMelee(c) = &mut update.character { if let CharacterState::ComboMelee(c) = &mut update.character {
c.stage = (data.stage % data.static_data.num_stages) + 1; c.stage = (data.stage % data.static_data.num_stages) + 1;

22
common/src/states/dash_melee.rs
View File

@ -74,15 +74,15 @@ impl CharacterBehavior for Data {
handle_orientation(data, &mut update, 1.0); handle_orientation(data, &mut update, 1.0);
handle_move(data, &mut update, 0.1); handle_move(data, &mut update, 0.1);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, self.static_data.is_interruptible); // handle_interrupt(data, &mut update, self.static_data.is_interruptible);
match update.character { // match update.character {
CharacterState::DashMelee(_) => {}, // CharacterState::DashMelee(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Buildup => { StageSection::Buildup => {
@ -101,7 +101,7 @@ impl CharacterBehavior for Data {
auto_charge: /*\!ability_key_is_pressed( auto_charge: /*\!ability_key_is_pressed(
data, data,
self.static_data.ability_info.key, self.static_data.ability_info.key,
)*/input_is_pressed(data, self.static_data.ability_info), )*/input_is_pressed(data, self.static_data.ability_info.input),
timer: Duration::default(), timer: Duration::default(),
stage_section: StageSection::Charge, stage_section: StageSection::Charge,
..*self ..*self
@ -111,7 +111,7 @@ impl CharacterBehavior for Data {
StageSection::Charge => { StageSection::Charge => {
if (self.static_data.infinite_charge if (self.static_data.infinite_charge
|| self.timer < self.static_data.charge_duration) || self.timer < self.static_data.charge_duration)
&& (/* ability_key_is_pressed(data, self.static_data.ability_info.key) */input_is_pressed(data, self.static_data.ability_info) && (/* ability_key_is_pressed(data, self.static_data.ability_info.key) */input_is_pressed(data, self.static_data.ability_info.input)
|| (self.auto_charge && self.timer < self.static_data.charge_duration)) || (self.auto_charge && self.timer < self.static_data.charge_duration))
&& update.energy.current() > 0 && update.energy.current() > 0
{ {

20
common/src/states/healing_beam.rs
View File

@ -54,15 +54,15 @@ impl CharacterBehavior for Data {
handle_move(data, &mut update, 0.4); handle_move(data, &mut update, 0.4);
handle_jump(data, &mut update); handle_jump(data, &mut update);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::HealingBeam(_) => {}, // CharacterState::HealingBeam(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Buildup => { StageSection::Buildup => {
@ -93,7 +93,7 @@ impl CharacterBehavior for Data {
StageSection::Cast => { StageSection::Cast => {
if if
/* ability_key_is_pressed(data, self.static_data.ability_info.key) */ /* ability_key_is_pressed(data, self.static_data.ability_info.key) */
input_is_pressed(data, self.static_data.ability_info) { input_is_pressed(data, self.static_data.ability_info.input) {
let speed = let speed =
self.static_data.range / self.static_data.beam_duration.as_secs_f32(); self.static_data.range / self.static_data.beam_duration.as_secs_f32();
let heal = AttackEffect::new( let heal = AttackEffect::new(

18
common/src/states/leap_melee.rs
View File

@ -58,15 +58,15 @@ impl CharacterBehavior for Data {
handle_move(data, &mut update, 0.3); handle_move(data, &mut update, 0.3);
handle_jump(data, &mut update); handle_jump(data, &mut update);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::LeapMelee(_) => {}, // CharacterState::LeapMelee(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
// Delay before leaping into the air // Delay before leaping into the air

18
common/src/states/repeater_ranged.rs
View File

@ -53,15 +53,15 @@ impl CharacterBehavior for Data {
handle_move(data, &mut update, 1.0); handle_move(data, &mut update, 1.0);
handle_jump(data, &mut update); handle_jump(data, &mut update);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::RepeaterRanged(_) => {}, // CharacterState::RepeaterRanged(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Movement => { StageSection::Movement => {

28
common/src/states/roll.rs
View File

@ -1,5 +1,5 @@
use crate::{ use crate::{
comp::{CharacterState, StateUpdate}, comp::{CharacterState, InputKind, StateUpdate},
states::{ states::{
behavior::{CharacterBehavior, JoinData}, behavior::{CharacterBehavior, JoinData},
utils::*, utils::*,
@ -37,7 +37,7 @@ pub struct Data {
/// Was sneaking /// Was sneaking
pub was_sneak: bool, pub was_sneak: bool,
/// Was in state with combo /// Was in state with combo
pub was_combo: Option<(AbilityKey, u32)>, pub was_combo: Option<(InputKind, u32)>,
} }
impl CharacterBehavior for Data { impl CharacterBehavior for Data {
@ -114,17 +114,19 @@ impl CharacterBehavior for Data {
}); });
} else { } else {
// Done // Done
if let Some((key, stage)) = self.was_combo { if let Some((input, stage)) = self.was_combo {
if ability_key_is_pressed(data, key) { // if ability_key_is_pressed(data, key) {
handle_interrupt(data, &mut update, true); // handle_interrupt(data, &mut update, true);
// If other states are introduced that progress through stages, add them // // If other states are introduced that progress
// here // through stages, add them
if let CharacterState::ComboMelee(c) = &mut update.character { // // here
c.stage = stage; // if let CharacterState::ComboMelee(c) = &mut
} // update.character {
} else { // c.stage = stage;
update.character = CharacterState::Wielding; // }
} // } else {
// update.character = CharacterState::Wielding;
// }
} else if self.was_wielded { } else if self.was_wielded {
update.character = CharacterState::Wielding; update.character = CharacterState::Wielding;
} else if self.was_sneak { } else if self.was_sneak {

18
common/src/states/shockwave.rs
View File

@ -60,15 +60,15 @@ impl CharacterBehavior for Data {
let mut update = StateUpdate::from(data); let mut update = StateUpdate::from(data);
handle_move(data, &mut update, self.static_data.move_efficiency); handle_move(data, &mut update, self.static_data.move_efficiency);
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, false); // handle_interrupt(data, &mut update, false);
match update.character { // match update.character {
CharacterState::Shockwave(_) => {}, // CharacterState::Shockwave(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Buildup => { StageSection::Buildup => {

20
common/src/states/spin_melee.rs
View File

@ -75,15 +75,15 @@ impl CharacterBehavior for Data {
}, },
} }
if !ability_key_is_pressed(data, self.static_data.ability_info.key) { // if !ability_key_is_pressed(data, self.static_data.ability_info.key) {
handle_interrupt(data, &mut update, self.static_data.is_interruptible); // handle_interrupt(data, &mut update, self.static_data.is_interruptible);
match update.character { // match update.character {
CharacterState::SpinMelee(_) => {}, // CharacterState::SpinMelee(_) => {},
_ => { // _ => {
return update; // return update;
}, // },
} // }
} // }
match self.stage_section { match self.stage_section {
StageSection::Buildup => { StageSection::Buildup => {
@ -179,7 +179,7 @@ impl CharacterBehavior for Data {
} else if update.energy.current() as f32 >= self.static_data.energy_cost } else if update.energy.current() as f32 >= self.static_data.energy_cost
&& (self.spins_remaining != 0 && (self.spins_remaining != 0
|| (self.static_data.is_infinite || (self.static_data.is_infinite
&& /*ability_key_is_pressed(data, self.static_data.ability_info.key)*/ input_is_pressed(data, self.static_data.ability_info))) && /*ability_key_is_pressed(data, self.static_data.ability_info.key)*/ input_is_pressed(data, self.static_data.ability_info.input)))
{ {
let new_spins_remaining = if self.static_data.is_infinite { let new_spins_remaining = if self.static_data.is_infinite {
self.spins_remaining self.spins_remaining

149
common/src/states/utils.rs
View File

@ -180,7 +180,12 @@ impl Body {
pub fn handle_move(data: &JoinData, update: &mut StateUpdate, efficiency: f32) { pub fn handle_move(data: &JoinData, update: &mut StateUpdate, efficiency: f32) {
if let Some(depth) = data.physics.in_liquid { if let Some(depth) = data.physics.in_liquid {
swim_move(data, update, efficiency, depth); swim_move(data, update, efficiency, depth);
} else if data.inputs.fly.is_pressed() && !data.physics.on_ground && data.body.can_fly() { } else if
/* data.inputs.fly.is_pressed() */
input_is_pressed(data, InputKind::Fly)
&& !data.physics.on_ground
&& data.body.can_fly()
{
fly_move(data, update, efficiency); fly_move(data, update, efficiency);
} else { } else {
basic_move(data, update, efficiency); basic_move(data, update, efficiency);
@ -314,11 +319,11 @@ fn fly_move(data: &JoinData, update: &mut StateUpdate, efficiency: f32) {
/// First checks whether `primary`, `secondary`, `ability3`, or `ability4` input /// First checks whether `primary`, `secondary`, `ability3`, or `ability4` input
/// is pressed, then attempts to go into Equipping state, otherwise Idle /// is pressed, then attempts to go into Equipping state, otherwise Idle
pub fn handle_wield(data: &JoinData, update: &mut StateUpdate) { pub fn handle_wield(data: &JoinData, update: &mut StateUpdate) {
if // if
// data.inputs.primary.is_pressed() || data.inputs.secondary.is_pressed() || // // data.inputs.primary.is_pressed() || data.inputs.secondary.is_pressed()
data.inputs.ability3.is_pressed() || data.inputs.ability4.is_pressed() { // || data.inputs.ability3.is_pressed() ||
attempt_wield(data, update); // data.inputs.ability4.is_pressed() { attempt_wield(data, update);
} // }
} }
/// If a tool is equipped, goes into Equipping state, otherwise goes to Idle /// If a tool is equipped, goes into Equipping state, otherwise goes to Idle
@ -416,7 +421,9 @@ pub fn attempt_glide_wield(data: &JoinData, update: &mut StateUpdate) {
/// Checks that player can jump and sends jump event if so /// Checks that player can jump and sends jump event if so
pub fn handle_jump(data: &JoinData, update: &mut StateUpdate) { pub fn handle_jump(data: &JoinData, update: &mut StateUpdate) {
if data.inputs.jump.is_pressed() if
/* data.inputs.jump.is_pressed() */
input_is_pressed(data, InputKind::Jump)
&& data.physics.on_ground && data.physics.on_ground
&& !data && !data
.physics .physics
@ -430,19 +437,14 @@ pub fn handle_jump(data: &JoinData, update: &mut StateUpdate) {
} }
} }
fn handle_ability_pressed( fn handle_ability_pressed(data: &JoinData, update: &mut StateUpdate, input: InputKind) {
data: &JoinData,
update: &mut StateUpdate,
ability_key: AbilityKey,
input: Option<InputKind>,
) {
let hands = |equip_slot| match data.inventory.equipped(equip_slot).map(|i| i.kind()) { let hands = |equip_slot| match data.inventory.equipped(equip_slot).map(|i| i.kind()) {
Some(ItemKind::Tool(tool)) => Some(tool.hands), Some(ItemKind::Tool(tool)) => Some(tool.hands),
_ => None, _ => None,
}; };
// Mouse1 and Skill1 always use the MainHand slot // Mouse1 and Skill1 always use the MainHand slot
let always_main_hand = matches!(ability_key, AbilityKey::Mouse1 | AbilityKey::Skill1); let always_main_hand = matches!(input, InputKind::Primary | InputKind::Ability(0));
// skill_index used to select ability for the AbilityKey::Skill2 input // skill_index used to select ability for the AbilityKey::Skill2 input
let (equip_slot, skill_index) = if always_main_hand { let (equip_slot, skill_index) = if always_main_hand {
(Some(EquipSlot::Mainhand), 0) (Some(EquipSlot::Mainhand), 0)
@ -466,16 +468,16 @@ fn handle_ability_pressed(
.inventory .inventory
.equipped(equip_slot) .equipped(equip_slot)
.map(|i| &i.item_config_expect().abilities) .map(|i| &i.item_config_expect().abilities)
.and_then(|abilities| match ability_key { .and_then(|abilities| match input {
AbilityKey::Mouse1 => Some(abilities.primary.clone()), InputKind::Primary => Some(abilities.primary.clone()),
AbilityKey::Mouse2 => Some(abilities.secondary.clone()), InputKind::Secondary => Some(abilities.secondary.clone()),
AbilityKey::Skill1 => abilities.abilities.get(0).cloned().and_then(unlocked), InputKind::Ability(0) => abilities.abilities.get(0).cloned().and_then(unlocked),
AbilityKey::Skill2 => abilities InputKind::Ability(_) => abilities
.abilities .abilities
.get(skill_index) .get(skill_index)
.cloned() .cloned()
.and_then(unlocked), .and_then(unlocked),
AbilityKey::Dodge => None, InputKind::Roll | InputKind::Jump | InputKind::Glide | InputKind::Fly => None,
}) })
.map(|a| { .map(|a| {
let tool = unwrap_tool_data(data, equip_slot).map(|t| t.kind); let tool = unwrap_tool_data(data, equip_slot).map(|t| t.kind);
@ -485,12 +487,7 @@ fn handle_ability_pressed(
{ {
update.character = ( update.character = (
&ability, &ability,
AbilityInfo::from_key( AbilityInfo::from_input(data, matches!(equip_slot, EquipSlot::Offhand), input),
data,
ability_key,
matches!(equip_slot, EquipSlot::Offhand),
input,
),
) )
.into(); .into();
} }
@ -499,10 +496,13 @@ fn handle_ability_pressed(
pub fn handle_input(data: &JoinData, update: &mut StateUpdate, input: InputKind) { pub fn handle_input(data: &JoinData, update: &mut StateUpdate, input: InputKind) {
match input { match input {
InputKind::Primary => handle_ability_pressed(data, update, AbilityKey::Mouse1, Some(input)), InputKind::Primary | InputKind::Secondary | InputKind::Ability(_) => {
InputKind::Secondary => { handle_ability_pressed(data, update, input)
handle_ability_pressed(data, update, AbilityKey::Mouse2, Some(input))
}, },
InputKind::Roll => handle_dodge_input(data, update),
InputKind::Jump => handle_jump(data, update),
InputKind::Glide => attempt_glide_wield(data, update),
InputKind::Fly => {},
} }
} }
@ -513,34 +513,10 @@ pub fn attempt_input(data: &JoinData, update: &mut StateUpdate) {
} }
} }
/*pub fn handle_ability1_input(data: &JoinData, update: &mut StateUpdate) {
if data.inputs.primary.is_pressed() {
handle_ability_pressed(data, update, AbilityKey::Mouse1);
}
}*/
// pub fn handle_ability2_input(data: &JoinData, update: &mut StateUpdate) {
// if data.inputs.secondary.is_pressed() {
// handle_ability_pressed(data, update, AbilityKey::Mouse2, None);
// }
// }
pub fn handle_ability3_input(data: &JoinData, update: &mut StateUpdate) {
if data.inputs.ability3.is_pressed() {
handle_ability_pressed(data, update, AbilityKey::Skill1, None);
}
}
pub fn handle_ability4_input(data: &JoinData, update: &mut StateUpdate) {
if data.inputs.ability4.is_pressed() {
handle_ability_pressed(data, update, AbilityKey::Skill2, None);
}
}
/// Checks that player can perform a dodge, then /// Checks that player can perform a dodge, then
/// attempts to perform their dodge ability /// attempts to perform their dodge ability
pub fn handle_dodge_input(data: &JoinData, update: &mut StateUpdate) { pub fn handle_dodge_input(data: &JoinData, update: &mut StateUpdate) {
if data.inputs.roll.is_pressed() && data.body.is_humanoid() { if input_is_pressed(data, InputKind::Roll) && data.body.is_humanoid() {
if let Some(ability) = data if let Some(ability) = data
.inventory .inventory
.equipped(EquipSlot::Mainhand) .equipped(EquipSlot::Mainhand)
@ -555,17 +531,17 @@ pub fn handle_dodge_input(data: &JoinData, update: &mut StateUpdate) {
if let CharacterState::ComboMelee(c) = data.character { if let CharacterState::ComboMelee(c) = data.character {
update.character = ( update.character = (
&ability, &ability,
AbilityInfo::from_key(data, AbilityKey::Dodge, false, None), AbilityInfo::from_input(data, false, InputKind::Roll),
) )
.into(); .into();
if let CharacterState::Roll(roll) = &mut update.character { if let CharacterState::Roll(roll) = &mut update.character {
roll.was_combo = Some((c.static_data.ability_info.key, c.stage)); roll.was_combo = Some((c.static_data.ability_info.input, c.stage));
roll.was_wielded = true; roll.was_wielded = true;
} }
} else if data.character.is_wield() { } else if data.character.is_wield() {
update.character = ( update.character = (
&ability, &ability,
AbilityInfo::from_key(data, AbilityKey::Dodge, false, None), AbilityInfo::from_input(data, false, InputKind::Roll),
) )
.into(); .into();
if let CharacterState::Roll(roll) = &mut update.character { if let CharacterState::Roll(roll) = &mut update.character {
@ -574,7 +550,7 @@ pub fn handle_dodge_input(data: &JoinData, update: &mut StateUpdate) {
} else if data.character.is_stealthy() { } else if data.character.is_stealthy() {
update.character = ( update.character = (
&ability, &ability,
AbilityInfo::from_key(data, AbilityKey::Dodge, false, None), AbilityInfo::from_input(data, false, InputKind::Roll),
) )
.into(); .into();
if let CharacterState::Roll(roll) = &mut update.character { if let CharacterState::Roll(roll) = &mut update.character {
@ -583,7 +559,7 @@ pub fn handle_dodge_input(data: &JoinData, update: &mut StateUpdate) {
} else { } else {
update.character = ( update.character = (
&ability, &ability,
AbilityInfo::from_key(data, AbilityKey::Dodge, false, None), AbilityInfo::from_input(data, false, InputKind::Roll),
) )
.into(); .into();
} }
@ -621,35 +597,14 @@ pub fn handle_interrupt(data: &JoinData, update: &mut StateUpdate, attacks_inter
if attacks_interrupt { if attacks_interrupt {
//handle_ability1_input(data, update); //handle_ability1_input(data, update);
// handle_ability2_input(data, update); // handle_ability2_input(data, update);
handle_ability3_input(data, update); // handle_ability3_input(data, update);
handle_ability4_input(data, update); // handle_ability4_input(data, update);
} }
handle_dodge_input(data, update); handle_dodge_input(data, update);
} }
pub fn input_is_pressed(data: &JoinData, ability_info: AbilityInfo) -> bool { pub fn input_is_pressed(data: &JoinData, input: InputKind) -> bool {
//data.controller.queued_inputs.contains(ability_info.input) data.controller.queued_inputs.contains(&input)
ability_info
.input
.map_or(false, |i| data.controller.queued_inputs.contains(&i))
}
pub fn ability_key_is_pressed(data: &JoinData, ability_key: AbilityKey) -> bool {
match ability_key {
AbilityKey::Mouse1 =>
/* data.inputs.primary.is_pressed() */
{
false
},
AbilityKey::Mouse2 =>
/* data.inputs.secondary.is_pressed() */
{
false
},
AbilityKey::Skill1 => data.inputs.ability3.is_pressed(),
AbilityKey::Skill2 => data.inputs.ability4.is_pressed(),
AbilityKey::Dodge => data.inputs.roll.is_pressed(),
}
} }
/// Determines what portion a state is in. Used in all attacks (eventually). Is /// Determines what portion a state is in. Used in all attacks (eventually). Is
@ -666,15 +621,6 @@ pub enum StageSection {
Movement, Movement,
} }
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub enum AbilityKey {
Mouse1,
Mouse2,
Skill1,
Skill2,
Dodge,
}
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub enum ForcedMovement { pub enum ForcedMovement {
Forward { Forward {
@ -713,17 +659,11 @@ impl MovementDirection {
pub struct AbilityInfo { pub struct AbilityInfo {
pub tool: Option<ToolKind>, pub tool: Option<ToolKind>,
pub hand: Option<HandInfo>, pub hand: Option<HandInfo>,
pub key: AbilityKey, pub input: InputKind,
pub input: Option<InputKind>,
} }
impl AbilityInfo { impl AbilityInfo {
pub fn from_key( pub fn from_input(data: &JoinData, from_offhand: bool, input: InputKind) -> Self {
data: &JoinData,
key: AbilityKey,
from_offhand: bool,
input: Option<InputKind>,
) -> Self {
let tool_data = if from_offhand { let tool_data = if from_offhand {
unwrap_tool_data(data, EquipSlot::Offhand) unwrap_tool_data(data, EquipSlot::Offhand)
} else { } else {
@ -738,12 +678,7 @@ impl AbilityInfo {
) )
}; };
Self { Self { tool, hand, input }
tool,
hand,
key,
input,
}
} }
} }

4
common/src/states/wielding.rs
View File

@ -18,8 +18,8 @@ impl CharacterBehavior for Data {
handle_climb(&data, &mut update); handle_climb(&data, &mut update);
//handle_ability1_input(&data, &mut update); //handle_ability1_input(&data, &mut update);
// handle_ability2_input(&data, &mut update); // handle_ability2_input(&data, &mut update);
handle_ability3_input(&data, &mut update); // handle_ability3_input(&data, &mut update);
handle_ability4_input(&data, &mut update); // handle_ability4_input(&data, &mut update);
handle_dodge_input(&data, &mut update); handle_dodge_input(&data, &mut update);
attempt_input(&data, &mut update); attempt_input(&data, &mut update);

9
common/sys/src/controller.rs
View File

@ -34,15 +34,6 @@ impl<'a> System<'a> for Sys {
for (entity, controller) in (&read_data.entities, &mut controllers).join() { for (entity, controller) in (&read_data.entities, &mut controllers).join() {
let mut inputs = &mut controller.inputs; let mut inputs = &mut controller.inputs;
// Note(imbris): I avoided incrementing the duration with inputs.tick() because
// this is being done manually in voxygen right now so it would double up on
// speed of time.
// Perhaphs the duration aspects of inputs could be
// calculated exclusively on the server (since the client can't be
// trusted anyway). It needs to be considered if these calculations
// being on the client are critical for responsiveness/client-side prediction.
inputs.tick_freshness();
// Update `inputs.move_dir`. // Update `inputs.move_dir`.
inputs.move_dir = if inputs.move_dir.magnitude_squared() > 1.0 { inputs.move_dir = if inputs.move_dir.magnitude_squared() > 1.0 {
// Cap move_dir to 1 // Cap move_dir to 1

412
server/src/sys/agent.rs
View File

@ -571,16 +571,34 @@ impl<'a> AgentData<'a> {
if let Some((travel_to, _destination)) = &agent.rtsim_controller.travel_to { if let Some((travel_to, _destination)) = &agent.rtsim_controller.travel_to {
// if it has an rtsim destination and can fly then it should // if it has an rtsim destination and can fly then it should
// if it is flying and bumps something above it then it should move down // if it is flying and bumps something above it then it should move down
controller.inputs.fly.set_state( if self.traversal_config.can_fly
self.traversal_config.can_fly && !read_data
&& !read_data .terrain
.terrain .ray(self.pos.0, self.pos.0 + (Vec3::unit_z() * 3.0))
.ray(self.pos.0, self.pos.0 + (Vec3::unit_z() * 3.0)) .until(Block::is_solid)
.until(Block::is_solid) .cast()
.cast() .1
.1 .map_or(true, |b| b.is_some())
.map_or(true, |b| b.is_some()), {
); controller.actions.push(ControlAction::StartInput {
input: InputKind::Fly,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Fly))
}
// controller.inputs.fly.set_state(
// self.traversal_config.can_fly
// && !read_data
// .terrain
// .ray(self.pos.0, self.pos.0 + (Vec3::unit_z() * 3.0))
// .until(Block::is_solid)
// .cast()
// .1
// .map_or(true, |b| b.is_some()),
// );
if let Some((bearing, speed)) = agent.chaser.chase( if let Some((bearing, speed)) = agent.chaser.chase(
&*read_data.terrain, &*read_data.terrain,
self.pos.0, self.pos.0,
@ -594,10 +612,22 @@ impl<'a> AgentData<'a> {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) bearing.xy().try_normalized().unwrap_or_else(Vec2::zero)
* speed.min(agent.rtsim_controller.speed_factor); * speed.min(agent.rtsim_controller.speed_factor);
controller.inputs.jump.set_state( if bearing.z > 1.5
bearing.z > 1.5 || self.traversal_config.can_fly && self.traversal_config.on_ground
|| self.traversal_config.can_fly && self.traversal_config.on_ground, {
); controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(
// bearing.z > 1.5
// || self.traversal_config.can_fly && self.traversal_config.on_ground,
// );
controller.inputs.climb = Some(comp::Climb::Up); controller.inputs.climb = Some(comp::Climb::Up);
//.filter(|_| bearing.z > 0.1 || self.physics_state.in_liquid.is_some()); //.filter(|_| bearing.z > 0.1 || self.physics_state.in_liquid.is_some());
@ -925,7 +955,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
agent.action_timer += dt.0; agent.action_timer += dt.0;
@ -1100,7 +1140,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
@ -1108,7 +1158,11 @@ impl<'a> AgentData<'a> {
&& dist_sqrd < 16.0f32.powi(2) && dist_sqrd < 16.0f32.powi(2)
&& thread_rng().gen::<f32>() < 0.02 && thread_rng().gen::<f32>() < 0.02
{ {
controller.inputs.roll.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Roll,
target: None,
});
// controller.inputs.roll.set_state(true);
} }
} else { } else {
agent.target = None; agent.target = None;
@ -1137,7 +1191,11 @@ impl<'a> AgentData<'a> {
&& self.energy.current() > 800 && self.energy.current() > 800
&& thread_rng().gen_bool(0.5) && thread_rng().gen_bool(0.5)
{ {
controller.inputs.ability3.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Ability(0),
target: None,
});
// controller.inputs.ability3.set_state(true);
agent.action_timer += dt.0; agent.action_timer += dt.0;
} else { } else {
controller.actions.push(ControlAction::StartInput { controller.actions.push(ControlAction::StartInput {
@ -1160,14 +1218,28 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
if self.body.map(|b| b.is_humanoid()).unwrap_or(false) if self.body.map(|b| b.is_humanoid()).unwrap_or(false)
&& dist_sqrd < 16.0f32.powi(2) && dist_sqrd < 16.0f32.powi(2)
&& thread_rng().gen::<f32>() < 0.02 && thread_rng().gen::<f32>() < 0.02
{ {
controller.inputs.roll.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Roll,
target: None,
});
// controller.inputs.roll.set_state(true);
} }
} else { } else {
agent.target = None; agent.target = None;
@ -1196,7 +1268,11 @@ impl<'a> AgentData<'a> {
&& self.energy.current() > 700 && self.energy.current() > 700
&& thread_rng().gen_bool(0.9) && thread_rng().gen_bool(0.9)
{ {
controller.inputs.ability3.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Ability(0),
target: None,
});
// controller.inputs.ability3.set_state(true);
agent.action_timer += dt.0; agent.action_timer += dt.0;
} else { } else {
controller.actions.push(ControlAction::StartInput { controller.actions.push(ControlAction::StartInput {
@ -1226,7 +1302,11 @@ impl<'a> AgentData<'a> {
.has_skill(Skill::Hammer(HammerSkill::UnlockLeap)) .has_skill(Skill::Hammer(HammerSkill::UnlockLeap))
&& agent.action_timer > 5.0 && agent.action_timer > 5.0
{ {
controller.inputs.ability3.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Ability(0),
target: None,
});
// controller.inputs.ability3.set_state(true);
agent.action_timer = 0.0; agent.action_timer = 0.0;
} else { } else {
agent.action_timer += dt.0; agent.action_timer += dt.0;
@ -1234,7 +1314,17 @@ impl<'a> AgentData<'a> {
} else { } else {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} }
@ -1242,7 +1332,11 @@ impl<'a> AgentData<'a> {
&& dist_sqrd < 16.0f32.powi(2) && dist_sqrd < 16.0f32.powi(2)
&& thread_rng().gen::<f32>() < 0.02 && thread_rng().gen::<f32>() < 0.02
{ {
controller.inputs.roll.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Roll,
target: None,
});
// controller.inputs.roll.set_state(true);
} }
} else { } else {
agent.target = None; agent.target = None;
@ -1258,7 +1352,11 @@ impl<'a> AgentData<'a> {
&& agent.action_timer < 2.0 && agent.action_timer < 2.0
&& self.energy.current() > 600 && self.energy.current() > 600
{ {
controller.inputs.ability3.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Ability(0),
target: None,
});
// controller.inputs.ability3.set_state(true);
agent.action_timer += dt.0; agent.action_timer += dt.0;
} else if agent.action_timer > 2.0 { } else if agent.action_timer > 2.0 {
agent.action_timer = 0.0; agent.action_timer = 0.0;
@ -1297,7 +1395,17 @@ impl<'a> AgentData<'a> {
} else { } else {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} }
@ -1305,7 +1413,11 @@ impl<'a> AgentData<'a> {
&& dist_sqrd < 16.0f32.powi(2) && dist_sqrd < 16.0f32.powi(2)
&& thread_rng().gen::<f32>() < 0.02 && thread_rng().gen::<f32>() < 0.02
{ {
controller.inputs.roll.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Roll,
target: None,
});
// controller.inputs.roll.set_state(true);
} }
} else { } else {
agent.target = None; agent.target = None;
@ -1315,7 +1427,11 @@ impl<'a> AgentData<'a> {
if self.body.map(|b| b.is_humanoid()).unwrap_or(false) if self.body.map(|b| b.is_humanoid()).unwrap_or(false)
&& dist_sqrd < (2.0 * min_attack_dist * self.scale).powi(2) && dist_sqrd < (2.0 * min_attack_dist * self.scale).powi(2)
{ {
controller.inputs.roll.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Roll,
target: None,
});
// controller.inputs.roll.set_state(true);
} else if dist_sqrd < MAX_CHASE_DIST.powi(2) { } else if dist_sqrd < MAX_CHASE_DIST.powi(2) {
if let Some((bearing, speed)) = agent.chaser.chase( if let Some((bearing, speed)) = agent.chaser.chase(
&*terrain, &*terrain,
@ -1358,7 +1474,11 @@ impl<'a> AgentData<'a> {
.actions .actions
.push(ControlAction::CancelInput(InputKind::Secondary)); .push(ControlAction::CancelInput(InputKind::Secondary));
// controller.inputs.secondary.set_state(false); // controller.inputs.secondary.set_state(false);
controller.inputs.ability3.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Ability(0),
target: None,
});
// controller.inputs.ability3.set_state(true);
agent.action_timer += dt.0; agent.action_timer += dt.0;
} else { } else {
controller controller
@ -1375,7 +1495,17 @@ impl<'a> AgentData<'a> {
} else { } else {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} }
@ -1383,7 +1513,11 @@ impl<'a> AgentData<'a> {
&& dist_sqrd < 16.0f32.powi(2) && dist_sqrd < 16.0f32.powi(2)
&& thread_rng().gen::<f32>() < 0.02 && thread_rng().gen::<f32>() < 0.02
{ {
controller.inputs.roll.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Roll,
target: None,
});
// controller.inputs.roll.set_state(true);
} }
} else if can_see_tgt(&*terrain, self.pos, tgt_pos, dist_sqrd) { } else if can_see_tgt(&*terrain, self.pos, tgt_pos, dist_sqrd) {
if let Some((bearing, speed)) = agent.chaser.chase( if let Some((bearing, speed)) = agent.chaser.chase(
@ -1398,7 +1532,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -1409,7 +1553,11 @@ impl<'a> AgentData<'a> {
if self.body.map(|b| b.is_humanoid()).unwrap_or(false) if self.body.map(|b| b.is_humanoid()).unwrap_or(false)
&& dist_sqrd < (min_attack_dist * self.scale).powi(2) && dist_sqrd < (min_attack_dist * self.scale).powi(2)
{ {
controller.inputs.roll.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Roll,
target: None,
});
// controller.inputs.roll.set_state(true);
} else if dist_sqrd < (5.0 * min_attack_dist * self.scale).powi(2) { } else if dist_sqrd < (5.0 * min_attack_dist * self.scale).powi(2) {
if agent.action_timer < 1.5 { if agent.action_timer < 1.5 {
controller.inputs.move_dir = (tgt_pos.0 - self.pos.0) controller.inputs.move_dir = (tgt_pos.0 - self.pos.0)
@ -1435,7 +1583,11 @@ impl<'a> AgentData<'a> {
&& self.energy.current() > 800 && self.energy.current() > 800
&& thread_rng().gen::<f32>() > 0.8 && thread_rng().gen::<f32>() > 0.8
{ {
controller.inputs.ability3.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Ability(0),
target: None,
});
// controller.inputs.ability3.set_state(true);
} else if self.energy.current() > 10 { } else if self.energy.current() > 10 {
controller.actions.push(ControlAction::StartInput { controller.actions.push(ControlAction::StartInput {
input: InputKind::Secondary, input: InputKind::Secondary,
@ -1475,7 +1627,17 @@ impl<'a> AgentData<'a> {
} else { } else {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} }
@ -1483,7 +1645,11 @@ impl<'a> AgentData<'a> {
&& dist_sqrd < 16.0f32.powi(2) && dist_sqrd < 16.0f32.powi(2)
&& thread_rng().gen::<f32>() < 0.02 && thread_rng().gen::<f32>() < 0.02
{ {
controller.inputs.roll.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Roll,
target: None,
});
// controller.inputs.roll.set_state(true);
} }
} else if can_see_tgt(&*terrain, self.pos, tgt_pos, dist_sqrd) { } else if can_see_tgt(&*terrain, self.pos, tgt_pos, dist_sqrd) {
if let Some((bearing, speed)) = agent.chaser.chase( if let Some((bearing, speed)) = agent.chaser.chase(
@ -1498,7 +1664,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -1517,7 +1693,11 @@ impl<'a> AgentData<'a> {
//controller.inputs.primary.set_state(true); //controller.inputs.primary.set_state(true);
} else if dist_sqrd < MAX_CHASE_DIST.powi(2) { } else if dist_sqrd < MAX_CHASE_DIST.powi(2) {
if self.vel.0.is_approx_zero() { if self.vel.0.is_approx_zero() {
controller.inputs.ability3.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Ability(0),
target: None,
});
// controller.inputs.ability3.set_state(true);
} }
if let Some((bearing, speed)) = agent.chaser.chase( if let Some((bearing, speed)) = agent.chaser.chase(
&*terrain, &*terrain,
@ -1545,7 +1725,17 @@ impl<'a> AgentData<'a> {
} else { } else {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} }
@ -1617,7 +1807,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -1671,12 +1871,32 @@ impl<'a> AgentData<'a> {
target: None, target: None,
}); });
// controller.inputs.secondary.set_state(true); // controller.inputs.secondary.set_state(true);
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} else { } else {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -1727,7 +1947,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -1768,7 +1998,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -1808,7 +2048,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -1824,7 +2074,11 @@ impl<'a> AgentData<'a> {
}); });
// controller.inputs.secondary.set_state(true); // controller.inputs.secondary.set_state(true);
} else if dist_sqrd < (5.0 * min_attack_dist * self.scale).powi(2) { } else if dist_sqrd < (5.0 * min_attack_dist * self.scale).powi(2) {
controller.inputs.ability3.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Ability(0),
target: None,
});
// controller.inputs.ability3.set_state(true);
} else if dist_sqrd < MAX_CHASE_DIST.powi(2) { } else if dist_sqrd < MAX_CHASE_DIST.powi(2) {
if let Some((bearing, speed)) = agent.chaser.chase( if let Some((bearing, speed)) = agent.chaser.chase(
&*terrain, &*terrain,
@ -1847,7 +2101,17 @@ impl<'a> AgentData<'a> {
} else { } else {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} }
@ -1888,7 +2152,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -1929,7 +2203,11 @@ impl<'a> AgentData<'a> {
//controller.inputs.primary.set_state(true); //controller.inputs.primary.set_state(true);
agent.action_timer += dt.0; agent.action_timer += dt.0;
} else if agent.action_timer < 6.0 { } else if agent.action_timer < 6.0 {
controller.inputs.ability3.set_state(true); controller.actions.push(ControlAction::StartInput {
input: InputKind::Ability(0),
target: None,
});
// controller.inputs.ability3.set_state(true);
agent.action_timer += dt.0; agent.action_timer += dt.0;
} else { } else {
agent.action_timer = 0.0; agent.action_timer = 0.0;
@ -1947,7 +2225,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -1975,7 +2263,17 @@ impl<'a> AgentData<'a> {
) { ) {
controller.inputs.move_dir = controller.inputs.move_dir =
bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed; bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) * speed;
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} else { } else {
@ -2046,7 +2344,17 @@ impl<'a> AgentData<'a> {
let dist_sqrd = self.pos.0.distance_squared(tgt_pos.0); let dist_sqrd = self.pos.0.distance_squared(tgt_pos.0);
controller.inputs.move_dir = bearing.xy().try_normalized().unwrap_or_else(Vec2::zero) controller.inputs.move_dir = bearing.xy().try_normalized().unwrap_or_else(Vec2::zero)
* speed.min(0.2 + (dist_sqrd - AVG_FOLLOW_DIST.powi(2)) / 8.0); * speed.min(0.2 + (dist_sqrd - AVG_FOLLOW_DIST.powi(2)) / 8.0);
controller.inputs.jump.set_state(bearing.z > 1.5); if bearing.z > 1.5 {
controller.actions.push(ControlAction::StartInput {
input: InputKind::Jump,
target: None,
});
} else {
controller
.actions
.push(ControlAction::CancelInput(InputKind::Jump))
}
// controller.inputs.jump.set_state(bearing.z > 1.5);
controller.inputs.move_z = bearing.z; controller.inputs.move_z = bearing.z;
} }
} }

6
voxygen/src/controller.rs
View File

@ -117,9 +117,6 @@ impl From<&crate::settings::GamepadSettings> for ControllerSettings {
map.entry(settings.game_buttons.sneak) map.entry(settings.game_buttons.sneak)
.or_default() .or_default()
.push(GameInput::Sneak); .push(GameInput::Sneak);
/*map.entry(settings.game_buttons.wall_leap)
.or_default()
.push(GameInput::WallLeap);*/
map.entry(settings.game_buttons.toggle_lantern) map.entry(settings.game_buttons.toggle_lantern)
.or_default() .or_default()
.push(GameInput::ToggleLantern); .push(GameInput::ToggleLantern);
@ -177,9 +174,6 @@ impl From<&crate::settings::GamepadSettings> for ControllerSettings {
map.entry(settings.game_buttons.swap_loadout) map.entry(settings.game_buttons.swap_loadout)
.or_default() .or_default()
.push(GameInput::SwapLoadout); .push(GameInput::SwapLoadout);
/*map.entry(settings.game_buttons.charge)
.or_default()
.push(GameInput::Charge);*/
map map
}, },
menu_button_map: { menu_button_map: {

29
voxygen/src/session.rs
View File

@ -126,7 +126,6 @@ impl SessionState {
outcomes: &mut Vec<Outcome>, outcomes: &mut Vec<Outcome>,
) -> Result<TickAction, Error> { ) -> Result<TickAction, Error> {
span!(_guard, "tick", "Session::tick"); span!(_guard, "tick", "Session::tick");
self.inputs.tick(dt);
let mut client = self.client.borrow_mut(); let mut client = self.client.borrow_mut();
for event in client.tick(self.inputs.clone(), dt, crate::ecs::sys::add_local_systems)? { for event in client.tick(self.inputs.clone(), dt, crate::ecs::sys::add_local_systems)? {
@ -386,7 +385,7 @@ impl PlayState for SessionState {
} }
}, },
GameInput::Roll => { GameInput::Roll => {
let client = self.client.borrow(); let mut client = self.client.borrow_mut();
if can_build { if can_build {
if state { if state {
if let Some(block) = select_pos.and_then(|sp| { if let Some(block) = select_pos.and_then(|sp| {
@ -396,7 +395,8 @@ impl PlayState for SessionState {
} }
} }
} else { } else {
self.inputs.roll.set_state(state); client.handle_input(InputKind::Roll, state);
// self.inputs.roll.set_state(state);
} }
}, },
GameInput::Respawn => { GameInput::Respawn => {
@ -406,7 +406,8 @@ impl PlayState for SessionState {
} }
}, },
GameInput::Jump => { GameInput::Jump => {
self.inputs.jump.set_state(state); let mut client = self.client.borrow_mut();
client.handle_input(InputKind::Jump, state);
}, },
GameInput::SwimUp => { GameInput::SwimUp => {
self.key_state.swim_up = state; self.key_state.swim_up = state;
@ -462,7 +463,14 @@ impl PlayState for SessionState {
} }
}, },
GameInput::Fly => { GameInput::Fly => {
// Not sure where to put comment, but I noticed when testing flight
// Syncing of inputs between mounter and mountee broke with
// controller change
self.key_state.fly ^= state; self.key_state.fly ^= state;
let mut client = self.client.borrow_mut();
client.handle_input(InputKind::Fly, self.key_state.fly);
// self.inputs.fly.set_state(self.key_state.
// fly);
}, },
GameInput::Climb => { GameInput::Climb => {
self.key_state.climb_up = state; self.key_state.climb_up = state;
@ -726,7 +734,6 @@ impl PlayState for SessionState {
}; };
self.inputs.climb = self.key_state.climb(); self.inputs.climb = self.key_state.climb();
self.inputs.fly.set_state(self.key_state.fly);
self.inputs.move_z = self.inputs.move_z =
self.key_state.swim_up as i32 as f32 - self.key_state.swim_down as i32 as f32; self.key_state.swim_up as i32 as f32 - self.key_state.swim_down as i32 as f32;
@ -1219,8 +1226,16 @@ impl PlayState for SessionState {
let mut client = self.client.borrow_mut(); let mut client = self.client.borrow_mut();
client.perform_trade_action(action); client.perform_trade_action(action);
}, },
HudEvent::Ability3(state) => self.inputs.ability3.set_state(state), HudEvent::Ability3(state) => {
HudEvent::Ability4(state) => self.inputs.ability4.set_state(state), let mut client = self.client.borrow_mut();
client.handle_input(InputKind::Ability(0), state);
// self.inputs.ability3.set_state(state);
},
HudEvent::Ability4(state) => {
let mut client = self.client.borrow_mut();
client.handle_input(InputKind::Ability(1), state);
// self.inputs.ability4.set_state(state);
},
HudEvent::ChangeFOV(new_fov) => { HudEvent::ChangeFOV(new_fov) => {
global_state.settings.graphics.fov = new_fov; global_state.settings.graphics.fov = new_fov;
global_state.settings.save_to_file_warn(); global_state.settings.save_to_file_warn();

5
voxygen/src/settings.rs
View File

@ -138,7 +138,6 @@ impl ControlSettings {
GameInput::SwimDown => KeyMouse::Key(VirtualKeyCode::LShift), GameInput::SwimDown => KeyMouse::Key(VirtualKeyCode::LShift),
GameInput::Fly => KeyMouse::Key(VirtualKeyCode::H), GameInput::Fly => KeyMouse::Key(VirtualKeyCode::H),
GameInput::Sneak => KeyMouse::Key(VirtualKeyCode::LControl), GameInput::Sneak => KeyMouse::Key(VirtualKeyCode::LControl),
//GameInput::WallLeap => MIDDLE_CLICK_KEY,
GameInput::ToggleLantern => KeyMouse::Key(VirtualKeyCode::G), GameInput::ToggleLantern => KeyMouse::Key(VirtualKeyCode::G),
GameInput::Mount => KeyMouse::Key(VirtualKeyCode::F), GameInput::Mount => KeyMouse::Key(VirtualKeyCode::F),
GameInput::Map => KeyMouse::Key(VirtualKeyCode::M), GameInput::Map => KeyMouse::Key(VirtualKeyCode::M),
@ -158,7 +157,6 @@ impl ControlSettings {
GameInput::Respawn => KeyMouse::Key(VirtualKeyCode::Space), GameInput::Respawn => KeyMouse::Key(VirtualKeyCode::Space),
GameInput::Interact => KeyMouse::Key(VirtualKeyCode::E), GameInput::Interact => KeyMouse::Key(VirtualKeyCode::E),
GameInput::ToggleWield => KeyMouse::Key(VirtualKeyCode::T), GameInput::ToggleWield => KeyMouse::Key(VirtualKeyCode::T),
//GameInput::Charge => KeyMouse::Key(VirtualKeyCode::Key1),
GameInput::FreeLook => KeyMouse::Key(VirtualKeyCode::L), GameInput::FreeLook => KeyMouse::Key(VirtualKeyCode::L),
GameInput::AutoWalk => KeyMouse::Key(VirtualKeyCode::Period), GameInput::AutoWalk => KeyMouse::Key(VirtualKeyCode::Period),
GameInput::CycleCamera => KeyMouse::Key(VirtualKeyCode::Key0), GameInput::CycleCamera => KeyMouse::Key(VirtualKeyCode::Key0),
@ -257,7 +255,6 @@ pub mod con_settings {
pub swimup: Button, pub swimup: Button,
pub swimdown: Button, pub swimdown: Button,
pub sneak: Button, pub sneak: Button,
//pub wall_leap: Button,
pub toggle_lantern: Button, pub toggle_lantern: Button,
pub mount: Button, pub mount: Button,
pub map: Button, pub map: Button,
@ -349,7 +346,6 @@ pub mod con_settings {
swimup: Button::Simple(GilButton::South), swimup: Button::Simple(GilButton::South),
swimdown: Button::Simple(GilButton::East), swimdown: Button::Simple(GilButton::East),
sneak: Button::Simple(GilButton::East), sneak: Button::Simple(GilButton::East),
//wall_leap: Button::Simple(GilButton::Unknown),
toggle_lantern: Button::Simple(GilButton::DPadLeft), toggle_lantern: Button::Simple(GilButton::DPadLeft),
mount: Button::Simple(GilButton::North), mount: Button::Simple(GilButton::North),
map: Button::Simple(GilButton::Select), map: Button::Simple(GilButton::Select),
@ -371,7 +367,6 @@ pub mod con_settings {
interact: Button::Simple(GilButton::North), interact: Button::Simple(GilButton::North),
toggle_wield: Button::Simple(GilButton::West), toggle_wield: Button::Simple(GilButton::West),
swap_loadout: Button::Simple(GilButton::LeftThumb), swap_loadout: Button::Simple(GilButton::LeftThumb),
//charge: Button::Simple(GilButton::Unknown),
} }
} }
} }

4
voxygen/src/window.rs
View File

@ -46,7 +46,6 @@ pub enum GameInput {
SwimDown, SwimDown,
Fly, Fly,
Sneak, Sneak,
//WallLeap,
ToggleLantern, ToggleLantern,
Mount, Mount,
Chat, Chat,
@ -69,7 +68,6 @@ pub enum GameInput {
Respawn, Respawn,
Interact, Interact,
ToggleWield, ToggleWield,
//Charge,
SwapLoadout, SwapLoadout,
FreeLook, FreeLook,
AutoWalk, AutoWalk,
@ -99,7 +97,6 @@ impl GameInput {
GameInput::SwimDown => "gameinput.swimdown", GameInput::SwimDown => "gameinput.swimdown",
GameInput::Fly => "gameinput.fly", GameInput::Fly => "gameinput.fly",
GameInput::Sneak => "gameinput.sneak", GameInput::Sneak => "gameinput.sneak",
//GameInput::WallLeap => "gameinput.wallleap",
GameInput::ToggleLantern => "gameinput.togglelantern", GameInput::ToggleLantern => "gameinput.togglelantern",
GameInput::Mount => "gameinput.mount", GameInput::Mount => "gameinput.mount",
GameInput::Chat => "gameinput.chat", GameInput::Chat => "gameinput.chat",
@ -123,7 +120,6 @@ impl GameInput {
GameInput::Respawn => "gameinput.respawn", GameInput::Respawn => "gameinput.respawn",
GameInput::Interact => "gameinput.interact", GameInput::Interact => "gameinput.interact",
GameInput::ToggleWield => "gameinput.togglewield", GameInput::ToggleWield => "gameinput.togglewield",
//GameInput::Charge => "gameinput.charge",
GameInput::FreeLook => "gameinput.freelook", GameInput::FreeLook => "gameinput.freelook",
GameInput::AutoWalk => "gameinput.autowalk", GameInput::AutoWalk => "gameinput.autowalk",
GameInput::Slot1 => "gameinput.slot1", GameInput::Slot1 => "gameinput.slot1",