2019-11-04 00:57:36 +00:00
|
|
|
use super::SysTimer;
|
|
|
|
|
use common::{
|
|
|
|
|
comp::{
|
2020-03-14 21:33:20 +00:00
|
|
|
Body, CanBuild, CharacterState, Energy, Gravity, Item, LightEmitter, Loadout, Mass,
|
2020-02-24 19:57:33 +00:00
|
|
|
MountState, Mounting, Player, Scale, Stats, Sticky,
|
2019-11-04 00:57:36 +00:00
|
|
|
},
|
2019-12-18 05:22:52 +00:00
|
|
|
msg::EcsCompPacket,
|
|
|
|
|
sync::{EntityPackage, SyncPackage, Uid, UpdateTracker, WorldSyncExt},
|
2019-11-04 00:57:36 +00:00
|
|
|
};
|
2019-11-29 06:04:37 +00:00
|
|
|
use hashbrown::HashMap;
|
2019-11-04 00:57:36 +00:00
|
|
|
use specs::{
|
2019-11-30 06:41:20 +00:00
|
|
|
shred::ResourceId, Entity as EcsEntity, Join, ReadExpect, ReadStorage, System, SystemData,
|
|
|
|
|
World, Write, WriteExpect,
|
2019-11-04 00:57:36 +00:00
|
|
|
};
|
2019-11-29 06:04:37 +00:00
|
|
|
use vek::*;
|
2019-11-04 00:57:36 +00:00
|
|
|
|
|
|
|
|
/// Always watching
|
2020-02-01 20:39:39 +00:00
|
|
|
/// This system will monitor specific components for insertion, removal, and
|
|
|
|
|
/// modification
|
2019-11-04 00:57:36 +00:00
|
|
|
pub struct Sys;
|
|
|
|
|
impl<'a> System<'a> for Sys {
|
|
|
|
|
type SystemData = (
|
|
|
|
|
Write<'a, SysTimer<Self>>,
|
|
|
|
|
TrackedComps<'a>,
|
|
|
|
|
WriteTrackers<'a>,
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
fn run(&mut self, (mut timer, comps, mut trackers): Self::SystemData) {
|
|
|
|
|
timer.start();
|
|
|
|
|
|
|
|
|
|
record_changes(&comps, &mut trackers);
|
|
|
|
|
|
|
|
|
|
timer.end();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Probably more difficult than it needs to be :p
|
|
|
|
|
#[derive(SystemData)]
|
|
|
|
|
pub struct TrackedComps<'a> {
|
2019-11-29 06:04:37 +00:00
|
|
|
pub uid: ReadStorage<'a, Uid>,
|
|
|
|
|
pub body: ReadStorage<'a, Body>,
|
|
|
|
|
pub player: ReadStorage<'a, Player>,
|
|
|
|
|
pub stats: ReadStorage<'a, Stats>,
|
2020-01-12 16:43:25 +00:00
|
|
|
pub energy: ReadStorage<'a, Energy>,
|
2019-11-29 06:04:37 +00:00
|
|
|
pub can_build: ReadStorage<'a, CanBuild>,
|
|
|
|
|
pub light_emitter: ReadStorage<'a, LightEmitter>,
|
|
|
|
|
pub item: ReadStorage<'a, Item>,
|
|
|
|
|
pub scale: ReadStorage<'a, Scale>,
|
|
|
|
|
pub mounting: ReadStorage<'a, Mounting>,
|
|
|
|
|
pub mount_state: ReadStorage<'a, MountState>,
|
|
|
|
|
pub mass: ReadStorage<'a, Mass>,
|
|
|
|
|
pub sticky: ReadStorage<'a, Sticky>,
|
|
|
|
|
pub gravity: ReadStorage<'a, Gravity>,
|
2020-03-14 21:33:20 +00:00
|
|
|
pub loadout: ReadStorage<'a, Loadout>,
|
2020-02-24 19:57:33 +00:00
|
|
|
pub character_state: ReadStorage<'a, CharacterState>,
|
2019-11-04 00:57:36 +00:00
|
|
|
}
|
|
|
|
|
impl<'a> TrackedComps<'a> {
|
|
|
|
|
pub fn create_entity_package(&self, entity: EcsEntity) -> EntityPackage<EcsCompPacket> {
|
|
|
|
|
let uid = self
|
|
|
|
|
.uid
|
|
|
|
|
.get(entity)
|
|
|
|
|
.copied()
|
|
|
|
|
.expect("No uid to create an entity package")
|
|
|
|
|
.0;
|
2019-12-18 05:22:52 +00:00
|
|
|
let mut comps = Vec::new();
|
|
|
|
|
self.body.get(entity).copied().map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
self.player
|
|
|
|
|
.get(entity)
|
|
|
|
|
.cloned()
|
2019-12-18 05:22:52 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
self.stats
|
|
|
|
|
.get(entity)
|
|
|
|
|
.cloned()
|
2019-12-18 05:22:52 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
2020-01-12 16:43:25 +00:00
|
|
|
self.energy
|
|
|
|
|
.get(entity)
|
|
|
|
|
.cloned()
|
|
|
|
|
.map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
self.can_build
|
|
|
|
|
.get(entity)
|
|
|
|
|
.cloned()
|
2019-12-18 05:22:52 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
self.light_emitter
|
|
|
|
|
.get(entity)
|
|
|
|
|
.copied()
|
2019-12-18 05:22:52 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
|
|
|
|
self.item.get(entity).cloned().map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
self.scale
|
|
|
|
|
.get(entity)
|
|
|
|
|
.copied()
|
2019-12-18 05:22:52 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
self.mounting
|
|
|
|
|
.get(entity)
|
|
|
|
|
.cloned()
|
2019-12-18 05:22:52 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
self.mount_state
|
|
|
|
|
.get(entity)
|
|
|
|
|
.cloned()
|
2019-12-18 05:22:52 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
|
|
|
|
self.mass.get(entity).copied().map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
self.sticky
|
|
|
|
|
.get(entity)
|
|
|
|
|
.copied()
|
2019-12-18 05:22:52 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
self.gravity
|
|
|
|
|
.get(entity)
|
|
|
|
|
.copied()
|
2019-12-18 05:22:52 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
2020-03-14 21:33:20 +00:00
|
|
|
self.loadout
|
2020-02-03 10:54:50 +00:00
|
|
|
.get(entity)
|
2020-03-14 21:33:20 +00:00
|
|
|
.cloned()
|
2020-02-03 10:54:50 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
2020-02-24 19:57:33 +00:00
|
|
|
self.character_state
|
|
|
|
|
.get(entity)
|
2020-03-16 11:32:57 +00:00
|
|
|
.cloned()
|
2020-02-24 19:57:33 +00:00
|
|
|
.map(|c| comps.push(c.into()));
|
2019-11-04 00:57:36 +00:00
|
|
|
|
2019-12-18 05:22:52 +00:00
|
|
|
EntityPackage { uid, comps }
|
2019-11-04 00:57:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#[derive(SystemData)]
|
|
|
|
|
pub struct ReadTrackers<'a> {
|
2019-11-29 06:04:37 +00:00
|
|
|
pub uid: ReadExpect<'a, UpdateTracker<Uid>>,
|
|
|
|
|
pub body: ReadExpect<'a, UpdateTracker<Body>>,
|
|
|
|
|
pub player: ReadExpect<'a, UpdateTracker<Player>>,
|
|
|
|
|
pub stats: ReadExpect<'a, UpdateTracker<Stats>>,
|
2020-01-12 16:43:25 +00:00
|
|
|
pub energy: ReadExpect<'a, UpdateTracker<Energy>>,
|
2019-11-29 06:04:37 +00:00
|
|
|
pub can_build: ReadExpect<'a, UpdateTracker<CanBuild>>,
|
|
|
|
|
pub light_emitter: ReadExpect<'a, UpdateTracker<LightEmitter>>,
|
|
|
|
|
pub item: ReadExpect<'a, UpdateTracker<Item>>,
|
|
|
|
|
pub scale: ReadExpect<'a, UpdateTracker<Scale>>,
|
|
|
|
|
pub mounting: ReadExpect<'a, UpdateTracker<Mounting>>,
|
|
|
|
|
pub mount_state: ReadExpect<'a, UpdateTracker<MountState>>,
|
|
|
|
|
pub mass: ReadExpect<'a, UpdateTracker<Mass>>,
|
|
|
|
|
pub sticky: ReadExpect<'a, UpdateTracker<Sticky>>,
|
|
|
|
|
pub gravity: ReadExpect<'a, UpdateTracker<Gravity>>,
|
2020-03-14 21:33:20 +00:00
|
|
|
pub loadout: ReadExpect<'a, UpdateTracker<Loadout>>,
|
2020-02-24 19:57:33 +00:00
|
|
|
pub character_state: ReadExpect<'a, UpdateTracker<CharacterState>>,
|
2019-11-04 00:57:36 +00:00
|
|
|
}
|
|
|
|
|
impl<'a> ReadTrackers<'a> {
|
|
|
|
|
pub fn create_sync_package(
|
|
|
|
|
&self,
|
|
|
|
|
comps: &TrackedComps,
|
|
|
|
|
filter: impl Join + Copy,
|
2019-11-29 06:04:37 +00:00
|
|
|
deleted_entities: Vec<u64>,
|
2019-11-04 00:57:36 +00:00
|
|
|
) -> SyncPackage<EcsCompPacket> {
|
2019-11-29 06:04:37 +00:00
|
|
|
SyncPackage::new(&comps.uid, &self.uid, filter, deleted_entities)
|
2019-11-30 05:33:17 +00:00
|
|
|
.with_component(&comps.uid, &*self.body, &comps.body, filter)
|
|
|
|
|
.with_component(&comps.uid, &*self.player, &comps.player, filter)
|
|
|
|
|
.with_component(&comps.uid, &*self.stats, &comps.stats, filter)
|
2020-01-12 16:43:25 +00:00
|
|
|
.with_component(&comps.uid, &*self.energy, &comps.energy, filter)
|
2019-11-30 05:33:17 +00:00
|
|
|
.with_component(&comps.uid, &*self.can_build, &comps.can_build, filter)
|
2019-11-04 00:57:36 +00:00
|
|
|
.with_component(
|
|
|
|
|
&comps.uid,
|
2019-11-30 05:33:17 +00:00
|
|
|
&*self.light_emitter,
|
2019-11-04 00:57:36 +00:00
|
|
|
&comps.light_emitter,
|
|
|
|
|
filter,
|
|
|
|
|
)
|
2019-11-30 05:33:17 +00:00
|
|
|
.with_component(&comps.uid, &*self.item, &comps.item, filter)
|
|
|
|
|
.with_component(&comps.uid, &*self.scale, &comps.scale, filter)
|
|
|
|
|
.with_component(&comps.uid, &*self.mounting, &comps.mounting, filter)
|
|
|
|
|
.with_component(&comps.uid, &*self.mount_state, &comps.mount_state, filter)
|
|
|
|
|
.with_component(&comps.uid, &*self.mass, &comps.mass, filter)
|
|
|
|
|
.with_component(&comps.uid, &*self.sticky, &comps.sticky, filter)
|
|
|
|
|
.with_component(&comps.uid, &*self.gravity, &comps.gravity, filter)
|
2020-03-14 21:33:20 +00:00
|
|
|
.with_component(&comps.uid, &*self.loadout, &comps.loadout, filter)
|
2020-02-24 19:57:33 +00:00
|
|
|
.with_component(
|
|
|
|
|
&comps.uid,
|
|
|
|
|
&*self.character_state,
|
|
|
|
|
&comps.character_state,
|
|
|
|
|
filter,
|
|
|
|
|
)
|
2019-11-04 00:57:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(SystemData)]
|
|
|
|
|
pub struct WriteTrackers<'a> {
|
|
|
|
|
uid: WriteExpect<'a, UpdateTracker<Uid>>,
|
|
|
|
|
body: WriteExpect<'a, UpdateTracker<Body>>,
|
|
|
|
|
player: WriteExpect<'a, UpdateTracker<Player>>,
|
|
|
|
|
stats: WriteExpect<'a, UpdateTracker<Stats>>,
|
2020-01-12 16:43:25 +00:00
|
|
|
energy: WriteExpect<'a, UpdateTracker<Energy>>,
|
2019-11-04 00:57:36 +00:00
|
|
|
can_build: WriteExpect<'a, UpdateTracker<CanBuild>>,
|
|
|
|
|
light_emitter: WriteExpect<'a, UpdateTracker<LightEmitter>>,
|
|
|
|
|
item: WriteExpect<'a, UpdateTracker<Item>>,
|
|
|
|
|
scale: WriteExpect<'a, UpdateTracker<Scale>>,
|
|
|
|
|
mounting: WriteExpect<'a, UpdateTracker<Mounting>>,
|
|
|
|
|
mount_state: WriteExpect<'a, UpdateTracker<MountState>>,
|
|
|
|
|
mass: WriteExpect<'a, UpdateTracker<Mass>>,
|
|
|
|
|
sticky: WriteExpect<'a, UpdateTracker<Sticky>>,
|
|
|
|
|
gravity: WriteExpect<'a, UpdateTracker<Gravity>>,
|
2020-03-14 21:33:20 +00:00
|
|
|
loadout: WriteExpect<'a, UpdateTracker<Loadout>>,
|
2020-02-24 19:57:33 +00:00
|
|
|
character_state: WriteExpect<'a, UpdateTracker<CharacterState>>,
|
2019-11-04 00:57:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn record_changes(comps: &TrackedComps, trackers: &mut WriteTrackers) {
|
|
|
|
|
// Update trackers
|
|
|
|
|
trackers.uid.record_changes(&comps.uid);
|
|
|
|
|
trackers.body.record_changes(&comps.body);
|
|
|
|
|
trackers.player.record_changes(&comps.player);
|
|
|
|
|
trackers.stats.record_changes(&comps.stats);
|
2020-01-12 16:43:25 +00:00
|
|
|
trackers.energy.record_changes(&comps.energy);
|
2019-11-04 00:57:36 +00:00
|
|
|
trackers.can_build.record_changes(&comps.can_build);
|
|
|
|
|
trackers.light_emitter.record_changes(&comps.light_emitter);
|
|
|
|
|
trackers.item.record_changes(&comps.item);
|
|
|
|
|
trackers.scale.record_changes(&comps.scale);
|
|
|
|
|
trackers.mounting.record_changes(&comps.mounting);
|
|
|
|
|
trackers.mount_state.record_changes(&comps.mount_state);
|
|
|
|
|
trackers.mass.record_changes(&comps.mass);
|
|
|
|
|
trackers.sticky.record_changes(&comps.sticky);
|
|
|
|
|
trackers.gravity.record_changes(&comps.gravity);
|
2020-03-14 21:33:20 +00:00
|
|
|
trackers.loadout.record_changes(&comps.loadout);
|
2020-02-24 19:57:33 +00:00
|
|
|
trackers
|
|
|
|
|
.character_state
|
|
|
|
|
.record_changes(&comps.character_state);
|
2019-11-04 00:57:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn register_trackers(world: &mut World) {
|
|
|
|
|
world.register_tracker::<Uid>();
|
|
|
|
|
world.register_tracker::<Body>();
|
|
|
|
|
world.register_tracker::<Player>();
|
|
|
|
|
world.register_tracker::<Stats>();
|
2020-01-12 16:43:25 +00:00
|
|
|
world.register_tracker::<Energy>();
|
2019-11-04 00:57:36 +00:00
|
|
|
world.register_tracker::<CanBuild>();
|
|
|
|
|
world.register_tracker::<LightEmitter>();
|
|
|
|
|
world.register_tracker::<Item>();
|
|
|
|
|
world.register_tracker::<Scale>();
|
|
|
|
|
world.register_tracker::<Mounting>();
|
|
|
|
|
world.register_tracker::<MountState>();
|
|
|
|
|
world.register_tracker::<Mass>();
|
|
|
|
|
world.register_tracker::<Sticky>();
|
|
|
|
|
world.register_tracker::<Gravity>();
|
2020-03-14 21:33:20 +00:00
|
|
|
world.register_tracker::<Loadout>();
|
2020-02-24 19:57:33 +00:00
|
|
|
world.register_tracker::<CharacterState>();
|
2019-11-04 00:57:36 +00:00
|
|
|
}
|
|
|
|
|
|
2019-11-29 06:04:37 +00:00
|
|
|
/// Deleted entities grouped by region
|
|
|
|
|
pub struct DeletedEntities {
|
|
|
|
|
map: HashMap<Vec2<i32>, Vec<u64>>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Default for DeletedEntities {
|
|
|
|
|
fn default() -> Self {
|
|
|
|
|
Self {
|
|
|
|
|
map: HashMap::new(),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl DeletedEntities {
|
|
|
|
|
pub fn record_deleted_entity(&mut self, uid: Uid, region_key: Vec2<i32>) {
|
|
|
|
|
self.map
|
|
|
|
|
.entry(region_key)
|
|
|
|
|
.or_insert(Vec::new())
|
|
|
|
|
.push(uid.into());
|
|
|
|
|
}
|
2020-02-01 20:39:39 +00:00
|
|
|
|
2019-11-29 06:04:37 +00:00
|
|
|
pub fn take_deleted_in_region(&mut self, key: Vec2<i32>) -> Option<Vec<u64>> {
|
|
|
|
|
self.map.remove(&key)
|
|
|
|
|
}
|
2020-02-01 20:39:39 +00:00
|
|
|
|
2019-11-29 06:04:37 +00:00
|
|
|
pub fn get_deleted_in_region(&mut self, key: Vec2<i32>) -> Option<&Vec<u64>> {
|
|
|
|
|
self.map.get(&key)
|
|
|
|
|
}
|
2020-02-01 20:39:39 +00:00
|
|
|
|
2019-11-29 06:04:37 +00:00
|
|
|
pub fn take_remaining_deleted(&mut self) -> Vec<(Vec2<i32>, Vec<u64>)> {
|
|
|
|
|
// TODO: don't allocate
|
|
|
|
|
self.map.drain().collect()
|
2019-11-04 00:57:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
