mirror of
https://gitlab.com/veloren/veloren.git
synced 2024-08-30 18:12:32 +00:00
1930 lines
79 KiB
Rust
1930 lines
79 KiB
Rust
use crate::{
|
|
assets::{self, Asset},
|
|
combat::{self, CombatEffect, DamageKind, Knockback},
|
|
comp::{
|
|
self, aura, beam, buff,
|
|
inventory::item::tool::{Stats, ToolKind},
|
|
projectile::ProjectileConstructor,
|
|
skills, Body, CharacterState, EnergySource, LightEmitter, StateUpdate,
|
|
},
|
|
states::{
|
|
behavior::JoinData,
|
|
utils::{AbilityInfo, StageSection},
|
|
*,
|
|
},
|
|
terrain::SpriteKind,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::time::Duration;
|
|
|
|
#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug, Serialize, Deserialize)]
|
|
pub enum CharacterAbilityType {
|
|
BasicMelee,
|
|
BasicRanged,
|
|
Boost,
|
|
ChargedMelee(StageSection),
|
|
ChargedRanged,
|
|
DashMelee(StageSection),
|
|
BasicBlock,
|
|
ComboMelee(StageSection, u32),
|
|
LeapMelee(StageSection),
|
|
SpinMelee(StageSection),
|
|
Shockwave,
|
|
BasicBeam,
|
|
RepeaterRanged,
|
|
BasicAura,
|
|
SelfBuff,
|
|
}
|
|
|
|
impl From<&CharacterState> for CharacterAbilityType {
|
|
fn from(state: &CharacterState) -> Self {
|
|
match state {
|
|
CharacterState::BasicMelee(_) => Self::BasicMelee,
|
|
CharacterState::BasicRanged(_) => Self::BasicRanged,
|
|
CharacterState::Boost(_) => Self::Boost,
|
|
CharacterState::DashMelee(data) => Self::DashMelee(data.stage_section),
|
|
CharacterState::BasicBlock(_) => Self::BasicBlock,
|
|
CharacterState::LeapMelee(data) => Self::LeapMelee(data.stage_section),
|
|
CharacterState::ComboMelee(data) => Self::ComboMelee(data.stage_section, data.stage),
|
|
CharacterState::SpinMelee(data) => Self::SpinMelee(data.stage_section),
|
|
CharacterState::ChargedMelee(data) => Self::ChargedMelee(data.stage_section),
|
|
CharacterState::ChargedRanged(_) => Self::ChargedRanged,
|
|
CharacterState::Shockwave(_) => Self::Shockwave,
|
|
CharacterState::BasicBeam(_) => Self::BasicBeam,
|
|
CharacterState::RepeaterRanged(_) => Self::RepeaterRanged,
|
|
CharacterState::BasicAura(_) => Self::BasicAura,
|
|
CharacterState::SelfBuff(_) => Self::SelfBuff,
|
|
_ => Self::BasicMelee,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
|
|
pub enum CharacterAbility {
|
|
BasicMelee {
|
|
energy_cost: f32,
|
|
buildup_duration: f32,
|
|
swing_duration: f32,
|
|
recover_duration: f32,
|
|
base_damage: f32,
|
|
base_poise_damage: f32,
|
|
knockback: Knockback,
|
|
range: f32,
|
|
max_angle: f32,
|
|
damage_effect: Option<CombatEffect>,
|
|
damage_kind: DamageKind,
|
|
},
|
|
BasicRanged {
|
|
energy_cost: f32,
|
|
buildup_duration: f32,
|
|
recover_duration: f32,
|
|
projectile: ProjectileConstructor,
|
|
projectile_body: Body,
|
|
projectile_light: Option<LightEmitter>,
|
|
projectile_speed: f32,
|
|
num_projectiles: u32,
|
|
projectile_spread: f32,
|
|
},
|
|
RepeaterRanged {
|
|
energy_cost: f32,
|
|
buildup_duration: f32,
|
|
shoot_duration: f32,
|
|
recover_duration: f32,
|
|
max_speed: f32,
|
|
half_speed_at: u32,
|
|
projectile: ProjectileConstructor,
|
|
projectile_body: Body,
|
|
projectile_light: Option<LightEmitter>,
|
|
projectile_speed: f32,
|
|
},
|
|
Boost {
|
|
movement_duration: f32,
|
|
only_up: bool,
|
|
speed: f32,
|
|
max_exit_velocity: f32,
|
|
},
|
|
DashMelee {
|
|
energy_cost: f32,
|
|
base_damage: f32,
|
|
scaled_damage: f32,
|
|
base_poise_damage: f32,
|
|
scaled_poise_damage: f32,
|
|
base_knockback: f32,
|
|
scaled_knockback: f32,
|
|
range: f32,
|
|
angle: f32,
|
|
energy_drain: f32,
|
|
forward_speed: f32,
|
|
buildup_duration: f32,
|
|
charge_duration: f32,
|
|
swing_duration: f32,
|
|
recover_duration: f32,
|
|
charge_through: bool,
|
|
is_interruptible: bool,
|
|
damage_kind: DamageKind,
|
|
},
|
|
BasicBlock {
|
|
buildup_duration: f32,
|
|
recover_duration: f32,
|
|
max_angle: f32,
|
|
block_strength: f32,
|
|
energy_cost: f32,
|
|
},
|
|
Roll {
|
|
energy_cost: f32,
|
|
buildup_duration: f32,
|
|
movement_duration: f32,
|
|
recover_duration: f32,
|
|
roll_strength: f32,
|
|
immune_melee: bool,
|
|
},
|
|
ComboMelee {
|
|
stage_data: Vec<combo_melee::Stage<f32>>,
|
|
initial_energy_gain: f32,
|
|
max_energy_gain: f32,
|
|
energy_increase: f32,
|
|
speed_increase: f32,
|
|
max_speed_increase: f32,
|
|
scales_from_combo: u32,
|
|
is_interruptible: bool,
|
|
ori_modifier: f32,
|
|
},
|
|
LeapMelee {
|
|
energy_cost: f32,
|
|
buildup_duration: f32,
|
|
movement_duration: f32,
|
|
swing_duration: f32,
|
|
recover_duration: f32,
|
|
base_damage: f32,
|
|
base_poise_damage: f32,
|
|
range: f32,
|
|
max_angle: f32,
|
|
knockback: f32,
|
|
forward_leap_strength: f32,
|
|
vertical_leap_strength: f32,
|
|
damage_kind: DamageKind,
|
|
},
|
|
SpinMelee {
|
|
buildup_duration: f32,
|
|
swing_duration: f32,
|
|
recover_duration: f32,
|
|
base_damage: f32,
|
|
base_poise_damage: f32,
|
|
knockback: Knockback,
|
|
range: f32,
|
|
damage_effect: Option<CombatEffect>,
|
|
energy_cost: f32,
|
|
is_infinite: bool,
|
|
movement_behavior: spin_melee::MovementBehavior,
|
|
is_interruptible: bool,
|
|
forward_speed: f32,
|
|
num_spins: u32,
|
|
specifier: Option<spin_melee::FrontendSpecifier>,
|
|
target: Option<combat::GroupTarget>,
|
|
damage_kind: DamageKind,
|
|
},
|
|
ChargedMelee {
|
|
energy_cost: f32,
|
|
energy_drain: f32,
|
|
initial_damage: f32,
|
|
scaled_damage: f32,
|
|
initial_poise_damage: f32,
|
|
scaled_poise_damage: f32,
|
|
initial_knockback: f32,
|
|
scaled_knockback: f32,
|
|
range: f32,
|
|
max_angle: f32,
|
|
charge_duration: f32,
|
|
swing_duration: f32,
|
|
hit_timing: f32,
|
|
recover_duration: f32,
|
|
specifier: Option<charged_melee::FrontendSpecifier>,
|
|
damage_kind: DamageKind,
|
|
},
|
|
ChargedRanged {
|
|
energy_cost: f32,
|
|
energy_drain: f32,
|
|
initial_regen: f32,
|
|
scaled_regen: f32,
|
|
initial_damage: f32,
|
|
scaled_damage: f32,
|
|
initial_knockback: f32,
|
|
scaled_knockback: f32,
|
|
buildup_duration: f32,
|
|
charge_duration: f32,
|
|
recover_duration: f32,
|
|
projectile_body: Body,
|
|
projectile_light: Option<LightEmitter>,
|
|
initial_projectile_speed: f32,
|
|
scaled_projectile_speed: f32,
|
|
move_speed: f32,
|
|
},
|
|
Shockwave {
|
|
energy_cost: f32,
|
|
buildup_duration: f32,
|
|
swing_duration: f32,
|
|
recover_duration: f32,
|
|
damage: f32,
|
|
poise_damage: f32,
|
|
knockback: Knockback,
|
|
shockwave_angle: f32,
|
|
shockwave_vertical_angle: f32,
|
|
shockwave_speed: f32,
|
|
shockwave_duration: f32,
|
|
requires_ground: bool,
|
|
move_efficiency: f32,
|
|
damage_kind: DamageKind,
|
|
specifier: comp::shockwave::FrontendSpecifier,
|
|
},
|
|
BasicBeam {
|
|
buildup_duration: f32,
|
|
recover_duration: f32,
|
|
beam_duration: f32,
|
|
damage: f32,
|
|
tick_rate: f32,
|
|
range: f32,
|
|
max_angle: f32,
|
|
damage_effect: Option<CombatEffect>,
|
|
energy_regen: f32,
|
|
energy_drain: f32,
|
|
orientation_behavior: basic_beam::OrientationBehavior,
|
|
ori_rate: f32,
|
|
specifier: beam::FrontendSpecifier,
|
|
},
|
|
BasicAura {
|
|
buildup_duration: f32,
|
|
cast_duration: f32,
|
|
recover_duration: f32,
|
|
targets: combat::GroupTarget,
|
|
aura: aura::AuraBuffConstructor,
|
|
aura_duration: f32,
|
|
range: f32,
|
|
energy_cost: f32,
|
|
scales_with_combo: bool,
|
|
specifier: aura::Specifier,
|
|
},
|
|
Blink {
|
|
buildup_duration: f32,
|
|
recover_duration: f32,
|
|
max_range: f32,
|
|
},
|
|
BasicSummon {
|
|
buildup_duration: f32,
|
|
cast_duration: f32,
|
|
recover_duration: f32,
|
|
summon_amount: u32,
|
|
summon_distance: (f32, f32),
|
|
summon_info: basic_summon::SummonInfo,
|
|
duration: Option<Duration>,
|
|
},
|
|
SelfBuff {
|
|
buildup_duration: f32,
|
|
cast_duration: f32,
|
|
recover_duration: f32,
|
|
buff_kind: buff::BuffKind,
|
|
buff_strength: f32,
|
|
buff_duration: Option<f32>,
|
|
energy_cost: f32,
|
|
},
|
|
SpriteSummon {
|
|
buildup_duration: f32,
|
|
cast_duration: f32,
|
|
recover_duration: f32,
|
|
sprite: SpriteKind,
|
|
summon_distance: (f32, f32),
|
|
sparseness: f64,
|
|
},
|
|
}
|
|
|
|
impl Default for CharacterAbility {
|
|
fn default() -> Self {
|
|
CharacterAbility::BasicMelee {
|
|
energy_cost: 0.0,
|
|
buildup_duration: 0.25,
|
|
swing_duration: 0.25,
|
|
recover_duration: 0.5,
|
|
base_damage: 10.0,
|
|
base_poise_damage: 0.0,
|
|
knockback: Knockback {
|
|
strength: 0.0,
|
|
direction: combat::KnockbackDir::Away,
|
|
},
|
|
range: 3.5,
|
|
max_angle: 15.0,
|
|
damage_effect: None,
|
|
damage_kind: DamageKind::Crushing,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Asset for CharacterAbility {
|
|
type Loader = assets::RonLoader;
|
|
|
|
const EXTENSION: &'static str = "ron";
|
|
}
|
|
|
|
impl CharacterAbility {
|
|
/// Attempts to fulfill requirements, mutating `update` (taking energy) if
|
|
/// applicable.
|
|
pub fn requirements_paid(&self, data: &JoinData, update: &mut StateUpdate) -> bool {
|
|
match self {
|
|
CharacterAbility::Roll { energy_cost, .. } => {
|
|
data.physics.on_ground.is_some()
|
|
&& data.inputs.move_dir.magnitude_squared() > 0.25
|
|
&& update
|
|
.energy
|
|
.try_change_by(-(*energy_cost as i32), EnergySource::Ability)
|
|
.is_ok()
|
|
},
|
|
CharacterAbility::DashMelee { energy_cost, .. }
|
|
| CharacterAbility::BasicMelee { energy_cost, .. }
|
|
| CharacterAbility::BasicRanged { energy_cost, .. }
|
|
| CharacterAbility::SpinMelee { energy_cost, .. }
|
|
| CharacterAbility::ChargedRanged { energy_cost, .. }
|
|
| CharacterAbility::ChargedMelee { energy_cost, .. }
|
|
| CharacterAbility::Shockwave { energy_cost, .. }
|
|
| CharacterAbility::BasicBlock { energy_cost, .. }
|
|
| CharacterAbility::SelfBuff { energy_cost, .. } => update
|
|
.energy
|
|
.try_change_by(-(*energy_cost as i32), EnergySource::Ability)
|
|
.is_ok(),
|
|
// Consumes energy within state, so value only checked before entering state
|
|
CharacterAbility::RepeaterRanged { energy_cost, .. } => {
|
|
update.energy.current() as f32 >= *energy_cost
|
|
},
|
|
CharacterAbility::LeapMelee { energy_cost, .. } => {
|
|
update.vel.0.z >= 0.0
|
|
&& update
|
|
.energy
|
|
.try_change_by(-(*energy_cost as i32), EnergySource::Ability)
|
|
.is_ok()
|
|
},
|
|
CharacterAbility::BasicAura {
|
|
energy_cost,
|
|
scales_with_combo,
|
|
..
|
|
} => {
|
|
((*scales_with_combo && data.combo.counter() > 0) | !*scales_with_combo)
|
|
&& update
|
|
.energy
|
|
.try_change_by(-(*energy_cost as i32), EnergySource::Ability)
|
|
.is_ok()
|
|
},
|
|
CharacterAbility::ComboMelee { .. }
|
|
| CharacterAbility::Boost { .. }
|
|
| CharacterAbility::BasicBeam { .. }
|
|
| CharacterAbility::Blink { .. }
|
|
| CharacterAbility::BasicSummon { .. }
|
|
| CharacterAbility::SpriteSummon { .. } => true,
|
|
}
|
|
}
|
|
|
|
pub fn default_roll() -> CharacterAbility {
|
|
CharacterAbility::Roll {
|
|
energy_cost: 120.0,
|
|
buildup_duration: 0.05,
|
|
movement_duration: 0.33,
|
|
recover_duration: 0.125,
|
|
roll_strength: 2.0,
|
|
immune_melee: true,
|
|
}
|
|
}
|
|
|
|
pub fn default_block() -> CharacterAbility {
|
|
CharacterAbility::BasicBlock {
|
|
buildup_duration: 0.35,
|
|
recover_duration: 0.3,
|
|
max_angle: 60.0,
|
|
block_strength: 0.5,
|
|
energy_cost: 50.0,
|
|
}
|
|
}
|
|
|
|
pub fn adjusted_by_stats(mut self, stats: Stats) -> Self {
|
|
use CharacterAbility::*;
|
|
match self {
|
|
BasicMelee {
|
|
ref mut energy_cost,
|
|
ref mut buildup_duration,
|
|
ref mut swing_duration,
|
|
ref mut recover_duration,
|
|
ref mut base_damage,
|
|
ref mut base_poise_damage,
|
|
knockback: _,
|
|
ref mut range,
|
|
max_angle: _,
|
|
damage_effect: _,
|
|
damage_kind: _,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*swing_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*base_damage *= stats.power;
|
|
*base_poise_damage *= stats.poise_strength;
|
|
*range *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
BasicRanged {
|
|
ref mut energy_cost,
|
|
ref mut buildup_duration,
|
|
ref mut recover_duration,
|
|
ref mut projectile,
|
|
projectile_body: _,
|
|
projectile_light: _,
|
|
ref mut projectile_speed,
|
|
num_projectiles: _,
|
|
projectile_spread: _,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*projectile = projectile.modified_projectile(stats.power, 1_f32, 1_f32);
|
|
*projectile_speed *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
RepeaterRanged {
|
|
ref mut energy_cost,
|
|
ref mut buildup_duration,
|
|
ref mut shoot_duration,
|
|
ref mut recover_duration,
|
|
max_speed: _,
|
|
half_speed_at: _,
|
|
ref mut projectile,
|
|
projectile_body: _,
|
|
projectile_light: _,
|
|
ref mut projectile_speed,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*shoot_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*projectile = projectile.modified_projectile(stats.power, 1_f32, 1_f32);
|
|
*projectile_speed *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
Boost {
|
|
ref mut movement_duration,
|
|
only_up: _,
|
|
speed: ref mut boost_speed,
|
|
max_exit_velocity: _,
|
|
} => {
|
|
*movement_duration /= stats.speed;
|
|
*boost_speed *= stats.power;
|
|
},
|
|
DashMelee {
|
|
ref mut energy_cost,
|
|
ref mut base_damage,
|
|
ref mut scaled_damage,
|
|
ref mut base_poise_damage,
|
|
ref mut scaled_poise_damage,
|
|
base_knockback: _,
|
|
scaled_knockback: _,
|
|
ref mut range,
|
|
angle: _,
|
|
ref mut energy_drain,
|
|
forward_speed: _,
|
|
ref mut buildup_duration,
|
|
charge_duration: _,
|
|
ref mut swing_duration,
|
|
ref mut recover_duration,
|
|
charge_through: _,
|
|
is_interruptible: _,
|
|
damage_kind: _,
|
|
} => {
|
|
*base_damage *= stats.power;
|
|
*scaled_damage *= stats.power;
|
|
*base_poise_damage *= stats.poise_strength;
|
|
*scaled_poise_damage *= stats.poise_strength;
|
|
*buildup_duration /= stats.speed;
|
|
*swing_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*range *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
*energy_drain /= stats.energy_efficiency;
|
|
},
|
|
BasicBlock {
|
|
ref mut buildup_duration,
|
|
ref mut recover_duration,
|
|
// Do we want angle to be adjusted by range?
|
|
max_angle: _,
|
|
// Block strength explicitly not modified by power, that will be a separate stat
|
|
block_strength: _,
|
|
ref mut energy_cost,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
Roll {
|
|
ref mut energy_cost,
|
|
ref mut buildup_duration,
|
|
ref mut movement_duration,
|
|
ref mut recover_duration,
|
|
roll_strength: _,
|
|
immune_melee: _,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*movement_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
ComboMelee {
|
|
ref mut stage_data,
|
|
initial_energy_gain: _,
|
|
max_energy_gain: _,
|
|
energy_increase: _,
|
|
speed_increase: _,
|
|
max_speed_increase: _,
|
|
scales_from_combo: _,
|
|
is_interruptible: _,
|
|
ori_modifier: _,
|
|
} => {
|
|
*stage_data = stage_data
|
|
.iter_mut()
|
|
.map(|s| s.adjusted_by_stats(stats))
|
|
.collect();
|
|
},
|
|
LeapMelee {
|
|
ref mut energy_cost,
|
|
ref mut buildup_duration,
|
|
movement_duration: _,
|
|
ref mut swing_duration,
|
|
ref mut recover_duration,
|
|
ref mut base_damage,
|
|
ref mut base_poise_damage,
|
|
ref mut range,
|
|
max_angle: _,
|
|
knockback: _,
|
|
forward_leap_strength: _,
|
|
vertical_leap_strength: _,
|
|
damage_kind: _,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*swing_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*base_damage *= stats.power;
|
|
*base_poise_damage *= stats.poise_strength;
|
|
*range *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
SpinMelee {
|
|
ref mut buildup_duration,
|
|
ref mut swing_duration,
|
|
ref mut recover_duration,
|
|
ref mut base_damage,
|
|
ref mut base_poise_damage,
|
|
knockback: _,
|
|
ref mut range,
|
|
damage_effect: _,
|
|
ref mut energy_cost,
|
|
is_infinite: _,
|
|
movement_behavior: _,
|
|
is_interruptible: _,
|
|
forward_speed: _,
|
|
num_spins: _,
|
|
specifier: _,
|
|
target: _,
|
|
damage_kind: _,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*swing_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*base_damage *= stats.power;
|
|
*base_poise_damage *= stats.poise_strength;
|
|
*range *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
ChargedMelee {
|
|
ref mut energy_cost,
|
|
ref mut energy_drain,
|
|
ref mut initial_damage,
|
|
ref mut scaled_damage,
|
|
ref mut initial_poise_damage,
|
|
ref mut scaled_poise_damage,
|
|
initial_knockback: _,
|
|
scaled_knockback: _,
|
|
ref mut range,
|
|
max_angle: _,
|
|
charge_duration: _,
|
|
ref mut swing_duration,
|
|
hit_timing: _,
|
|
ref mut recover_duration,
|
|
specifier: _,
|
|
damage_kind: _,
|
|
} => {
|
|
*initial_damage *= stats.power;
|
|
*scaled_damage *= stats.power;
|
|
*initial_poise_damage *= stats.poise_strength;
|
|
*scaled_poise_damage *= stats.poise_strength;
|
|
*swing_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*range *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
*energy_drain /= stats.energy_efficiency;
|
|
},
|
|
ChargedRanged {
|
|
ref mut energy_cost,
|
|
ref mut energy_drain,
|
|
initial_regen: _,
|
|
scaled_regen: _,
|
|
ref mut initial_damage,
|
|
ref mut scaled_damage,
|
|
initial_knockback: _,
|
|
scaled_knockback: _,
|
|
ref mut buildup_duration,
|
|
charge_duration: _,
|
|
ref mut recover_duration,
|
|
projectile_body: _,
|
|
projectile_light: _,
|
|
ref mut initial_projectile_speed,
|
|
ref mut scaled_projectile_speed,
|
|
move_speed: _,
|
|
} => {
|
|
*initial_damage *= stats.power;
|
|
*scaled_damage *= stats.power;
|
|
*buildup_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*initial_projectile_speed *= stats.range;
|
|
*scaled_projectile_speed *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
*energy_drain /= stats.energy_efficiency;
|
|
},
|
|
Shockwave {
|
|
ref mut energy_cost,
|
|
ref mut buildup_duration,
|
|
ref mut swing_duration,
|
|
ref mut recover_duration,
|
|
ref mut damage,
|
|
ref mut poise_damage,
|
|
knockback: _,
|
|
shockwave_angle: _,
|
|
shockwave_vertical_angle: _,
|
|
shockwave_speed: _,
|
|
ref mut shockwave_duration,
|
|
requires_ground: _,
|
|
move_efficiency: _,
|
|
damage_kind: _,
|
|
specifier: _,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*swing_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*damage *= stats.power;
|
|
*poise_damage *= stats.poise_strength;
|
|
*shockwave_duration *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
BasicBeam {
|
|
ref mut buildup_duration,
|
|
ref mut recover_duration,
|
|
ref mut beam_duration,
|
|
ref mut damage,
|
|
ref mut tick_rate,
|
|
ref mut range,
|
|
max_angle: _,
|
|
damage_effect: _,
|
|
energy_regen: _,
|
|
ref mut energy_drain,
|
|
orientation_behavior: _,
|
|
ori_rate: _,
|
|
specifier: _,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*damage *= stats.power;
|
|
*tick_rate *= stats.speed;
|
|
*range *= stats.range;
|
|
// Duration modified to keep velocity constant
|
|
*beam_duration *= stats.range;
|
|
*energy_drain /= stats.energy_efficiency;
|
|
},
|
|
BasicAura {
|
|
ref mut buildup_duration,
|
|
ref mut cast_duration,
|
|
ref mut recover_duration,
|
|
targets: _,
|
|
aura:
|
|
aura::AuraBuffConstructor {
|
|
kind: _,
|
|
ref mut strength,
|
|
duration: _,
|
|
category: _,
|
|
},
|
|
aura_duration: _,
|
|
ref mut range,
|
|
ref mut energy_cost,
|
|
scales_with_combo: _,
|
|
specifier: _,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*cast_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*strength *= stats.power;
|
|
*range *= stats.range;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
Blink {
|
|
ref mut buildup_duration,
|
|
ref mut recover_duration,
|
|
ref mut max_range,
|
|
} => {
|
|
*buildup_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*max_range *= stats.range;
|
|
},
|
|
BasicSummon {
|
|
ref mut buildup_duration,
|
|
ref mut cast_duration,
|
|
ref mut recover_duration,
|
|
summon_amount: _,
|
|
summon_distance: (ref mut inner_dist, ref mut outer_dist),
|
|
summon_info: _,
|
|
duration: _,
|
|
} => {
|
|
// TODO: Figure out how/if power should affect this
|
|
*buildup_duration /= stats.speed;
|
|
*cast_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*inner_dist *= stats.range;
|
|
*outer_dist *= stats.range;
|
|
},
|
|
SelfBuff {
|
|
ref mut buildup_duration,
|
|
ref mut cast_duration,
|
|
ref mut recover_duration,
|
|
buff_kind: _,
|
|
ref mut buff_strength,
|
|
buff_duration: _,
|
|
ref mut energy_cost,
|
|
} => {
|
|
*buff_strength *= stats.power;
|
|
*buildup_duration /= stats.speed;
|
|
*cast_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*energy_cost /= stats.energy_efficiency;
|
|
},
|
|
SpriteSummon {
|
|
ref mut buildup_duration,
|
|
ref mut cast_duration,
|
|
ref mut recover_duration,
|
|
sprite: _,
|
|
summon_distance: (ref mut inner_dist, ref mut outer_dist),
|
|
sparseness: _,
|
|
} => {
|
|
// TODO: Figure out how/if power should affect this
|
|
*buildup_duration /= stats.speed;
|
|
*cast_duration /= stats.speed;
|
|
*recover_duration /= stats.speed;
|
|
*inner_dist *= stats.range;
|
|
*outer_dist *= stats.range;
|
|
},
|
|
}
|
|
self
|
|
}
|
|
|
|
pub fn get_energy_cost(&self) -> u32 {
|
|
use CharacterAbility::*;
|
|
match self {
|
|
BasicMelee { energy_cost, .. }
|
|
| BasicRanged { energy_cost, .. }
|
|
| RepeaterRanged { energy_cost, .. }
|
|
| DashMelee { energy_cost, .. }
|
|
| Roll { energy_cost, .. }
|
|
| LeapMelee { energy_cost, .. }
|
|
| SpinMelee { energy_cost, .. }
|
|
| ChargedMelee { energy_cost, .. }
|
|
| ChargedRanged { energy_cost, .. }
|
|
| Shockwave { energy_cost, .. }
|
|
| BasicAura { energy_cost, .. }
|
|
| BasicBlock { energy_cost, .. }
|
|
| SelfBuff { energy_cost, .. } => *energy_cost as u32,
|
|
BasicBeam { energy_drain, .. } => {
|
|
if *energy_drain > f32::EPSILON {
|
|
1
|
|
} else {
|
|
0
|
|
}
|
|
},
|
|
Boost { .. }
|
|
| ComboMelee { .. }
|
|
| Blink { .. }
|
|
| BasicSummon { .. }
|
|
| SpriteSummon { .. } => 0,
|
|
}
|
|
}
|
|
|
|
pub fn adjusted_by_skills(
|
|
mut self,
|
|
skillset: &skills::SkillSet,
|
|
tool: Option<ToolKind>,
|
|
) -> Self {
|
|
use skills::Skill::{self, *};
|
|
use CharacterAbility::*;
|
|
match tool {
|
|
Some(ToolKind::Sword) => {
|
|
use skills::SwordSkill::*;
|
|
match self {
|
|
ComboMelee {
|
|
ref mut is_interruptible,
|
|
ref mut speed_increase,
|
|
ref mut max_speed_increase,
|
|
ref stage_data,
|
|
ref mut max_energy_gain,
|
|
ref mut scales_from_combo,
|
|
..
|
|
} => {
|
|
*is_interruptible = skillset.has_skill(Sword(InterruptingAttacks));
|
|
let speed_segments = Sword(TsSpeed).max_level().map_or(1, |l| l + 1) as f32;
|
|
let speed_level = if skillset.has_skill(Sword(TsCombo)) {
|
|
skillset
|
|
.skill_level(Sword(TsSpeed))
|
|
.unwrap_or(None)
|
|
.map_or(1, |l| l + 1) as f32
|
|
} else {
|
|
0.0
|
|
};
|
|
{
|
|
*speed_increase *= speed_level / speed_segments;
|
|
*max_speed_increase *= speed_level / speed_segments;
|
|
}
|
|
let energy_level =
|
|
if let Ok(Some(level)) = skillset.skill_level(Sword(TsRegen)) {
|
|
level
|
|
} else {
|
|
0
|
|
};
|
|
*max_energy_gain = *max_energy_gain
|
|
* ((energy_level + 1) * stage_data.len() as u16 - 1) as f32
|
|
/ (Sword(TsRegen).max_level().unwrap() + 1) as f32
|
|
* (stage_data.len() - 1) as f32;
|
|
*scales_from_combo = skillset
|
|
.skill_level(Sword(TsDamage))
|
|
.unwrap_or(None)
|
|
.unwrap_or(0)
|
|
.into();
|
|
},
|
|
DashMelee {
|
|
ref mut is_interruptible,
|
|
ref mut energy_cost,
|
|
ref mut energy_drain,
|
|
ref mut base_damage,
|
|
ref mut scaled_damage,
|
|
ref mut forward_speed,
|
|
ref mut charge_through,
|
|
..
|
|
} => {
|
|
*is_interruptible = skillset.has_skill(Sword(InterruptingAttacks));
|
|
if let Ok(Some(level)) = skillset.skill_level(Sword(DCost)) {
|
|
*energy_cost *= 0.75_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sword(DDrain)) {
|
|
*energy_drain *= 0.75_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sword(DDamage)) {
|
|
*base_damage *= 1.2_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sword(DScaling)) {
|
|
*scaled_damage *= 1.2_f32.powi(level.into());
|
|
}
|
|
if skillset.has_skill(Sword(DSpeed)) {
|
|
*forward_speed *= 1.15;
|
|
}
|
|
*charge_through = skillset.has_skill(Sword(DInfinite));
|
|
},
|
|
SpinMelee {
|
|
ref mut is_interruptible,
|
|
ref mut base_damage,
|
|
ref mut swing_duration,
|
|
ref mut energy_cost,
|
|
ref mut num_spins,
|
|
..
|
|
} => {
|
|
*is_interruptible = skillset.has_skill(Sword(InterruptingAttacks));
|
|
if let Ok(Some(level)) = skillset.skill_level(Sword(SDamage)) {
|
|
*base_damage *= 1.4_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sword(SSpeed)) {
|
|
*swing_duration *= 0.8_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sword(SCost)) {
|
|
*energy_cost *= 0.75_f32.powi(level.into());
|
|
}
|
|
*num_spins = skillset
|
|
.skill_level(Sword(SSpins))
|
|
.unwrap_or(None)
|
|
.unwrap_or(0) as u32
|
|
+ 1;
|
|
},
|
|
_ => {},
|
|
}
|
|
},
|
|
Some(ToolKind::Axe) => {
|
|
use skills::AxeSkill::*;
|
|
match self {
|
|
ComboMelee {
|
|
ref mut speed_increase,
|
|
ref mut max_speed_increase,
|
|
ref mut stage_data,
|
|
ref mut max_energy_gain,
|
|
ref mut scales_from_combo,
|
|
..
|
|
} => {
|
|
if !skillset.has_skill(Axe(DsCombo)) {
|
|
stage_data.pop();
|
|
}
|
|
let speed_segments = Axe(DsSpeed).max_level().unwrap_or(1) as f32;
|
|
let speed_level = skillset
|
|
.skill_level(Axe(DsSpeed))
|
|
.unwrap_or(None)
|
|
.unwrap_or(0) as f32;
|
|
{
|
|
*speed_increase *= speed_level / speed_segments;
|
|
*max_speed_increase *= speed_level / speed_segments;
|
|
}
|
|
let energy_level =
|
|
if let Ok(Some(level)) = skillset.skill_level(Axe(DsRegen)) {
|
|
level
|
|
} else {
|
|
0
|
|
};
|
|
*max_energy_gain = *max_energy_gain
|
|
* ((energy_level + 1) * stage_data.len() as u16 - 1) as f32
|
|
/ (Axe(DsRegen).max_level().unwrap() + 1) as f32
|
|
* (stage_data.len() - 1) as f32;
|
|
*scales_from_combo = skillset
|
|
.skill_level(Axe(DsDamage))
|
|
.unwrap_or(None)
|
|
.unwrap_or(0)
|
|
.into();
|
|
},
|
|
SpinMelee {
|
|
ref mut base_damage,
|
|
ref mut swing_duration,
|
|
ref mut energy_cost,
|
|
ref mut is_infinite,
|
|
ref mut movement_behavior,
|
|
..
|
|
} => {
|
|
*is_infinite = skillset.has_skill(Axe(SInfinite));
|
|
*movement_behavior = if skillset.has_skill(Axe(SHelicopter)) {
|
|
spin_melee::MovementBehavior::AxeHover
|
|
} else {
|
|
spin_melee::MovementBehavior::ForwardGround
|
|
};
|
|
if let Ok(Some(level)) = skillset.skill_level(Axe(SDamage)) {
|
|
*base_damage *= 1.3_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Axe(SSpeed)) {
|
|
*swing_duration *= 0.8_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Axe(SCost)) {
|
|
*energy_cost *= 0.75_f32.powi(level.into());
|
|
}
|
|
},
|
|
LeapMelee {
|
|
ref mut base_damage,
|
|
ref mut knockback,
|
|
ref mut energy_cost,
|
|
ref mut forward_leap_strength,
|
|
ref mut vertical_leap_strength,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Axe(LDamage)) {
|
|
*base_damage *= 1.35_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Axe(LKnockback)) {
|
|
*knockback *= 1.4_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Axe(LCost)) {
|
|
*energy_cost *= 0.75_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Axe(LDistance)) {
|
|
*forward_leap_strength *= 1.2_f32.powi(level.into());
|
|
*vertical_leap_strength *= 1.2_f32.powi(level.into());
|
|
}
|
|
},
|
|
_ => {},
|
|
}
|
|
},
|
|
Some(ToolKind::Hammer) => {
|
|
use skills::HammerSkill::*;
|
|
match self {
|
|
ComboMelee {
|
|
ref mut speed_increase,
|
|
ref mut max_speed_increase,
|
|
ref mut stage_data,
|
|
ref mut max_energy_gain,
|
|
ref mut scales_from_combo,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(SsKnockback)) {
|
|
*stage_data = (*stage_data)
|
|
.iter()
|
|
.map(|s| s.modify_strike(1.5_f32.powi(level.into())))
|
|
.collect::<Vec<combo_melee::Stage<f32>>>();
|
|
}
|
|
let speed_segments = Hammer(SsSpeed).max_level().unwrap_or(1) as f32;
|
|
let speed_level = skillset
|
|
.skill_level(Hammer(SsSpeed))
|
|
.unwrap_or(None)
|
|
.unwrap_or(0) as f32;
|
|
{
|
|
*speed_increase *= speed_level / speed_segments;
|
|
*max_speed_increase *= speed_level / speed_segments;
|
|
}
|
|
let energy_level =
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(SsRegen)) {
|
|
level
|
|
} else {
|
|
0
|
|
};
|
|
*max_energy_gain = *max_energy_gain
|
|
* ((energy_level + 1) * stage_data.len() as u16) as f32
|
|
/ ((Hammer(SsRegen).max_level().unwrap() + 1) * stage_data.len() as u16)
|
|
as f32;
|
|
*scales_from_combo = skillset
|
|
.skill_level(Hammer(SsDamage))
|
|
.unwrap_or(None)
|
|
.unwrap_or(0)
|
|
.into();
|
|
},
|
|
ChargedMelee {
|
|
ref mut scaled_damage,
|
|
ref mut scaled_knockback,
|
|
ref mut energy_drain,
|
|
ref mut charge_duration,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(CDamage)) {
|
|
*scaled_damage *= 1.25_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(CKnockback)) {
|
|
*scaled_knockback *= 1.5_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(CDrain)) {
|
|
*energy_drain *= 0.75_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(CSpeed)) {
|
|
*charge_duration /= 1.25_f32.powi(level.into());
|
|
}
|
|
},
|
|
LeapMelee {
|
|
ref mut base_damage,
|
|
ref mut knockback,
|
|
ref mut energy_cost,
|
|
ref mut forward_leap_strength,
|
|
ref mut vertical_leap_strength,
|
|
ref mut range,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(LDamage)) {
|
|
*base_damage *= 1.4_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(LKnockback)) {
|
|
*knockback *= 1.5_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(LCost)) {
|
|
*energy_cost *= 0.75_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(LDistance)) {
|
|
*forward_leap_strength *= 1.25_f32.powi(level.into());
|
|
*vertical_leap_strength *= 1.25_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Hammer(LRange)) {
|
|
*range += 1.0 * level as f32;
|
|
}
|
|
},
|
|
_ => {},
|
|
}
|
|
},
|
|
Some(ToolKind::Bow) => {
|
|
use skills::BowSkill::*;
|
|
match self {
|
|
ChargedRanged {
|
|
ref mut initial_damage,
|
|
ref mut scaled_damage,
|
|
ref mut initial_regen,
|
|
ref mut scaled_regen,
|
|
ref mut initial_knockback,
|
|
ref mut scaled_knockback,
|
|
ref mut move_speed,
|
|
ref mut initial_projectile_speed,
|
|
ref mut scaled_projectile_speed,
|
|
ref mut charge_duration,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(ProjSpeed)) {
|
|
let projectile_speed_scaling = 1.2_f32.powi(level.into());
|
|
*initial_projectile_speed *= projectile_speed_scaling;
|
|
*scaled_projectile_speed *= projectile_speed_scaling;
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(CDamage)) {
|
|
let damage_scaling = 1.2_f32.powi(level.into());
|
|
*initial_damage *= damage_scaling;
|
|
*scaled_damage *= damage_scaling;
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(CRegen)) {
|
|
let regen_scaling = 1.2_f32.powi(level.into());
|
|
*initial_regen *= regen_scaling;
|
|
*scaled_regen *= regen_scaling;
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(CKnockback)) {
|
|
let knockback_scaling = 1.2_f32.powi(level.into());
|
|
*initial_knockback *= knockback_scaling;
|
|
*scaled_knockback *= knockback_scaling;
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(CSpeed)) {
|
|
*charge_duration /= 1.1_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(CMove)) {
|
|
*move_speed *= 1.1_f32.powi(level.into());
|
|
}
|
|
},
|
|
RepeaterRanged {
|
|
ref mut energy_cost,
|
|
ref mut projectile,
|
|
ref mut max_speed,
|
|
ref mut projectile_speed,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(ProjSpeed)) {
|
|
*projectile_speed *= 1.2_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(RDamage)) {
|
|
let power = 1.2_f32.powi(level.into());
|
|
*projectile = projectile.modified_projectile(power, 1_f32, 1_f32);
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(RCost)) {
|
|
*energy_cost *= 0.8_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(RSpeed)) {
|
|
*max_speed *= 1.2_f32.powi(level.into());
|
|
}
|
|
},
|
|
BasicRanged {
|
|
ref mut projectile,
|
|
ref mut energy_cost,
|
|
ref mut num_projectiles,
|
|
ref mut projectile_spread,
|
|
ref mut projectile_speed,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(ProjSpeed)) {
|
|
*projectile_speed *= 1.2_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(SDamage)) {
|
|
let power = 1.2_f32.powi(level.into());
|
|
*projectile = projectile.modified_projectile(power, 1_f32, 1_f32);
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(SCost)) {
|
|
*energy_cost *= 0.8_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(SArrows)) {
|
|
*num_projectiles += level as u32;
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Bow(SSpread)) {
|
|
*projectile_spread *= 0.8_f32.powi(level.into());
|
|
}
|
|
},
|
|
_ => {},
|
|
}
|
|
},
|
|
Some(ToolKind::Staff) => {
|
|
use skills::StaffSkill::*;
|
|
match self {
|
|
BasicRanged {
|
|
ref mut projectile, ..
|
|
} => {
|
|
let damage_level = skillset
|
|
.skill_level(Staff(BDamage))
|
|
.unwrap_or(None)
|
|
.unwrap_or(0);
|
|
let regen_level = skillset
|
|
.skill_level(Staff(BRegen))
|
|
.unwrap_or(None)
|
|
.unwrap_or(0);
|
|
let range_level = skillset
|
|
.skill_level(Staff(BRadius))
|
|
.unwrap_or(None)
|
|
.unwrap_or(0);
|
|
let power = 1.2_f32.powi(damage_level.into());
|
|
let regen = 1.2_f32.powi(regen_level.into());
|
|
let range = 1.15_f32.powi(range_level.into());
|
|
*projectile = projectile.modified_projectile(power, regen, range);
|
|
},
|
|
BasicBeam {
|
|
ref mut damage,
|
|
ref mut range,
|
|
ref mut energy_drain,
|
|
ref mut beam_duration,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Staff(FDamage)) {
|
|
*damage *= 1.3_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Staff(FRange)) {
|
|
let range_mod = 1.25_f32.powi(level.into());
|
|
*range *= range_mod;
|
|
// Duration modified to keep velocity constant
|
|
*beam_duration *= range_mod;
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Staff(FDrain)) {
|
|
*energy_drain *= 0.8_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Staff(FVelocity)) {
|
|
let velocity_increase = 1.25_f32.powi(level.into());
|
|
let duration_mod = 1.0 / (1.0 + velocity_increase);
|
|
*beam_duration *= duration_mod;
|
|
}
|
|
},
|
|
Shockwave {
|
|
ref mut damage,
|
|
ref mut knockback,
|
|
ref mut shockwave_duration,
|
|
ref mut energy_cost,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Staff(SDamage)) {
|
|
*damage *= 1.3_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Staff(SKnockback)) {
|
|
*knockback = knockback.modify_strength(1.3_f32.powi(level.into()));
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Staff(SRange)) {
|
|
*shockwave_duration *= 1.2_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Staff(SCost)) {
|
|
*energy_cost *= 0.8_f32.powi(level.into());
|
|
}
|
|
},
|
|
_ => {},
|
|
}
|
|
},
|
|
Some(ToolKind::Sceptre) => {
|
|
use skills::SceptreSkill::*;
|
|
match self {
|
|
BasicBeam {
|
|
ref mut damage,
|
|
ref mut range,
|
|
ref mut beam_duration,
|
|
ref mut damage_effect,
|
|
ref mut energy_regen,
|
|
..
|
|
} => {
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(LDamage)) {
|
|
*damage *= 1.2_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(LRange)) {
|
|
let range_mod = 1.2_f32.powi(level.into());
|
|
*range *= range_mod;
|
|
// Duration modified to keep velocity constant
|
|
*beam_duration *= range_mod;
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(LRegen)) {
|
|
*energy_regen *= 1.2_f32.powi(level.into());
|
|
}
|
|
if let (Ok(Some(level)), Some(CombatEffect::Lifesteal(ref mut lifesteal))) =
|
|
(skillset.skill_level(Sceptre(LLifesteal)), damage_effect)
|
|
{
|
|
*lifesteal *= 1.15_f32.powi(level.into());
|
|
}
|
|
},
|
|
BasicAura {
|
|
ref mut aura,
|
|
ref mut range,
|
|
ref mut energy_cost,
|
|
ref specifier,
|
|
..
|
|
} => {
|
|
if matches!(*specifier, aura::Specifier::WardingAura) {
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(AStrength)) {
|
|
aura.strength *= 1.15_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(ADuration)) {
|
|
aura.duration.map(|dur| dur * 1.2_f32.powi(level.into()));
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(ARange)) {
|
|
*range *= 1.25_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(ACost)) {
|
|
*energy_cost *= 0.85_f32.powi(level.into());
|
|
}
|
|
} else if matches!(*specifier, aura::Specifier::HealingAura) {
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(HHeal)) {
|
|
aura.strength *= 1.15_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(HDuration)) {
|
|
aura.duration.map(|dur| dur * 1.2_f32.powi(level.into()));
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(HRange)) {
|
|
*range *= 1.25_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Sceptre(HCost)) {
|
|
*energy_cost *= 0.85_f32.powi(level.into());
|
|
}
|
|
}
|
|
},
|
|
_ => {},
|
|
}
|
|
},
|
|
Some(ToolKind::Pick) => {
|
|
use skills::MiningSkill::*;
|
|
if let BasicMelee {
|
|
ref mut buildup_duration,
|
|
ref mut swing_duration,
|
|
ref mut recover_duration,
|
|
..
|
|
} = self
|
|
{
|
|
if let Ok(Some(level)) = skillset.skill_level(Pick(Speed)) {
|
|
let speed = 1.1_f32.powi(level.into());
|
|
*buildup_duration /= speed;
|
|
*swing_duration /= speed;
|
|
*recover_duration /= speed;
|
|
}
|
|
}
|
|
},
|
|
None => {
|
|
if let CharacterAbility::Roll {
|
|
ref mut energy_cost,
|
|
ref mut roll_strength,
|
|
ref mut movement_duration,
|
|
..
|
|
} = self
|
|
{
|
|
use skills::RollSkill::*;
|
|
if let Ok(Some(level)) = skillset.skill_level(Skill::Roll(Cost)) {
|
|
*energy_cost *= 0.9_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Skill::Roll(Strength)) {
|
|
*roll_strength *= 1.1_f32.powi(level.into());
|
|
}
|
|
if let Ok(Some(level)) = skillset.skill_level(Skill::Roll(Duration)) {
|
|
*movement_duration *= 1.1_f32.powi(level.into());
|
|
}
|
|
}
|
|
},
|
|
Some(_) => {},
|
|
}
|
|
self
|
|
}
|
|
}
|
|
|
|
impl From<(&CharacterAbility, AbilityInfo)> for CharacterState {
|
|
fn from((ability, ability_info): (&CharacterAbility, AbilityInfo)) -> Self {
|
|
match ability {
|
|
CharacterAbility::BasicMelee {
|
|
buildup_duration,
|
|
swing_duration,
|
|
recover_duration,
|
|
base_damage,
|
|
base_poise_damage,
|
|
knockback,
|
|
range,
|
|
max_angle,
|
|
damage_effect,
|
|
energy_cost: _,
|
|
damage_kind,
|
|
} => CharacterState::BasicMelee(basic_melee::Data {
|
|
static_data: basic_melee::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
swing_duration: Duration::from_secs_f32(*swing_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
base_damage: *base_damage,
|
|
base_poise_damage: *base_poise_damage,
|
|
knockback: *knockback,
|
|
range: *range,
|
|
max_angle: *max_angle,
|
|
damage_effect: *damage_effect,
|
|
ability_info,
|
|
damage_kind: *damage_kind,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
exhausted: false,
|
|
}),
|
|
CharacterAbility::BasicRanged {
|
|
buildup_duration,
|
|
recover_duration,
|
|
projectile,
|
|
projectile_body,
|
|
projectile_light,
|
|
projectile_speed,
|
|
energy_cost: _,
|
|
num_projectiles,
|
|
projectile_spread,
|
|
} => CharacterState::BasicRanged(basic_ranged::Data {
|
|
static_data: basic_ranged::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
projectile: *projectile,
|
|
projectile_body: *projectile_body,
|
|
projectile_light: *projectile_light,
|
|
projectile_speed: *projectile_speed,
|
|
num_projectiles: *num_projectiles,
|
|
projectile_spread: *projectile_spread,
|
|
ability_info,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
exhausted: false,
|
|
}),
|
|
CharacterAbility::Boost {
|
|
movement_duration,
|
|
only_up,
|
|
speed,
|
|
max_exit_velocity,
|
|
} => CharacterState::Boost(boost::Data {
|
|
static_data: boost::StaticData {
|
|
movement_duration: Duration::from_secs_f32(*movement_duration),
|
|
only_up: *only_up,
|
|
speed: *speed,
|
|
max_exit_velocity: *max_exit_velocity,
|
|
ability_info,
|
|
},
|
|
timer: Duration::default(),
|
|
}),
|
|
CharacterAbility::DashMelee {
|
|
energy_cost: _,
|
|
base_damage,
|
|
scaled_damage,
|
|
base_poise_damage,
|
|
scaled_poise_damage,
|
|
base_knockback,
|
|
scaled_knockback,
|
|
range,
|
|
angle,
|
|
energy_drain,
|
|
forward_speed,
|
|
buildup_duration,
|
|
charge_duration,
|
|
swing_duration,
|
|
recover_duration,
|
|
charge_through,
|
|
is_interruptible,
|
|
damage_kind,
|
|
} => CharacterState::DashMelee(dash_melee::Data {
|
|
static_data: dash_melee::StaticData {
|
|
base_damage: *base_damage,
|
|
scaled_damage: *scaled_damage,
|
|
base_poise_damage: *base_poise_damage,
|
|
scaled_poise_damage: *scaled_poise_damage,
|
|
base_knockback: *base_knockback,
|
|
scaled_knockback: *scaled_knockback,
|
|
range: *range,
|
|
angle: *angle,
|
|
energy_drain: *energy_drain,
|
|
forward_speed: *forward_speed,
|
|
charge_through: *charge_through,
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
charge_duration: Duration::from_secs_f32(*charge_duration),
|
|
swing_duration: Duration::from_secs_f32(*swing_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
is_interruptible: *is_interruptible,
|
|
ability_info,
|
|
damage_kind: *damage_kind,
|
|
},
|
|
auto_charge: false,
|
|
timer: Duration::default(),
|
|
charge_end_timer: Duration::from_secs_f32(*charge_duration),
|
|
stage_section: StageSection::Buildup,
|
|
exhausted: false,
|
|
}),
|
|
CharacterAbility::BasicBlock {
|
|
buildup_duration,
|
|
recover_duration,
|
|
max_angle,
|
|
block_strength,
|
|
energy_cost: _,
|
|
} => CharacterState::BasicBlock(basic_block::Data {
|
|
static_data: basic_block::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
max_angle: *max_angle,
|
|
block_strength: *block_strength,
|
|
ability_info,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
}),
|
|
CharacterAbility::Roll {
|
|
energy_cost: _,
|
|
buildup_duration,
|
|
movement_duration,
|
|
recover_duration,
|
|
roll_strength,
|
|
immune_melee,
|
|
} => CharacterState::Roll(roll::Data {
|
|
static_data: roll::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
movement_duration: Duration::from_secs_f32(*movement_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
roll_strength: *roll_strength,
|
|
immune_melee: *immune_melee,
|
|
ability_info,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
was_wielded: false, // false by default. utils might set it to true
|
|
was_sneak: false,
|
|
was_combo: None,
|
|
}),
|
|
CharacterAbility::ComboMelee {
|
|
stage_data,
|
|
initial_energy_gain,
|
|
max_energy_gain,
|
|
energy_increase,
|
|
speed_increase,
|
|
max_speed_increase,
|
|
scales_from_combo,
|
|
is_interruptible,
|
|
ori_modifier,
|
|
} => CharacterState::ComboMelee(combo_melee::Data {
|
|
static_data: combo_melee::StaticData {
|
|
num_stages: stage_data.len() as u32,
|
|
stage_data: stage_data.iter().map(|stage| stage.to_duration()).collect(),
|
|
initial_energy_gain: *initial_energy_gain,
|
|
max_energy_gain: *max_energy_gain,
|
|
energy_increase: *energy_increase,
|
|
speed_increase: 1.0 - *speed_increase,
|
|
max_speed_increase: *max_speed_increase,
|
|
scales_from_combo: *scales_from_combo,
|
|
is_interruptible: *is_interruptible,
|
|
ori_modifier: *ori_modifier as f32,
|
|
ability_info,
|
|
},
|
|
exhausted: false,
|
|
stage: 1,
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
}),
|
|
CharacterAbility::LeapMelee {
|
|
energy_cost: _,
|
|
buildup_duration,
|
|
movement_duration,
|
|
swing_duration,
|
|
recover_duration,
|
|
base_damage,
|
|
base_poise_damage,
|
|
knockback,
|
|
range,
|
|
max_angle,
|
|
forward_leap_strength,
|
|
vertical_leap_strength,
|
|
damage_kind,
|
|
} => CharacterState::LeapMelee(leap_melee::Data {
|
|
static_data: leap_melee::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
movement_duration: Duration::from_secs_f32(*movement_duration),
|
|
swing_duration: Duration::from_secs_f32(*swing_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
base_damage: *base_damage,
|
|
base_poise_damage: *base_poise_damage,
|
|
knockback: *knockback,
|
|
range: *range,
|
|
max_angle: *max_angle,
|
|
forward_leap_strength: *forward_leap_strength,
|
|
vertical_leap_strength: *vertical_leap_strength,
|
|
ability_info,
|
|
damage_kind: *damage_kind,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
exhausted: false,
|
|
}),
|
|
CharacterAbility::SpinMelee {
|
|
buildup_duration,
|
|
swing_duration,
|
|
recover_duration,
|
|
base_damage,
|
|
base_poise_damage,
|
|
knockback,
|
|
range,
|
|
damage_effect,
|
|
energy_cost,
|
|
is_infinite,
|
|
movement_behavior,
|
|
is_interruptible,
|
|
forward_speed,
|
|
num_spins,
|
|
specifier,
|
|
target,
|
|
damage_kind,
|
|
} => CharacterState::SpinMelee(spin_melee::Data {
|
|
static_data: spin_melee::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
swing_duration: Duration::from_secs_f32(*swing_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
base_damage: *base_damage,
|
|
base_poise_damage: *base_poise_damage,
|
|
knockback: *knockback,
|
|
range: *range,
|
|
damage_effect: *damage_effect,
|
|
energy_cost: *energy_cost,
|
|
is_infinite: *is_infinite,
|
|
movement_behavior: *movement_behavior,
|
|
is_interruptible: *is_interruptible,
|
|
forward_speed: *forward_speed,
|
|
num_spins: *num_spins,
|
|
target: *target,
|
|
ability_info,
|
|
specifier: *specifier,
|
|
damage_kind: *damage_kind,
|
|
},
|
|
timer: Duration::default(),
|
|
consecutive_spins: 1,
|
|
stage_section: StageSection::Buildup,
|
|
exhausted: false,
|
|
}),
|
|
CharacterAbility::ChargedMelee {
|
|
energy_cost,
|
|
energy_drain,
|
|
initial_damage,
|
|
scaled_damage,
|
|
initial_poise_damage,
|
|
scaled_poise_damage,
|
|
initial_knockback,
|
|
scaled_knockback,
|
|
charge_duration,
|
|
swing_duration,
|
|
hit_timing,
|
|
recover_duration,
|
|
range,
|
|
max_angle,
|
|
specifier,
|
|
damage_kind,
|
|
} => CharacterState::ChargedMelee(charged_melee::Data {
|
|
static_data: charged_melee::StaticData {
|
|
energy_cost: *energy_cost,
|
|
energy_drain: *energy_drain,
|
|
initial_damage: *initial_damage,
|
|
scaled_damage: *scaled_damage,
|
|
initial_poise_damage: *initial_poise_damage,
|
|
scaled_poise_damage: *scaled_poise_damage,
|
|
initial_knockback: *initial_knockback,
|
|
scaled_knockback: *scaled_knockback,
|
|
range: *range,
|
|
max_angle: *max_angle,
|
|
charge_duration: Duration::from_secs_f32(*charge_duration),
|
|
swing_duration: Duration::from_secs_f32(*swing_duration),
|
|
hit_timing: *hit_timing,
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
ability_info,
|
|
specifier: *specifier,
|
|
damage_kind: *damage_kind,
|
|
},
|
|
stage_section: StageSection::Charge,
|
|
timer: Duration::default(),
|
|
exhausted: false,
|
|
charge_amount: 0.0,
|
|
}),
|
|
CharacterAbility::ChargedRanged {
|
|
energy_cost: _,
|
|
energy_drain,
|
|
initial_regen,
|
|
scaled_regen,
|
|
initial_damage,
|
|
scaled_damage,
|
|
initial_knockback,
|
|
scaled_knockback,
|
|
buildup_duration,
|
|
charge_duration,
|
|
recover_duration,
|
|
projectile_body,
|
|
projectile_light,
|
|
initial_projectile_speed,
|
|
scaled_projectile_speed,
|
|
move_speed,
|
|
} => CharacterState::ChargedRanged(charged_ranged::Data {
|
|
static_data: charged_ranged::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
charge_duration: Duration::from_secs_f32(*charge_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
energy_drain: *energy_drain,
|
|
initial_regen: *initial_regen,
|
|
scaled_regen: *scaled_regen,
|
|
initial_damage: *initial_damage,
|
|
scaled_damage: *scaled_damage,
|
|
initial_knockback: *initial_knockback,
|
|
scaled_knockback: *scaled_knockback,
|
|
projectile_body: *projectile_body,
|
|
projectile_light: *projectile_light,
|
|
initial_projectile_speed: *initial_projectile_speed,
|
|
scaled_projectile_speed: *scaled_projectile_speed,
|
|
move_speed: *move_speed,
|
|
ability_info,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
exhausted: false,
|
|
}),
|
|
CharacterAbility::RepeaterRanged {
|
|
energy_cost,
|
|
buildup_duration,
|
|
shoot_duration,
|
|
recover_duration,
|
|
max_speed,
|
|
half_speed_at,
|
|
projectile,
|
|
projectile_body,
|
|
projectile_light,
|
|
projectile_speed,
|
|
} => CharacterState::RepeaterRanged(repeater_ranged::Data {
|
|
static_data: repeater_ranged::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
shoot_duration: Duration::from_secs_f32(*shoot_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
energy_cost: *energy_cost,
|
|
// 1.0 is subtracted as 1.0 is added in state file
|
|
max_speed: *max_speed - 1.0,
|
|
half_speed_at: *half_speed_at,
|
|
projectile: *projectile,
|
|
projectile_body: *projectile_body,
|
|
projectile_light: *projectile_light,
|
|
projectile_speed: *projectile_speed,
|
|
ability_info,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
projectiles_fired: 0,
|
|
speed: 1.0,
|
|
}),
|
|
CharacterAbility::Shockwave {
|
|
energy_cost: _,
|
|
buildup_duration,
|
|
swing_duration,
|
|
recover_duration,
|
|
damage,
|
|
poise_damage,
|
|
knockback,
|
|
shockwave_angle,
|
|
shockwave_vertical_angle,
|
|
shockwave_speed,
|
|
shockwave_duration,
|
|
requires_ground,
|
|
move_efficiency,
|
|
damage_kind,
|
|
specifier,
|
|
} => CharacterState::Shockwave(shockwave::Data {
|
|
static_data: shockwave::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
swing_duration: Duration::from_secs_f32(*swing_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
damage: *damage,
|
|
poise_damage: *poise_damage,
|
|
knockback: *knockback,
|
|
shockwave_angle: *shockwave_angle,
|
|
shockwave_vertical_angle: *shockwave_vertical_angle,
|
|
shockwave_speed: *shockwave_speed,
|
|
shockwave_duration: Duration::from_secs_f32(*shockwave_duration),
|
|
requires_ground: *requires_ground,
|
|
move_efficiency: *move_efficiency,
|
|
ability_info,
|
|
damage_kind: *damage_kind,
|
|
specifier: *specifier,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
}),
|
|
CharacterAbility::BasicBeam {
|
|
buildup_duration,
|
|
recover_duration,
|
|
beam_duration,
|
|
damage,
|
|
tick_rate,
|
|
range,
|
|
max_angle,
|
|
damage_effect,
|
|
energy_regen,
|
|
energy_drain,
|
|
orientation_behavior,
|
|
ori_rate,
|
|
specifier,
|
|
} => CharacterState::BasicBeam(basic_beam::Data {
|
|
static_data: basic_beam::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
beam_duration: Duration::from_secs_f32(*beam_duration),
|
|
damage: *damage,
|
|
tick_rate: *tick_rate,
|
|
range: *range,
|
|
max_angle: *max_angle,
|
|
damage_effect: *damage_effect,
|
|
energy_regen: *energy_regen,
|
|
energy_drain: *energy_drain,
|
|
ability_info,
|
|
orientation_behavior: *orientation_behavior,
|
|
ori_rate: *ori_rate,
|
|
specifier: *specifier,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
}),
|
|
CharacterAbility::BasicAura {
|
|
buildup_duration,
|
|
cast_duration,
|
|
recover_duration,
|
|
targets,
|
|
aura,
|
|
aura_duration,
|
|
range,
|
|
energy_cost: _,
|
|
scales_with_combo,
|
|
specifier,
|
|
} => CharacterState::BasicAura(basic_aura::Data {
|
|
static_data: basic_aura::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
cast_duration: Duration::from_secs_f32(*cast_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
targets: *targets,
|
|
aura: *aura,
|
|
aura_duration: Duration::from_secs_f32(*aura_duration),
|
|
range: *range,
|
|
ability_info,
|
|
scales_with_combo: *scales_with_combo,
|
|
specifier: *specifier,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
}),
|
|
CharacterAbility::Blink {
|
|
buildup_duration,
|
|
recover_duration,
|
|
max_range,
|
|
} => CharacterState::Blink(blink::Data {
|
|
static_data: blink::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
max_range: *max_range,
|
|
ability_info,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
}),
|
|
CharacterAbility::BasicSummon {
|
|
buildup_duration,
|
|
cast_duration,
|
|
recover_duration,
|
|
summon_amount,
|
|
summon_distance,
|
|
summon_info,
|
|
duration,
|
|
} => CharacterState::BasicSummon(basic_summon::Data {
|
|
static_data: basic_summon::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
cast_duration: Duration::from_secs_f32(*cast_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
summon_amount: *summon_amount,
|
|
summon_distance: *summon_distance,
|
|
summon_info: *summon_info,
|
|
ability_info,
|
|
duration: *duration,
|
|
},
|
|
summon_count: 0,
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
}),
|
|
CharacterAbility::SelfBuff {
|
|
buildup_duration,
|
|
cast_duration,
|
|
recover_duration,
|
|
buff_kind,
|
|
buff_strength,
|
|
buff_duration,
|
|
energy_cost: _,
|
|
} => CharacterState::SelfBuff(self_buff::Data {
|
|
static_data: self_buff::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
cast_duration: Duration::from_secs_f32(*cast_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
buff_kind: *buff_kind,
|
|
buff_strength: *buff_strength,
|
|
buff_duration: buff_duration.map(Duration::from_secs_f32),
|
|
ability_info,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
}),
|
|
CharacterAbility::SpriteSummon {
|
|
buildup_duration,
|
|
cast_duration,
|
|
recover_duration,
|
|
sprite,
|
|
summon_distance,
|
|
sparseness,
|
|
} => CharacterState::SpriteSummon(sprite_summon::Data {
|
|
static_data: sprite_summon::StaticData {
|
|
buildup_duration: Duration::from_secs_f32(*buildup_duration),
|
|
cast_duration: Duration::from_secs_f32(*cast_duration),
|
|
recover_duration: Duration::from_secs_f32(*recover_duration),
|
|
sprite: *sprite,
|
|
summon_distance: *summon_distance,
|
|
sparseness: *sparseness,
|
|
ability_info,
|
|
},
|
|
timer: Duration::default(),
|
|
stage_section: StageSection::Buildup,
|
|
achieved_radius: summon_distance.0.floor() as i32 - 1,
|
|
}),
|
|
}
|
|
}
|
|
}
|