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

#918 remove usages of .restrict_mut() from mount.rs and stats.rs

Browse Source
This commit is contained in:
Thomas Kosel 2021-07-27 22:22:39 +02:00
parent 7a3755b7b0
commit 27f666622f
No known key found for this signature in database
GPG Key ID: AC43C6126CC42595
2 changed files with 24 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
common/systems/src/mount.rs
View File

@ -45,10 +45,9 @@ impl<'a> System<'a> for Sys {
): Self::SystemData, ): Self::SystemData,
) { ) {
// Mounted entities. // Mounted entities.
for (entity, mut mount_states, body) in for (entity, mut mount_states, body) in (&entities, &mut mount_state, bodies.maybe()).join()
(&entities, &mut mount_state.restrict_mut(), bodies.maybe()).join()
{ {
match mount_states.get_unchecked() { match *mount_states {
MountState::Unmounted => {}, MountState::Unmounted => {},
MountState::MountedBy(mounter_uid) => { MountState::MountedBy(mounter_uid) => {
// Note: currently controller events are not passed through since none of them // Note: currently controller events are not passed through since none of them
@ -82,7 +81,7 @@ impl<'a> System<'a> for Sys {
} }
} }
} else { } else {
*(mount_states.get_mut_unchecked()) = MountState::Unmounted; *mount_states = MountState::Unmounted;
} }
}, },
} }

70
common/systems/src/stats.rs
View File

