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

Changed naming from 'immutable data' to 'read data'

Browse Source
This commit is contained in:
Sam 2021-02-22 16:02:37 -05:00
parent 2b5120319d
commit 3f467a32e6
9 changed files with 145 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
common/sys/src/aura.rs
View File

@ -16,7 +16,7 @@ use specs::{
use std::time::Duration;
#[derive(SystemData)]
pub struct ImmutableData<'a> {
pub struct ReadData<'a> {
entities: Entities<'a>,
dt: Read<'a, DeltaTime>,
server_bus: Read<'a, EventBus<ServerEvent>>,
@ -30,21 +30,17 @@ pub struct ImmutableData<'a> {
pub struct Sys;
impl<'a> System<'a> for Sys {
type SystemData = (ImmutableData<'a>, WriteStorage<'a, Auras>);
type SystemData = (ReadData<'a>, WriteStorage<'a, Auras>);
fn run(&mut self, (immutable_data, mut auras): Self::SystemData) {
let mut server_emitter = immutable_data.server_bus.emitter();
let dt = immutable_data.dt.0;
fn run(&mut self, (read_data, mut auras): Self::SystemData) {
let mut server_emitter = read_data.server_bus.emitter();
let dt = read_data.dt.0;
auras.set_event_emission(false);
// Iterate through all entities with an aura
for (entity, pos, mut auras_comp) in (
&immutable_data.entities,
&immutable_data.positions,
&mut auras,
)
.join()
for (entity, pos, mut auras_comp) in
(&read_data.entities, &read_data.positions, &mut auras).join()
{
let mut expired_auras = Vec::<AuraKey>::new();
// Iterate through the auras attached to this entity
@ -61,22 +57,22 @@ impl<'a> System<'a> for Sys {
}
}
for (target, target_pos, target_buffs, health) in (
&immutable_data.entities,
&immutable_data.positions,
&immutable_data.buffs,
&immutable_data.healths,
&read_data.entities,
&read_data.positions,
&read_data.buffs,
&read_data.healths,
)
.join()
{
// Ensure entity is within the aura radius
if target_pos.0.distance_squared(pos.0) < aura.radius.powi(2) {
if let AuraTarget::GroupOf(uid) = aura.target {
let same_group = immutable_data
let same_group = read_data
.uid_allocator
.retrieve_entity_internal(uid.into())
.and_then(|e| immutable_data.groups.get(e))
.and_then(|e| read_data.groups.get(e))
.map_or(false, |owner_group| {
Some(owner_group) == immutable_data.groups.get(target)
Some(owner_group) == read_data.groups.get(target)
});
if !same_group {
@ -103,7 +99,7 @@ impl<'a> System<'a> for Sys {
let apply_buff = match kind {
BuffKind::CampfireHeal => {
matches!(
immutable_data.char_states.get(target),
read_data.char_states.get(target),
Some(CharacterState::Sit)
) && health.current() < health.maximum()
},

48
common/sys/src/beam.rs
View File

@ -17,7 +17,7 @@ use std::time::Duration;
use vek::*;
#[derive(SystemData)]
pub struct ImmutableData<'a> {
pub struct ReadData<'a> {
entities: Entities<'a>,
server_bus: Read<'a, EventBus<ServerEvent>>,
time: Read<'a, Time>,
@ -39,22 +39,22 @@ pub struct ImmutableData<'a> {
pub struct Sys;
impl<'a> System<'a> for Sys {
type SystemData = (
ImmutableData<'a>,
ReadData<'a>,
WriteStorage<'a, BeamSegment>,
WriteStorage<'a, Beam>,
);
fn run(&mut self, (immutable_data, mut beam_segments, mut beams): Self::SystemData) {
let mut server_emitter = immutable_data.server_bus.emitter();
fn run(&mut self, (read_data, mut beam_segments, mut beams): Self::SystemData) {
let mut server_emitter = read_data.server_bus.emitter();
let time = immutable_data.time.0;
let dt = immutable_data.dt.0;
let time = read_data.time.0;
let dt = read_data.dt.0;
// Beams
for (entity, pos, ori, beam_segment) in (
&immutable_data.entities,
&immutable_data.positions,
&immutable_data.orientations,
&read_data.entities,
&read_data.positions,
&read_data.orientations,
&beam_segments,
)
.join()
@ -89,15 +89,13 @@ impl<'a> System<'a> for Sys {
(beam_segment.speed * (time_since_creation - frame_time)).max(0.0);
let frame_end_dist = (beam_segment.speed * time_since_creation).max(frame_start_dist);
let beam_owner = beam_segment.owner.and_then(|uid| {
immutable_data
.uid_allocator
.retrieve_entity_internal(uid.into())
});
let beam_owner = beam_segment
.owner
.and_then(|uid| read_data.uid_allocator.retrieve_entity_internal(uid.into()));
// Group to ignore collisions with
// Might make this more nuanced if beams are used for non damage effects
let group = beam_owner.and_then(|e| immutable_data.groups.get(e));
let group = beam_owner.and_then(|e| read_data.groups.get(e));
let hit_entities = if let Some(beam) = beam_owner.and_then(|e| beams.get_mut(e)) {
&mut beam.hit_entities
@ -107,11 +105,11 @@ impl<'a> System<'a> for Sys {
// Go through all other effectable entities
for (target, uid_b, pos_b, health_b, body_b) in (
&immutable_data.entities,
&immutable_data.uids,
&immutable_data.positions,
&immutable_data.healths,
&immutable_data.bodies,
&read_data.entities,
&read_data.uids,
&read_data.positions,
&read_data.healths,
&read_data.bodies,
)
.join()
{
@ -121,8 +119,8 @@ impl<'a> System<'a> for Sys {
}
// Scales
let scale_b = immutable_data.scales.get(target).map_or(1.0, |s| s.0);
let last_pos_b_maybe = immutable_data.last_positions.get(target);
let scale_b = read_data.scales.get(target).map_or(1.0, |s| s.0);
let last_pos_b_maybe = read_data.last_positions.get(target);
let rad_b = body_b.radius() * scale_b;
let height_b = body_b.height() * scale_b;
@ -136,7 +134,7 @@ impl<'a> System<'a> for Sys {
if hit {
// See if entities are in the same group
let same_group = group
.map(|group_a| Some(group_a) == immutable_data.groups.get(target))
.map(|group_a| Some(group_a) == read_data.groups.get(target))
.unwrap_or(Some(*uid_b) == beam_segment.owner);
let target_group = if same_group {
@ -156,14 +154,14 @@ impl<'a> System<'a> for Sys {
.map(|(entity, uid)| AttackerInfo {
entity,
uid,
energy: immutable_data.energies.get(entity),
energy: read_data.energies.get(entity),
});
beam_segment.properties.attack.apply_attack(
target_group,
attacker_info,
target,
immutable_data.inventories.get(target),
read_data.inventories.get(target),
ori.look_dir(),
false,
1.0,

21
common/sys/src/buff.rs
View File

@ -13,7 +13,7 @@ use specs::{
use std::time::Duration;
#[derive(SystemData)]
pub struct ImmutableData<'a> {
pub struct ReadData<'a> {
entities: Entities<'a>,
dt: Read<'a, DeltaTime>,
server_bus: Read<'a, EventBus<ServerEvent>>,
@ -23,26 +23,21 @@ pub struct ImmutableData<'a> {
pub struct Sys;
impl<'a> System<'a> for Sys {
type SystemData = (
ImmutableData<'a>,
ReadData<'a>,
WriteStorage<'a, Health>,
WriteStorage<'a, Energy>,
WriteStorage<'a, Buffs>,
);
fn run(&mut self, (immutable_data, mut healths, mut energies, mut buffs): Self::SystemData) {
let mut server_emitter = immutable_data.server_bus.emitter();
let dt = immutable_data.dt.0;
fn run(&mut self, (read_data, mut healths, mut energies, mut buffs): Self::SystemData) {
let mut server_emitter = read_data.server_bus.emitter();
let dt = read_data.dt.0;
// Set to false to avoid spamming server
buffs.set_event_emission(false);
healths.set_event_emission(false);
energies.set_event_emission(false);
for (entity, mut buff_comp, mut health, mut energy) in (
&immutable_data.entities,
&mut buffs,
&mut healths,
&mut energies,
)
.join()
for (entity, mut buff_comp, mut health, mut energy) in
(&read_data.entities, &mut buffs, &mut healths, &mut energies).join()
{
let (buff_comp_kinds, buff_comp_buffs) = buff_comp.parts();
let mut expired_buffs = Vec::<BuffId>::new();
@ -66,7 +61,7 @@ impl<'a> System<'a> for Sys {
}
}
if let Some(inventory) = immutable_data.inventories.get(entity) {
if let Some(inventory) = read_data.inventories.get(entity) {
let damage_reduction = Damage::compute_damage_reduction(inventory);
if (damage_reduction - 1.0).abs() < f32::EPSILON {
for (id, buff) in buff_comp.buffs.iter() {

42
common/sys/src/character_behavior.rs
View File

@ -47,7 +47,7 @@ fn incorporate_update(join: &mut JoinStruct, state_update: StateUpdate) {
}
#[derive(SystemData)]
pub struct ImmutableData<'a> {
pub struct ReadData<'a> {
entities: Entities<'a>,
server_bus: Read<'a, EventBus<ServerEvent>>,
local_bus: Read<'a, EventBus<LocalEvent>>,
@ -72,7 +72,7 @@ pub struct Sys;
impl<'a> System<'a> for Sys {
#[allow(clippy::type_complexity)]
type SystemData = (
ImmutableData<'a>,
ReadData<'a>,
WriteStorage<'a, CharacterState>,
WriteStorage<'a, Pos>,
WriteStorage<'a, Vel>,
@ -87,7 +87,7 @@ impl<'a> System<'a> for Sys {
fn run(
&mut self,
(
immutable_data,
read_data,
mut character_states,
mut positions,
mut velocities,
@ -100,8 +100,8 @@ impl<'a> System<'a> for Sys {
) {
let start_time = std::time::Instant::now();
span!(_guard, "run", "character_behavior::Sys::run");
let mut server_emitter = immutable_data.server_bus.emitter();
let mut local_emitter = immutable_data.local_bus.emitter();
let mut server_emitter = read_data.server_bus.emitter();
let mut local_emitter = read_data.local_bus.emitter();
for (
entity,
@ -118,8 +118,8 @@ impl<'a> System<'a> for Sys {
physics,
stat,
) in (
&immutable_data.entities,
&immutable_data.uids,
&read_data.entities,
&read_data.uids,
&mut character_states.restrict_mut(),
&mut positions,
&mut velocities,
@ -127,10 +127,10 @@ impl<'a> System<'a> for Sys {
&mut energies.restrict_mut(),
&mut inventories.restrict_mut(),
&mut controllers,
&immutable_data.healths,
&immutable_data.bodies,
&immutable_data.physics_states,
&immutable_data.stats,
&read_data.healths,
&read_data.bodies,
&read_data.physics_states,
&read_data.stats,
)
.join()
{
@ -141,7 +141,7 @@ impl<'a> System<'a> for Sys {
}
// If mounted, character state is controlled by mount
// TODO: Make mounting a state
if let Some(Mounting(_)) = immutable_data.mountings.get(entity) {
if let Some(Mounting(_)) = read_data.mountings.get(entity) {
let sit_state = CharacterState::Sit {};
if char_state.get_unchecked() != &sit_state {
*char_state.get_mut_unchecked() = sit_state;
@ -246,17 +246,13 @@ impl<'a> System<'a> for Sys {
health: &health,
body: &body,
physics: &physics,
melee_attack: immutable_data.melee_attacks.get(entity),
beam: immutable_data.beams.get(entity),
melee_attack: read_data.melee_attacks.get(entity),
beam: read_data.beams.get(entity),
stat: &stat,
};
for action in actions {
let j = JoinData::new(
&join_struct,
&immutable_data.lazy_update,
&immutable_data.dt,
);
let j = JoinData::new(&join_struct, &read_data.lazy_update, &read_data.dt);
let mut state_update = match j.character {
CharacterState::Idle => states::idle::Data.handle_event(&j, action),
CharacterState::Talk => states::talk::Data.handle_event(&j, action),
@ -299,11 +295,7 @@ impl<'a> System<'a> for Sys {
incorporate_update(&mut join_struct, state_update);
}
let j = JoinData::new(
&join_struct,
&immutable_data.lazy_update,
&immutable_data.dt,
);
let j = JoinData::new(&join_struct, &read_data.lazy_update, &read_data.dt);
let mut state_update = match j.character {
CharacterState::Idle => states::idle::Data.behavior(&j),
@ -337,7 +329,7 @@ impl<'a> System<'a> for Sys {
server_emitter.append(&mut state_update.server_events);
incorporate_update(&mut join_struct, state_update);
}
immutable_data.metrics.character_behavior_ns.store(
read_data.metrics.character_behavior_ns.store(
start_time.elapsed().as_nanos() as u64,
std::sync::atomic::Ordering::Relaxed,
);

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

@ -13,7 +13,7 @@ use specs::{
use vek::*;
#[derive(SystemData)]
pub struct ImmutableData<'a> {
pub struct ReadData<'a> {
entities: Entities<'a>,
uid_allocator: Read<'a, UidAllocator>,
server_bus: Read<'a, EventBus<ServerEvent>>,
@ -23,14 +23,14 @@ pub struct ImmutableData<'a> {
pub struct Sys;
impl<'a> System<'a> for Sys {
type SystemData = (ImmutableData<'a>, WriteStorage<'a, Controller>);
type SystemData = (ReadData<'a>, WriteStorage<'a, Controller>);
fn run(&mut self, (immutable_data, mut controllers): Self::SystemData) {
fn run(&mut self, (read_data, mut controllers): Self::SystemData) {
let start_time = std::time::Instant::now();
span!(_guard, "run", "controller::Sys::run");
let mut server_emitter = immutable_data.server_bus.emitter();
let mut server_emitter = read_data.server_bus.emitter();
for (entity, controller) in (&immutable_data.entities, &mut controllers).join() {
for (entity, controller) in (&read_data.entities, &mut controllers).join() {
let mut inputs = &mut controller.inputs;
// Note(imbris): I avoided incrementing the duration with inputs.tick() because
@ -55,7 +55,7 @@ impl<'a> System<'a> for Sys {
for event in controller.events.drain(..) {
match event {
ControlEvent::Mount(mountee_uid) => {
if let Some(mountee_entity) = immutable_data
if let Some(mountee_entity) = read_data
.uid_allocator
.retrieve_entity_internal(mountee_uid.id())
{
@ -76,7 +76,7 @@ impl<'a> System<'a> for Sys {
server_emitter.emit(ServerEvent::DisableLantern(entity))
},
ControlEvent::Interact(npc_uid) => {
if let Some(npc_entity) = immutable_data
if let Some(npc_entity) = read_data
.uid_allocator
.retrieve_entity_internal(npc_uid.id())
{
@ -103,7 +103,7 @@ impl<'a> System<'a> for Sys {
}
}
}
immutable_data.metrics.controller_ns.store(
read_data.metrics.controller_ns.store(
start_time.elapsed().as_nanos() as u64,
std::sync::atomic::Ordering::Relaxed,
);

42
common/sys/src/melee.rs
View File

@ -15,7 +15,7 @@ use specs::{
use vek::*;
#[derive(SystemData)]
pub struct ImmutableData<'a> {
pub struct ReadData<'a> {
entities: Entities<'a>,
uids: ReadStorage<'a, Uid>,
positions: ReadStorage<'a, Pos>,
@ -36,20 +36,20 @@ pub struct ImmutableData<'a> {
pub struct Sys;
impl<'a> System<'a> for Sys {
type SystemData = (ImmutableData<'a>, WriteStorage<'a, Melee>);
type SystemData = (ReadData<'a>, WriteStorage<'a, Melee>);
fn run(&mut self, (immutable_data, mut melee_attacks): Self::SystemData) {
fn run(&mut self, (read_data, mut melee_attacks): Self::SystemData) {
let start_time = std::time::Instant::now();
span!(_guard, "run", "melee::Sys::run");
let mut server_emitter = immutable_data.server_bus.emitter();
let mut server_emitter = read_data.server_bus.emitter();
// Attacks
for (attacker, uid, pos, ori, melee_attack, body) in (
&immutable_data.entities,
&immutable_data.uids,
&immutable_data.positions,
&immutable_data.orientations,
&read_data.entities,
&read_data.uids,
&read_data.positions,
&read_data.orientations,
&mut melee_attacks,
&immutable_data.bodies,
&read_data.bodies,
)
.join()
{
@ -60,10 +60,10 @@ impl<'a> System<'a> for Sys {
// Go through all other entities
for (target, pos_b, health_b, body_b) in (
&immutable_data.entities,
&immutable_data.positions,
&immutable_data.healths,
&immutable_data.bodies,
&read_data.entities,
&read_data.positions,
&read_data.healths,
&read_data.bodies,
)
.join()
{
@ -75,13 +75,13 @@ impl<'a> System<'a> for Sys {
let ori2 = Vec2::from(look_dir);
// Scales
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 scale = read_data.scales.get(attacker).map_or(1.0, |s| s.0);
let scale_b = read_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 = immutable_data
let is_dodge = read_data
.char_states
.get(target)
.map_or(false, |c_s| c_s.is_melee_dodge());
@ -94,10 +94,10 @@ impl<'a> System<'a> for Sys {
&& 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 = immutable_data
let same_group = read_data
.groups
.get(attacker)
.map(|group_a| Some(group_a) == immutable_data.groups.get(target))
.map(|group_a| Some(group_a) == read_data.groups.get(target))
.unwrap_or(false);
let target_group = if same_group {
@ -111,14 +111,14 @@ impl<'a> System<'a> for Sys {
let attacker_info = Some(AttackerInfo {
entity: attacker,
uid: *uid,
energy: immutable_data.energies.get(attacker),
energy: read_data.energies.get(attacker),
});
melee_attack.attack.apply_attack(
target_group,
attacker_info,
target,
immutable_data.inventories.get(target),
read_data.inventories.get(target),
dir,
is_dodge,
1.0,
@ -129,7 +129,7 @@ impl<'a> System<'a> for Sys {
}
}
}
immutable_data.metrics.melee_ns.store(
read_data.metrics.melee_ns.store(
start_time.elapsed().as_nanos() as u64,
std::sync::atomic::Ordering::Relaxed,
);

38
common/sys/src/projectile.rs
View File

@ -18,7 +18,7 @@ use specs::{
use std::time::Duration;
#[derive(SystemData)]
pub struct ImmutableData<'a> {
pub struct ReadData<'a> {
entities: Entities<'a>,
dt: Read<'a, DeltaTime>,
uid_allocator: Read<'a, UidAllocator>,
@ -36,21 +36,21 @@ pub struct ImmutableData<'a> {
pub struct Sys;
impl<'a> System<'a> for Sys {
type SystemData = (
ImmutableData<'a>,
ReadData<'a>,
WriteStorage<'a, Ori>,
WriteStorage<'a, Projectile>,
);
fn run(&mut self, (immutable_data, mut orientations, mut projectiles): Self::SystemData) {
fn run(&mut self, (read_data, mut orientations, mut projectiles): Self::SystemData) {
let start_time = std::time::Instant::now();
span!(_guard, "run", "projectile::Sys::run");
let mut server_emitter = immutable_data.server_bus.emitter();
let mut server_emitter = read_data.server_bus.emitter();
// Attacks
'projectile_loop: for (entity, pos, physics, ori, mut projectile) in (
&immutable_data.entities,
&immutable_data.positions,
&immutable_data.physics_states,
&read_data.entities,
&read_data.positions,
&read_data.physics_states,
&mut orientations,
&mut projectiles,
)
@ -64,12 +64,12 @@ impl<'a> System<'a> for Sys {
// Note: somewhat inefficient since we do the lookup for every touching
// entity, but if we pull this out of the loop we would want to do it only
// if there is at least one touching entity
.and_then(|uid| immutable_data.uid_allocator.retrieve_entity_internal(uid.into()))
.and_then(|e| immutable_data.groups.get(e))
.and_then(|uid| read_data.uid_allocator.retrieve_entity_internal(uid.into()))
.and_then(|e| read_data.groups.get(e))
.map_or(false, |owner_group|
Some(owner_group) == immutable_data.uid_allocator
Some(owner_group) == read_data.uid_allocator
.retrieve_entity_internal(other.into())
.and_then(|e| immutable_data.groups.get(e))
.and_then(|e| read_data.groups.get(e))
);
let target_group = if same_group {
@ -93,14 +93,12 @@ impl<'a> System<'a> for Sys {
for effect in projectile.hit_entity.drain(..) {
match effect {
projectile::Effect::Attack(attack) => {
if let Some(target_entity) = immutable_data
if let Some(target_entity) = read_data
.uid_allocator
.retrieve_entity_internal(other.into())
{
let owner_entity = projectile.owner.and_then(|u| {
immutable_data
.uid_allocator
.retrieve_entity_internal(u.into())
read_data.uid_allocator.retrieve_entity_internal(u.into())
});
let attacker_info =
@ -108,7 +106,7 @@ impl<'a> System<'a> for Sys {
AttackerInfo {
entity,
uid,
energy: immutable_data.energies.get(entity),
energy: read_data.energies.get(entity),
}
});
@ -116,7 +114,7 @@ impl<'a> System<'a> for Sys {
target_group,
attacker_info,
target_entity,
immutable_data.inventories.get(target_entity),
read_data.inventories.get(target_entity),
ori.look_dir(),
false,
1.0,
@ -182,7 +180,7 @@ impl<'a> System<'a> for Sys {
if projectile_vanished {
continue 'projectile_loop;
}
} else if let Some(dir) = immutable_data
} else if let Some(dir) = read_data
.velocities
.get(entity)
.and_then(|vel| Dir::from_unnormalized(vel.0))
@ -198,10 +196,10 @@ impl<'a> System<'a> for Sys {
}
projectile.time_left = projectile
.time_left
.checked_sub(Duration::from_secs_f32(immutable_data.dt.0))
.checked_sub(Duration::from_secs_f32(read_data.dt.0))
.unwrap_or_default();
}
immutable_data.metrics.projectile_ns.store(
read_data.metrics.projectile_ns.store(
start_time.elapsed().as_nanos() as u64,
std::sync::atomic::Ordering::Relaxed,
);

53
common/sys/src/shockwave.rs
View File

@ -17,7 +17,7 @@ use specs::{
use vek::*;
#[derive(SystemData)]
pub struct ImmutableData<'a> {
pub struct ReadData<'a> {
entities: Entities<'a>,
server_bus: Read<'a, EventBus<ServerEvent>>,
time: Read<'a, Time>,
@ -41,22 +41,22 @@ pub struct ImmutableData<'a> {
pub struct Sys;
impl<'a> System<'a> for Sys {
type SystemData = (
ImmutableData<'a>,
ReadData<'a>,
WriteStorage<'a, Shockwave>,
WriteStorage<'a, ShockwaveHitEntities>,
);
fn run(&mut self, (immutable_data, mut shockwaves, mut shockwave_hit_lists): Self::SystemData) {
let mut server_emitter = immutable_data.server_bus.emitter();
fn run(&mut self, (read_data, mut shockwaves, mut shockwave_hit_lists): Self::SystemData) {
let mut server_emitter = read_data.server_bus.emitter();
let time = immutable_data.time.0;
let dt = immutable_data.dt.0;
let time = read_data.time.0;
let dt = read_data.dt.0;
// Shockwaves
for (entity, pos, ori, shockwave, shockwave_hit_list) in (
&immutable_data.entities,
&immutable_data.positions,
&immutable_data.orientations,
&read_data.entities,
&read_data.positions,
&read_data.orientations,
&shockwaves,
&mut shockwave_hit_lists,
)
@ -99,24 +99,22 @@ impl<'a> System<'a> for Sys {
end: frame_end_dist,
};
let shockwave_owner = shockwave.owner.and_then(|uid| {
immutable_data
.uid_allocator
.retrieve_entity_internal(uid.into())
});
let shockwave_owner = shockwave
.owner
.and_then(|uid| read_data.uid_allocator.retrieve_entity_internal(uid.into()));
// Group to ignore collisions with
// Might make this more nuanced if shockwaves are used for non damage effects
let group = shockwave_owner.and_then(|e| immutable_data.groups.get(e));
let group = shockwave_owner.and_then(|e| read_data.groups.get(e));
// Go through all other effectable entities
for (target, uid_b, pos_b, health_b, body_b, physics_state_b) in (
&immutable_data.entities,
&immutable_data.uids,
&immutable_data.positions,
&immutable_data.healths,
&immutable_data.bodies,
&immutable_data.physics_states,
&read_data.entities,
&read_data.uids,
&read_data.positions,
&read_data.healths,
&read_data.bodies,
&read_data.physics_states,
)
.join()
{
@ -131,13 +129,10 @@ impl<'a> System<'a> for Sys {
// 2D versions
let pos_b2 = pos_b.0.xy();
let last_pos_b2_maybe = immutable_data
.last_positions
.get(target)
.map(|p| (p.0).0.xy());
let last_pos_b2_maybe = read_data.last_positions.get(target).map(|p| (p.0).0.xy());
// Scales
let scale_b = immutable_data.scales.get(target).map_or(1.0, |s| s.0);
let scale_b = read_data.scales.get(target).map_or(1.0, |s| s.0);
let rad_b = body_b.radius() * scale_b;
// Angle checks
@ -146,7 +141,7 @@ impl<'a> System<'a> for Sys {
// See if entities are in the same group
let same_group = group
.map(|group_a| Some(group_a) == immutable_data.groups.get(target))
.map(|group_a| Some(group_a) == read_data.groups.get(target))
.unwrap_or(Some(*uid_b) == shockwave.owner);
let target_group = if same_group {
@ -178,14 +173,14 @@ impl<'a> System<'a> for Sys {
.map(|(entity, uid)| AttackerInfo {
entity,
uid,
energy: immutable_data.energies.get(entity),
energy: read_data.energies.get(entity),
});
shockwave.properties.attack.apply_attack(
target_group,
attacker_info,
target,
immutable_data.inventories.get(target),
read_data.inventories.get(target),
dir,
false,
1.0,

22
common/sys/src/stats.rs
View File

@ -22,7 +22,7 @@ const ENERGY_REGEN_ACCEL: f32 = 10.0;
const POISE_REGEN_ACCEL: f32 = 2.0;
#[derive(SystemData)]
pub struct ImmutableData<'a> {
pub struct ReadData<'a> {
entities: Entities<'a>,
dt: Read<'a, DeltaTime>,
server_bus: Read<'a, EventBus<ServerEvent>>,
@ -38,7 +38,7 @@ pub struct Sys;
impl<'a> System<'a> for Sys {
#[allow(clippy::type_complexity)]
type SystemData = (
ImmutableData<'a>,
ReadData<'a>,
WriteStorage<'a, Stats>,
WriteStorage<'a, Health>,
WriteStorage<'a, Poise>,
@ -49,7 +49,7 @@ impl<'a> System<'a> for Sys {
fn run(
&mut self,
(
immutable_data,
read_data,
mut stats,
mut healths,
mut poises,
@ -59,8 +59,8 @@ impl<'a> System<'a> for Sys {
) {
let start_time = std::time::Instant::now();
span!(_guard, "run", "stats::Sys::run");
let mut server_event_emitter = immutable_data.server_bus.emitter();
let dt = immutable_data.dt.0;
let mut server_event_emitter = read_data.server_bus.emitter();
let dt = read_data.dt.0;
// Increment last change timer
healths.set_event_emission(false); // avoid unnecessary syncing
@ -76,11 +76,11 @@ impl<'a> System<'a> for Sys {
// Update stats
for (entity, uid, mut stats, mut health, pos) in (
&immutable_data.entities,
&immutable_data.uids,
&read_data.entities,
&read_data.uids,
&mut stats.restrict_mut(),
&mut healths.restrict_mut(),
&immutable_data.positions,
&read_data.positions,
)
.join()
{
@ -129,7 +129,7 @@ impl<'a> System<'a> for Sys {
&mut stats.restrict_mut(),
&mut healths.restrict_mut(),
&mut energies.restrict_mut(),
&immutable_data.bodies,
&read_data.bodies,
)
.join()
{
@ -161,7 +161,7 @@ impl<'a> System<'a> for Sys {
// Update energies and poises
for (character_state, mut energy, mut poise) in (
&immutable_data.char_states,
&read_data.char_states,
&mut energies.restrict_mut(),
&mut poises.restrict_mut(),
)
@ -256,7 +256,7 @@ impl<'a> System<'a> for Sys {
}
}
immutable_data.metrics.stats_ns.store(
read_data.metrics.stats_ns.store(
start_time.elapsed().as_nanos() as u64,
std::sync::atomic::Ordering::Relaxed,
);