space-crush/space-crush-common/src/systems/raster_update.rs

use shrev::ReaderId;
use specs::{hibitset::BitSetLike, prelude::*, Entities, ReadStorage, System, World, WriteStorage};

use crate::{components::Position, misc::ComponentEvent, resources::Raster};

pub struct RasterUpdate {
    need_update: BitSet,
    position_id: ReaderId<ComponentEvent<Position>>,
}

impl RasterUpdate {
    pub fn new(world: &mut World) -> Self {
        let need_update = BitSet::new();
        let position_id = unsafe {
            WriteStorage::<Position>::setup(world);

            let mut position = world.write_component::<Position>();
            position
                .unprotected_storage_mut()
                .channel_mut()
                .register_reader()
        };

        Self {
            need_update,
            position_id,
        }
    }
}

#[derive(SystemData)]
pub struct RasterUpdateData<'a> {
    raster: WriteExpect<'a, Raster>,
    entities: Entities<'a>,
    positions: ReadStorage<'a, Position>,
}

impl<'a> System<'a> for RasterUpdate {
    type SystemData = RasterUpdateData<'a>;

    fn run(&mut self, data: Self::SystemData) {
        let RasterUpdateData {
            mut raster,
            entities,
            positions,
        } = data;

        self.need_update.clear();

        let events = positions
            .unprotected_storage()
            .channel()
            .read(&mut self.position_id);
        for event in events {
            match event {
                ComponentEvent::Inserted(id) => {
                    self.need_update.add(*id);
                }
                ComponentEvent::Modified(id, position) | ComponentEvent::Removed(id, position) => {
                    self.need_update.add(*id);
                    raster.remove(id, position);
                }
            }
        }

        if self.need_update.is_empty() {
            return;
        }

        for (e, position) in (&entities, &positions).join() {
            raster.insert(e.id(), position);
        }
    }
}