@ -90,21 +90,17 @@ impl<'a> System<'a> for Sys {
&read_data.entities, &read_data.entities,
&read_data.uids, &read_data.uids,
&stats, &stats,
&mut skill_sets.restrict_mut(), &mut skill_sets,
&mut healths.restrict_mut(), &mut healths,
&read_data.positions, &read_data.positions,
&mut energies.restrict_mut(), &mut energies,
read_data.inventories.maybe(), read_data.inventories.maybe(),
) )
.join() .join()
{ {
let set_dead = { let set_dead = { health.should_die() && !health.is_dead };
let health = health.get_unchecked();
health.should_die() && !health.is_dead
};
if set_dead { if set_dead {
let mut health = health.get_mut_unchecked();
let cloned_entity = (entity, *pos); let cloned_entity = (entity, *pos);
entities_died_last_tick.0.push(cloned_entity); entities_died_last_tick.0.push(cloned_entity);
server_event_emitter.emit(ServerEvent::Destroy { server_event_emitter.emit(ServerEvent::Destroy {
@ -117,21 +113,18 @@ impl<'a> System<'a> for Sys {
let stat = stats; let stat = stats;
let update_max_hp = { let update_max_hp = {
let health = health.get_unchecked();
(stat.max_health_modifier - 1.0).abs() > f32::EPSILON (stat.max_health_modifier - 1.0).abs() > f32::EPSILON
|| health.base_max() != health.maximum() || health.base_max() != health.maximum()
}; };
if update_max_hp { if update_max_hp {
let mut health = health.get_mut_unchecked();
health.scale_maximum(stat.max_health_modifier); health.scale_maximum(stat.max_health_modifier);
} }
let (change_energy, energy_scaling) = { let (change_energy, energy_scaling) = {
let energy = energy.get_unchecked();
// Calculates energy scaling from stats and inventory // Calculates energy scaling from stats and inventory
let new_energy_scaling = let new_energy_scaling =
combat::compute_max_energy_mod(energy, inventory) + stat.max_energy_modifier; combat::compute_max_energy_mod(&energy, inventory) + stat.max_energy_modifier;
let current_energy_scaling = energy.maximum() as f32 / energy.base_max() as f32; let current_energy_scaling = energy.maximum() as f32 / energy.base_max() as f32;
// Only changes energy if new modifier different from old modifer // Only changes energy if new modifier different from old modifer
// TODO: Look into using wider threshold incase floating point imprecision makes // TODO: Look into using wider threshold incase floating point imprecision makes
@ -144,22 +137,19 @@ impl<'a> System<'a> for Sys {
// If modifier sufficiently different, mutably access energy // If modifier sufficiently different, mutably access energy
if change_energy { if change_energy {
let mut energy = energy.get_mut_unchecked();
energy.scale_maximum(energy_scaling); energy.scale_maximum(energy_scaling);
} }
let skillset = skill_set.get_unchecked(); let skills_to_level = skill_set
let skills_to_level = skillset
.skill_groups .skill_groups
.iter() .iter()
.filter_map(|s_g| { .filter_map(|s_g| {
(s_g.exp >= skillset.skill_point_cost(s_g.skill_group_kind)) (s_g.exp >= skill_set.skill_point_cost(s_g.skill_group_kind))
.then(|| s_g.skill_group_kind) .then(|| s_g.skill_group_kind)
}) })
.collect::<HashSet<_>>(); .collect::<HashSet<_>>();
if !skills_to_level.is_empty() { if !skills_to_level.is_empty() {
let mut skill_set = skill_set.get_mut_unchecked();
for skill_group in skills_to_level { for skill_group in skills_to_level {
skill_set.earn_skill_point(skill_group); skill_set.earn_skill_point(skill_group);
outcomes.push(Outcome::SkillPointGain { outcomes.push(Outcome::SkillPointGain {
@ -174,44 +164,34 @@ impl<'a> System<'a> for Sys {
// Apply effects from leveling skills // Apply effects from leveling skills
for (mut skill_set, mut health, mut energy, body) in ( for (mut skill_set, mut health, mut energy, body) in (
&mut skill_sets.restrict_mut(), &mut skill_sets,
&mut healths.restrict_mut(), &mut healths,
&mut energies.restrict_mut(), &mut energies,
&read_data.bodies, &read_data.bodies,
) )
.join() .join()
{ {
let skillset = skill_set.get_unchecked(); if skill_set.modify_health {
if skillset.modify_health { let health_level = skill_set
let mut health = health.get_mut_unchecked();
let health_level = skillset
.skill_level(Skill::General(GeneralSkill::HealthIncrease)) .skill_level(Skill::General(GeneralSkill::HealthIncrease))
.unwrap_or(None) .unwrap_or(None)
.unwrap_or(0); .unwrap_or(0);
health.update_max_hp(Some(*body), health_level); health.update_max_hp(Some(*body), health_level);
let mut skillset = skill_set.get_mut_unchecked(); skill_set.modify_health = false;
skillset.modify_health = false;
} }
let skillset = skill_set.get_unchecked(); if skill_set.modify_energy {
if skillset.modify_energy { let energy_level = skill_set
let mut energy = energy.get_mut_unchecked();
let energy_level = skillset
.skill_level(Skill::General(GeneralSkill::EnergyIncrease)) .skill_level(Skill::General(GeneralSkill::EnergyIncrease))
.unwrap_or(None) .unwrap_or(None)
.unwrap_or(0); .unwrap_or(0);
energy.update_max_energy(Some(*body), energy_level); energy.update_max_energy(Some(*body), energy_level);
let mut skill_set = skill_set.get_mut_unchecked();
skill_set.modify_energy = false; skill_set.modify_energy = false;
} }
} }
// Update energies and poises // Update energies and poises
for (character_state, mut energy, mut poise) in ( for (character_state, mut energy, mut poise) in
&read_data.char_states, (&read_data.char_states, &mut energies, &mut poises).join()
&mut energies.restrict_mut(),
&mut poises.restrict_mut(),
)
.join()
{ {
match character_state { match character_state {
// Accelerate recharging energy. // Accelerate recharging energy.
@ -225,13 +205,9 @@ impl<'a> System<'a> for Sys {
| CharacterState::Wielding { .. } | CharacterState::Wielding { .. }
| CharacterState::Equipping { .. } | CharacterState::Equipping { .. }
| CharacterState::Boost { .. } => { | CharacterState::Boost { .. } => {
let res = { let res = { energy.current() < energy.maximum() };
let energy = energy.get_unchecked();
energy.current() < energy.maximum()
};
if res { if res {
let mut energy = energy.get_mut_unchecked();
let energy = &mut *energy; let energy = &mut *energy;
// Have to account for Calc I differential equations due to acceleration // Have to account for Calc I differential equations due to acceleration
energy.change_by(EnergyChange { energy.change_by(EnergyChange {
@ -243,13 +219,9 @@ impl<'a> System<'a> for Sys {
(energy.regen_rate + ENERGY_REGEN_ACCEL * dt).min(100.0); (energy.regen_rate + ENERGY_REGEN_ACCEL * dt).min(100.0);
} }
let res_poise = { let res_poise = { poise.current() < poise.maximum() };
let poise = poise.get_unchecked();
poise.current() < poise.maximum()
};
if res_poise { if res_poise {
let mut poise = poise.get_mut_unchecked();
let poise = &mut *poise; let poise = &mut *poise;
poise.change_by( poise.change_by(
PoiseChange { PoiseChange {
@ -280,8 +252,8 @@ impl<'a> System<'a> for Sys {
| CharacterState::BasicSummon { .. } | CharacterState::BasicSummon { .. }
| CharacterState::SelfBuff { .. } | CharacterState::SelfBuff { .. }
| CharacterState::SpriteSummon { .. } => { | CharacterState::SpriteSummon { .. } => {
if energy.get_unchecked().regen_rate != 0.0 { if energy.regen_rate != 0.0 {
energy.get_mut_unchecked().regen_rate = 0.0 energy.regen_rate = 0.0
} }
}, },
// Abilities that temporarily stall energy gain, but preserve regen_rate. // Abilities that temporarily stall energy gain, but preserve regen_rate.