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

Move skill boost modifiers to skills module

Browse Source
This commit is contained in:
juliancoffee 2021-07-01 20:08:23 +03:00
parent e387617017
commit 274acae939
6 changed files with 577 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

442
common/src/comp/ability.rs
View File

@ -5,7 +5,8 @@ use crate::{
self, aura, beam, buff,
inventory::item::tool::{Stats, ToolKind},
projectile::ProjectileConstructor,
skills, Body, CharacterState, EnergySource, LightEmitter, StateUpdate,
skills::{self, Boost},
Body, CharacterState, EnergySource, LightEmitter, StateUpdate,
},
states::{
behavior::JoinData,
@ -784,22 +785,22 @@ impl CharacterAbility {
ref mut charge_through,
..
} => {
skills::adjust_with_level(skillset, Sword(DCost), |m, level| {
*energy_cost *= m.powi(level.into())
});
skills::adjust_with_level(skillset, Sword(DDrain), |m, level| {
*energy_drain *= m.powi(level.into())
});
skills::adjust_with_level(skillset, Sword(DDamage), |m, level| {
*base_damage *= m.powi(level.into())
});
skills::adjust_with_level(skillset, Sword(DScaling), |m, level| {
*scaled_damage *= m.powi(level.into())
});
skills::set_if_has(skillset, Sword(DSpeed), |m| {
*forward_speed *= m;
});
*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 {
@ -810,16 +811,16 @@ impl CharacterAbility {
ref mut num_spins,
..
} => {
skills::adjust_with_level(skillset, Sword(SDamage), |m, level| {
*base_damage *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Sword(SSpeed), |m, level| {
*swing_duration *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Sword(SCost), |m, level| {
*energy_cost *= m.powi(level.into());
});
*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)
@ -876,21 +877,21 @@ impl CharacterAbility {
ref mut movement_behavior,
..
} => {
skills::adjust_with_level(skillset, Axe(SDamage), |m, level| {
*base_damage *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Axe(SSpeed), |m, level| {
*swing_duration *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Axe(SCost), |m, level| {
*energy_cost *= m.powi(level.into());
});
*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,
@ -900,19 +901,19 @@ impl CharacterAbility {
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());
}
skills::adjust_with_level(skillset, Axe(LDamage), |m, level| {
*base_damage *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Axe(LKnockback), |m, level| {
*knockback *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Axe(LCost), |m, level| {
*energy_cost *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Axe(LDistance), |m, level| {
*forward_leap_strength *= m.powi(level.into());
*vertical_leap_strength *= m.powi(level.into());
});
},
_ => {},
}
@ -928,12 +929,13 @@ impl CharacterAbility {
ref mut scales_from_combo,
..
} => {
if let Ok(Some(level)) = skillset.skill_level(Hammer(SsKnockback)) {
skills::adjust_with_level(skillset, Hammer(SsKnockback), |m, level| {
let knockback_mult = m.powi(level.into());
*stage_data = (*stage_data)
.iter()
.map(|s| s.modify_strike(1.5_f32.powi(level.into())))
.map(|s| s.modify_strike(knockback_mult))
.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))
@ -966,18 +968,18 @@ impl CharacterAbility {
ref mut speed,
..
} => {
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)) {
*speed *= 1.25_f32.powi(level.into());
}
skills::adjust_with_level(skillset, Hammer(CDamage), |m, level| {
*scaled_damage *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Hammer(CKnockback), |m, level| {
*scaled_knockback *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Hammer(CDrain), |m, level| {
*energy_drain *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Hammer(CSpeed), |m, level| {
*speed *= m.powi(level.into());
});
},
LeapMelee {
ref mut base_damage,
@ -988,22 +990,22 @@ impl CharacterAbility {
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;
}
skills::adjust_with_level(skillset, Hammer(LDamage), |m, level| {
*base_damage *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Hammer(LKnockback), |m, level| {
*knockback *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Hammer(LCost), |m, level| {
*energy_cost *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Hammer(LDistance), |m, level| {
*forward_leap_strength *= m.powi(level.into());
*vertical_leap_strength *= m.powi(level.into());
});
skills::adjust_counter_with_level(skillset, Hammer(LRange), |m, level| {
*range += (m * level) as f32;
});
},
_ => {},
}
@ -1024,32 +1026,32 @@ impl CharacterAbility {
ref mut scaled_projectile_speed,
..
} => {
if let Ok(Some(level)) = skillset.skill_level(Bow(ProjSpeed)) {
let projectile_speed_scaling = 1.2_f32.powi(level.into());
skills::adjust_with_level(skillset, Bow(ProjSpeed), |m, level| {
let projectile_speed_scaling = m.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());
});
skills::adjust_with_level(skillset, Bow(CDamage), |m, level| {
let damage_scaling = m.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());
});
skills::adjust_with_level(skillset, Bow(CRegen), |m, level| {
let regen_scaling = m.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());
});
skills::adjust_with_level(skillset, Bow(CKnockback), |m, level| {
let knockback_scaling = m.powi(level.into());
*initial_knockback *= knockback_scaling;
*scaled_knockback *= knockback_scaling;
}
if let Ok(Some(level)) = skillset.skill_level(Bow(CSpeed)) {
*speed *= 1.1_f32.powi(level.into());
}
if let Ok(Some(level)) = skillset.skill_level(Bow(CMove)) {
*move_speed *= 1.1_f32.powi(level.into());
}
});
skills::adjust_with_level(skillset, Bow(CSpeed), |m, level| {
*speed *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Bow(CMove), |m, level| {
*move_speed *= m.powi(level.into());
});
},
RepeaterRanged {
ref mut energy_cost,
@ -1058,19 +1060,19 @@ impl CharacterAbility {
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());
skills::adjust_with_level(skillset, Bow(ProjSpeed), |m, level| {
*projectile_speed *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Bow(RDamage), |m, level| {
let power = m.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());
}
});
skills::adjust_with_level(skillset, Bow(RCost), |m, level| {
*energy_cost *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Bow(RSpeed), |m, level| {
*max_speed *= m.powi(level.into());
});
},
BasicRanged {
ref mut projectile,
@ -1080,22 +1082,22 @@ impl CharacterAbility {
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());
skills::adjust_with_level(skillset, Bow(ProjSpeed), |m, level| {
*projectile_speed *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Bow(SDamage), |m, level| {
let power = m.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());
}
});
skills::adjust_with_level(skillset, Bow(SCost), |m, level| {
*energy_cost *= m.powi(level.into());
});
skills::adjust_counter_with_level(skillset, Bow(SArrows), |m, level| {
*num_projectiles += (m * level) as u32;
});
skills::adjust_with_level(skillset, Bow(SSpread), |m, level| {
*projectile_spread *= m.powi(level.into());
});
},
_ => {},
}
@ -1106,21 +1108,39 @@ impl CharacterAbility {
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());
let power = {
let skill = Staff(BDamage);
let level = skillset.skill_level(skill).unwrap_or(None).unwrap_or(0);
if let Some(m) = skill.boost().as_mult_maybe() {
m.powi(level.into())
} else {
skills::invalid_skill_boost(skill);
1.0
}
};
let regen = {
let skill = Staff(BRegen);
let level = skillset.skill_level(skill).unwrap_or(None).unwrap_or(0);
if let Some(m) = skill.boost().as_mult_maybe() {
m.powi(level.into())
} else {
skills::invalid_skill_boost(skill);
1.0
}
};
let range = {
let skill = Staff(BRadius);
let level = skillset.skill_level(skill).unwrap_or(None).unwrap_or(0);
if let Some(m) = skill.boost().as_mult_maybe() {
m.powi(level.into())
} else {
skills::invalid_skill_boost(skill);
1.0
}
};
*projectile = projectile.modified_projectile(power, regen, range);
},
BasicBeam {
@ -1130,23 +1150,23 @@ impl CharacterAbility {
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());
skills::adjust_with_level(skillset, Staff(FDamage), |m, level| {
*damage *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Staff(FRange), |m, level| {
let range_mod = m.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());
});
skills::adjust_with_level(skillset, Staff(FDrain), |m, level| {
*energy_drain *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Staff(FVelocity), |m, level| {
let velocity_increase = m.powi(level.into());
let duration_mod = 1.0 / (1.0 + velocity_increase);
*beam_duration *= duration_mod;
}
});
},
Shockwave {
ref mut damage,
@ -1155,18 +1175,19 @@ impl CharacterAbility {
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());
}
skills::adjust_with_level(skillset, Staff(SDamage), |m, level| {
*damage *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Staff(SKnockback), |m, level| {
let strength_modifier = m.powi(level.into());
*knockback = knockback.modify_strength(strength_modifier);
});
skills::adjust_with_level(skillset, Staff(SRange), |m, level| {
*shockwave_duration *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Staff(SCost), |m, level| {
*energy_cost *= m.powi(level.into());
});
},
_ => {},
}
@ -1182,23 +1203,24 @@ impl CharacterAbility {
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());
skills::adjust_with_level(skillset, Sceptre(LDamage), |m, level| {
*damage *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Sceptre(LRange), |m, level| {
let range_mod = m.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());
}
});
skills::adjust_with_level(skillset, Sceptre(LRegen), |m, level| {
*energy_regen *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Sceptre(LLifesteal), |m, level| {
if let Some(CombatEffect::Lifesteal(ref mut lifesteal)) = damage_effect
{
*lifesteal *= m.powi(level.into());
}
});
},
HealingBeam {
ref mut heal,
@ -1207,18 +1229,18 @@ impl CharacterAbility {
ref mut beam_duration,
..
} => {
if let Ok(Some(level)) = skillset.skill_level(Sceptre(HHeal)) {
*heal *= 1.2_f32.powi(level.into());
}
if let Ok(Some(level)) = skillset.skill_level(Sceptre(HRange)) {
let range_mod = 1.2_f32.powi(level.into());
skills::adjust_with_level(skillset, Sceptre(HHeal), |m, level| {
*heal *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Sceptre(HRange), |m, level| {
let range_mod = m.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(HCost)) {
*energy_cost *= 0.8_f32.powi(level.into());
}
});
skills::adjust_with_level(skillset, Sceptre(HCost), |m, level| {
*energy_cost *= m.powi(level.into());
});
},
BasicAura {
ref mut aura,
@ -1226,18 +1248,20 @@ impl CharacterAbility {
ref mut energy_cost,
..
} => {
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());
}
skills::adjust_with_level(skillset, Sceptre(AStrength), |m, level| {
aura.strength *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Sceptre(ADuration), |m, level| {
if let Some(ref mut duration) = aura.duration {
*duration *= m.powi(level.into());
}
});
skills::adjust_with_level(skillset, Sceptre(ARange), |m, level| {
*range *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Sceptre(ACost), |m, level| {
*energy_cost *= m.powi(level.into());
});
},
_ => {},
}
@ -1251,12 +1275,12 @@ impl CharacterAbility {
..
} = self
{
if let Ok(Some(level)) = skillset.skill_level(Pick(Speed)) {
let speed = 1.1_f32.powi(level.into());
skills::adjust_with_level(skillset, Pick(Speed), |m, level| {
let speed = m.powi(level.into());
*buildup_duration /= speed;
*swing_duration /= speed;
*recover_duration /= speed;
}
});
}
},
None => {
@ -1268,15 +1292,15 @@ impl CharacterAbility {
} = 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());
}
skills::adjust_with_level(skillset, Skill::Roll(Cost), |m, level| {
*energy_cost *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Skill::Roll(Strength), |m, level| {
*roll_strength *= m.powi(level.into());
});
skills::adjust_with_level(skillset, Skill::Roll(Duration), |m, level| {
*movement_duration *= m.powi(level.into());
});
}
},
Some(_) => {},

2
common/src/comp/energy.rs
View File

@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
use specs::{Component, DerefFlaggedStorage};
use specs_idvs::IdvStorage;
pub const ENERGY_PER_LEVEL: u32 = 50;
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct Energy {
current: u32,
@ -99,7 +100,6 @@ impl Energy {
}
pub fn update_max_energy(&mut self, body: Option<Body>, level: u16) {
const ENERGY_PER_LEVEL: u32 = 50;
if let Some(body) = body {
// Checks the current difference between maximum and base max
let current_difference = self.maximum as i32 - self.base_max as i32;

306
common/src/comp/skills.rs
View File

@ -1,6 +1,10 @@
use crate::{
assets::{self, Asset, AssetExt},
comp::item::tool::ToolKind,
comp::{
self,
body::{humanoid, Body},
item::tool::ToolKind,
},
};
use hashbrown::{HashMap, HashSet};
use lazy_static::lazy_static;
@ -110,6 +114,106 @@ pub enum Skill {
Pick(MiningSkill),
}
/// Enum which returned as result from `boost` function
/// `Number` can represent values from -inf to +inf,
/// but it should generaly be in range -50..50
///
/// Number(-25) says that some value
/// will be reduced by 25% (for example energy consumption)
///
/// Number(15) says that some value
/// will be increased by 15% (for example damage)
#[derive(Debug, Clone, Copy)]
pub enum BoostValue {
Number(i16),
NonDescriptive,
}
impl BoostValue {
pub fn as_mult_maybe(self) -> Option<f32> {
match self {
Self::Number(x) => Some(1.0 + x as f32 * 0.01),
Self::NonDescriptive => None,
}
}
pub fn as_i16_maybe(self) -> Option<i16> {
match self {
Self::Number(x) => Some(x),
Self::NonDescriptive => None,
}
}
}
impl From<i16> for BoostValue {
fn from(number: i16) -> Self { BoostValue::Number(number) }
}
pub fn adjust_with_level(skillset: &SkillSet, skill: Skill, effect: impl FnOnce(f32, u16)) {
if let Ok(Some(level)) = skillset.skill_level(skill) {
skill
.boost()
.as_mult_maybe()
.map_or_else(|| invalid_skill_boost(skill), |m| effect(m, level))
}
}
pub fn adjust_counter_with_level(skillset: &SkillSet, skill: Skill, effect: impl FnOnce(i16, i16)) {
if let Ok(Some(level)) = skillset.skill_level(skill) {
skill
.boost()
.as_i16_maybe()
.map_or_else(|| invalid_skill_boost(skill), |m| effect(m, level as i16))
}
}
pub fn set_if_has(skillset: &SkillSet, skill: Skill, effect: impl FnOnce(f32)) {
if skillset.has_skill(skill) {
skill
.boost()
.as_mult_maybe()
.map_or_else(|| invalid_skill_boost(skill), |m| effect(m))
}
}
pub fn invalid_skill_boost(skill: Skill) {
let err_msg = format!(
"{:?} produced unexpected BoostValue: {:?}",
skill,
skill.boost()
);
common_base::dev_panic!(err_msg);
}
/// Returns value which corresponds to the boost given by this skill
pub trait Boost {
fn boost(self) -> BoostValue;
}
impl Boost for Skill {
fn boost(self) -> BoostValue {
match self {
// General tree boosts
Skill::General(s) => s.boost(),
// Weapon tree boosts
Skill::Sword(s) => s.boost(),
Skill::Axe(s) => s.boost(),
Skill::Hammer(s) => s.boost(),
Skill::Bow(s) => s.boost(),
Skill::Staff(s) => s.boost(),
Skill::Sceptre(s) => s.boost(),
// Movement tree boosts
Skill::Roll(s) => s.boost(),
Skill::Climb(s) => s.boost(),
Skill::Swim(s) => s.boost(),
// Non-combat tree boosts
Skill::Pick(s) => s.boost(),
// Unlock Group has more complex semantic
Skill::UnlockGroup(_) => BoostValue::NonDescriptive,
}
}
}
pub enum SkillError {
MissingSkill,
}
@ -138,6 +242,32 @@ pub enum SwordSkill {
SSpins,
}
impl Boost for SwordSkill {
fn boost(self) -> BoostValue {
match self {
// Dash
Self::DDamage => 20.into(),
Self::DCost => (-25_i16).into(),
Self::DDrain => (-25_i16).into(),
Self::DScaling => 20.into(),
Self::DSpeed => 15.into(),
// Spin
Self::SDamage => 40.into(),
Self::SSpeed => (-20_i16).into(),
Self::SCost => (-25_i16).into(),
// Non-descriptive values
Self::InterruptingAttacks
| Self::TsCombo
| Self::TsDamage
| Self::TsRegen
| Self::TsSpeed
| Self::DInfinite
| Self::UnlockSpin
| Self::SSpins => BoostValue::NonDescriptive,
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum AxeSkill {
// Double strike upgrades
@ -159,6 +289,30 @@ pub enum AxeSkill {
LDistance,
}
impl Boost for AxeSkill {
fn boost(self) -> BoostValue {
match self {
// Spin upgrades
Self::SDamage => 30.into(),
Self::SSpeed => (-20_i16).into(),
Self::SCost => (-25_i16).into(),
// Leap upgrades
Self::LDamage => 35.into(),
Self::LKnockback => 40.into(),
Self::LCost => (-25_i16).into(),
Self::LDistance => 20.into(),
// Non-descriptive boosts
Self::UnlockLeap
| Self::DsCombo
| Self::DsDamage
| Self::DsSpeed
| Self::DsRegen
| Self::SInfinite
| Self::SHelicopter => BoostValue::NonDescriptive,
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum HammerSkill {
// Single strike upgrades
@ -180,6 +334,30 @@ pub enum HammerSkill {
LRange,
}
impl Boost for HammerSkill {
fn boost(self) -> BoostValue {
match self {
// Single strike upgrades
Self::SsKnockback => 50.into(),
// Charged melee upgrades
Self::CDamage => 25.into(),
Self::CKnockback => 50.into(),
Self::CDrain => (-25_i16).into(),
Self::CSpeed => 25.into(),
// Leap upgrades
Self::LDamage => 40.into(),
Self::LKnockback => 50.into(),
Self::LCost => (-25_i16).into(),
Self::LDistance => 25.into(),
Self::LRange => 1.into(),
// Non-descriptive values
Self::UnlockLeap | Self::SsDamage | Self::SsSpeed | Self::SsRegen => {
BoostValue::NonDescriptive
},
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum BowSkill {
// Passives
@ -202,6 +380,32 @@ pub enum BowSkill {
SSpread,
}
impl Boost for BowSkill {
fn boost(self) -> BoostValue {
match self {
// Passive
Self::ProjSpeed => 20.into(),
// Charged upgrades
Self::CDamage => 20.into(),
Self::CRegen => 20.into(),
Self::CKnockback => 20.into(),
Self::CSpeed => 10.into(),
Self::CMove => 10.into(),
// Repeater upgrades
Self::RDamage => 20.into(),
Self::RCost => (-20_i16).into(),
Self::RSpeed => 20.into(),
// Shotgun upgrades
Self::SDamage => 20.into(),
Self::SCost => (-20_i16).into(),
Self::SArrows => 1.into(),
Self::SSpread => (-20_i16).into(),
// Non-descriptive values
Self::UnlockShotgun => BoostValue::NonDescriptive,
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum StaffSkill {
// Basic ranged upgrades
@ -221,6 +425,29 @@ pub enum StaffSkill {
SCost,
}
impl Boost for StaffSkill {
fn boost(self) -> BoostValue {
match self {
// Fireball upgrades
Self::BDamage => 20.into(),
Self::BRegen => 20.into(),
Self::BRadius => 15.into(),
// Flamethrower upgrades
Self::FDamage => 30.into(),
Self::FRange => 25.into(),
Self::FDrain => (-20_i16).into(),
Self::FVelocity => 25.into(),
// Shockwave upgrades
Self::SDamage => 30.into(),
Self::SKnockback => 30.into(),
Self::SRange => 20.into(),
Self::SCost => (-20_i16).into(),
// Non-descriptive values
Self::UnlockShockwave => BoostValue::NonDescriptive,
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum SceptreSkill {
// Lifesteal beam upgrades
@ -240,12 +467,52 @@ pub enum SceptreSkill {
ACost,
}
impl Boost for SceptreSkill {
fn boost(self) -> BoostValue {
match self {
// Lifesteal beam upgrades
Self::LDamage => 20.into(),
Self::LRange => 20.into(),
Self::LRegen => 20.into(),
Self::LLifesteal => 15.into(),
// Healing beam upgrades
Self::HHeal => 20.into(),
Self::HRange => 20.into(),
Self::HCost => (-20_i16).into(),
// Warding aura upgrades
Self::AStrength => 15.into(),
Self::ADuration => 20.into(),
Self::ARange => 25.into(),
Self::ACost => (-15_i16).into(),
Self::UnlockAura => BoostValue::NonDescriptive,
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum GeneralSkill {
HealthIncrease,
EnergyIncrease,
}
impl Boost for GeneralSkill {
fn boost(self) -> BoostValue {
// NOTE: These should be used only for UI.
// Source of truth are corresponding systems
match self {
Self::HealthIncrease => {
let health_increase =
(Body::Humanoid(humanoid::Body::random()).base_health_increase() / 10) as i16;
health_increase.into()
},
Self::EnergyIncrease => {
let energy_increase = (comp::energy::ENERGY_PER_LEVEL / 10) as i16;
energy_increase.into()
},
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum RollSkill {
Cost,
@ -253,17 +520,44 @@ pub enum RollSkill {
Duration,
}
impl Boost for RollSkill {
fn boost(self) -> BoostValue {
match self {
Self::Cost => (-10_i16).into(),
Self::Strength => 10.into(),
Self::Duration => 10.into(),
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum ClimbSkill {
Cost,
Speed,
}
impl Boost for ClimbSkill {
fn boost(self) -> BoostValue {
match self {
Self::Cost => (-20_i16).into(),
Self::Speed => 20.into(),
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum SwimSkill {
Speed,
}
impl Boost for SwimSkill {
fn boost(self) -> BoostValue {
match self {
Self::Speed => 40.into(),
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum MiningSkill {
Speed,
@ -271,6 +565,16 @@ pub enum MiningSkill {
GemGain,
}
impl Boost for MiningSkill {
fn boost(self) -> BoostValue {
match self {
Self::Speed => 10.into(),
Self::OreGain => 5.into(),
Self::GemGain => 5.into(),
}
}
}
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum SkillGroupKind {
General,

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

@ -1,6 +1,6 @@
use crate::{
comp::{
skills::{ClimbSkill::*, Skill},
skills::{self, ClimbSkill::*, Skill},
CharacterState, Climb, EnergySource, InputKind, Ori, StateUpdate,
},
consts::GRAVITY,
@ -31,12 +31,12 @@ pub struct Data {
impl Data {
pub fn create_adjusted_by_skills(join_data: &JoinData) -> Self {
let mut data = Data::default();
if let Ok(Some(level)) = join_data.skill_set.skill_level(Skill::Climb(Cost)) {
data.static_data.energy_cost *= 0.8_f32.powi(level.into());
}
if let Ok(Some(level)) = join_data.skill_set.skill_level(Skill::Climb(Speed)) {
data.static_data.movement_speed *= 1.2_f32.powi(level.into());
}
skills::adjust_with_level(join_data.skill_set, Skill::Climb(Cost), |m, level| {
data.static_data.energy_cost *= m.powi(level.into());
});
skills::adjust_with_level(join_data.skill_set, Skill::Climb(Speed), |m, level| {
data.static_data.movement_speed *= m.powi(level.into());
});
data
}
}

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

@ -5,7 +5,7 @@ use crate::{
inventory::slot::{EquipSlot, Slot},
item::{Hands, ItemKind, Tool, ToolKind},
quadruped_low, quadruped_medium, quadruped_small,
skills::{Skill, SwimSkill},
skills::{self, Skill, SwimSkill},
theropod, Body, CharacterAbility, CharacterState, Density, InputAttr, InputKind,
InventoryAction, StateUpdate,
},
@ -366,9 +366,9 @@ fn swim_move(data: &JoinData, update: &mut StateUpdate, efficiency: f32, submers
let force = efficiency * force;
let mut water_accel = force / data.mass.0;
if let Ok(Some(level)) = data.skill_set.skill_level(Skill::Swim(SwimSkill::Speed)) {
water_accel *= 1.4_f32.powi(level.into());
}
skills::adjust_with_level(data.skill_set, Skill::Swim(SwimSkill::Speed), |m, level| {
water_accel *= m.powi(level.into());
});
let dir = if data.body.can_strafe() {
data.inputs.move_dir

42
server/src/events/interaction.rs
View File

@ -337,28 +337,40 @@ pub fn handle_mine_block(
xp_pools: HashSet::from_iter(vec![SkillGroupKind::Weapon(tool)]),
});
}
use common::comp::skills::{MiningSkill, Skill};
use common::comp::skills::{self, MiningSkill, Skill};
use rand::Rng;
let mut rng = rand::thread_rng();
let chance_add_ore = || {
let mut chance = 0.0;
skills::adjust_with_level(
&skillset,
Skill::Pick(MiningSkill::OreGain),
|m, level| {
chance = (m - 1.0) * level as f32;
},
);
chance as f64
};
let chance_add_gem = || {
let mut chance = 0.0;
skills::adjust_with_level(
&skillset,
Skill::Pick(MiningSkill::GemGain),
|m, level| {
chance = (m - 1.0) * level as f32;
},
);
chance as f64
};
if item.item_definition_id().contains("mineral.ore.")
&& rng.gen_bool(
0.05 * skillset
.skill_level(Skill::Pick(MiningSkill::OreGain))
.ok()
.flatten()
.unwrap_or(0) as f64,
)
&& rng.gen_bool(chance_add_ore())
{
let _ = item.increase_amount(1);
}
if item.item_definition_id().contains("mineral.gem.")
&& rng.gen_bool(
0.05 * skillset
.skill_level(Skill::Pick(MiningSkill::GemGain))
.ok()
.flatten()
.unwrap_or(0) as f64,
)
&& rng.gen_bool(chance_add_gem())
{
let _ = item.increase_amount(1);
}