diff --git a/common/sys/src/melee.rs b/common/sys/src/melee.rs index d008677a60..81d147512c 100644 --- a/common/sys/src/melee.rs +++ b/common/sys/src/melee.rs @@ -1,97 +1,69 @@ use common::{ combat::AttackerInfo, - comp::{group, Body, CharacterState, Energy, Health, Inventory, Melee, Ori, Pos, Scale}, - event::{EventBus, LocalEvent, ServerEvent}, + comp::{Body, CharacterState, Energy, Group, Health, Inventory, Melee, Ori, Pos, Scale}, + event::{EventBus, ServerEvent}, metrics::SysMetrics, span, uid::Uid, util::Dir, GroupTarget, }; -use specs::{Entities, Join, Read, ReadExpect, ReadStorage, System, WriteStorage}; +use specs::{ + shred::ResourceId, Entities, Join, Read, ReadExpect, ReadStorage, System, SystemData, World, + WriteStorage, +}; use vek::*; +#[derive(SystemData)] +pub struct ImmutableData<'a> { + entities: Entities<'a>, + uids: ReadStorage<'a, Uid>, + positions: ReadStorage<'a, Pos>, + orientations: ReadStorage<'a, Ori>, + scales: ReadStorage<'a, Scale>, + bodies: ReadStorage<'a, Body>, + healths: ReadStorage<'a, Health>, + energies: ReadStorage<'a, Energy>, + inventories: ReadStorage<'a, Inventory>, + groups: ReadStorage<'a, Group>, + char_states: ReadStorage<'a, CharacterState>, + server_bus: Read<'a, EventBus>, + metrics: ReadExpect<'a, SysMetrics>, +} + /// This system is responsible for handling accepted inputs like moving or /// attacking pub struct Sys; -impl<'a> System<'a> for Sys { - #[allow(clippy::type_complexity)] - type SystemData = ( - Entities<'a>, - Read<'a, EventBus>, - Read<'a, EventBus>, - ReadExpect<'a, SysMetrics>, - ReadStorage<'a, Uid>, - ReadStorage<'a, Pos>, - ReadStorage<'a, Ori>, - ReadStorage<'a, Scale>, - ReadStorage<'a, Body>, - ReadStorage<'a, Health>, - ReadStorage<'a, Energy>, - ReadStorage<'a, Inventory>, - ReadStorage<'a, group::Group>, - WriteStorage<'a, Melee>, - ReadStorage<'a, CharacterState>, - ); - fn run( - &mut self, - ( - entities, - server_bus, - local_bus, - sys_metrics, - uids, - positions, - orientations, - scales, - bodies, - healths, - energies, - inventories, - groups, - mut attacking_storage, - char_states, - ): Self::SystemData, - ) { +impl<'a> System<'a> for Sys { + type SystemData = (ImmutableData<'a>, WriteStorage<'a, Melee>); + + fn run(&mut self, (immutable_data, mut melee_attacks): Self::SystemData) { let start_time = std::time::Instant::now(); span!(_guard, "run", "melee::Sys::run"); - let mut server_emitter = server_bus.emitter(); - let _local_emitter = local_bus.emitter(); + let mut server_emitter = immutable_data.server_bus.emitter(); // Attacks - for (entity, uid, pos, ori, scale_maybe, attack, body) in ( - &entities, - &uids, - &positions, - &orientations, - scales.maybe(), - &mut attacking_storage, - &bodies, + for (attacker, uid, pos, ori, melee_attack, body) in ( + &immutable_data.entities, + &immutable_data.uids, + &immutable_data.positions, + &immutable_data.orientations, + &mut melee_attacks, + &immutable_data.bodies, ) .join() { - if attack.applied { + if melee_attack.applied { continue; } - attack.applied = true; + melee_attack.applied = true; // Go through all other entities - for ( - b, - pos_b, - scale_b_maybe, - health_b, - body_b, - char_state_b_maybe, - inventory_b_maybe, - ) in ( - &entities, - &positions, - scales.maybe(), - &healths, - &bodies, - char_states.maybe(), - inventories.maybe(), + for (target, pos_b, health_b, body_b) in ( + &immutable_data.entities, + &immutable_data.positions, + &immutable_data.healths, + &immutable_data.bodies, ) .join() { @@ -103,25 +75,29 @@ impl<'a> System<'a> for Sys { let ori2 = Vec2::from(look_dir); // Scales - let scale = scale_maybe.map_or(1.0, |s| s.0); - let scale_b = scale_b_maybe.map_or(1.0, |s| s.0); + let scale = immutable_data.scales.get(attacker).map_or(1.0, |s| s.0); + let scale_b = immutable_data.scales.get(target).map_or(1.0, |s| s.0); let rad = body.radius() * scale; let rad_b = body_b.radius() * scale_b; // Check if entity is dodging - let is_dodge = char_state_b_maybe.map_or(false, |c_s| c_s.is_melee_dodge()); + let is_dodge = immutable_data + .char_states + .get(target) + .map_or(false, |c_s| c_s.is_melee_dodge()); // Check if it is a hit - if entity != b + if attacker != target && !health_b.is_dead // Spherical wedge shaped attack field - && pos.0.distance_squared(pos_b.0) < (rad + rad_b + scale * attack.range).powi(2) - && ori2.angle_between(pos_b2 - pos2) < attack.max_angle + (rad_b / pos2.distance(pos_b2)).atan() + && pos.0.distance_squared(pos_b.0) < (rad + rad_b + scale * melee_attack.range).powi(2) + && ori2.angle_between(pos_b2 - pos2) < melee_attack.max_angle + (rad_b / pos2.distance(pos_b2)).atan() { // See if entities are in the same group - let same_group = groups - .get(entity) - .map(|group_a| Some(group_a) == groups.get(b)) + let same_group = immutable_data + .groups + .get(attacker) + .map(|group_a| Some(group_a) == immutable_data.groups.get(target)) .unwrap_or(false); let target_group = if same_group { @@ -133,27 +109,27 @@ impl<'a> System<'a> for Sys { let dir = Dir::new((pos_b.0 - pos.0).try_normalized().unwrap_or(look_dir)); let attacker_info = Some(AttackerInfo { - entity, + entity: attacker, uid: *uid, - energy: energies.get(entity), + energy: immutable_data.energies.get(attacker), }); - attack.attack.apply_attack( + melee_attack.attack.apply_attack( target_group, attacker_info, - b, - inventory_b_maybe, + target, + immutable_data.inventories.get(target), dir, is_dodge, 1.0, |e| server_emitter.emit(e), ); - attack.hit_count += 1; + melee_attack.hit_count += 1; } } } - sys_metrics.melee_ns.store( + immutable_data.metrics.melee_ns.store( start_time.elapsed().as_nanos() as u64, std::sync::atomic::Ordering::Relaxed, );