refactor writing entities

1 files changed, 6 insertions, 58 deletions

diff --git a/src/sim/sim_manager/mod.rs b/src/sim/sim_manager/mod.rs
index 97f542b..74c21fa 100644
--- a/src/sim/sim_manager/mod.rs
+++ b/src/sim/sim_manager/mod.rs
@@ -1,18 +1,16 @@
 use std::time::Instant;
 
 use fxhash::FxHashMap;
-use glam::IVec2;
 
 use crate::{
     Config,
     config::{PHYSICS_DELTA_TIME, PHYSICS_FPS, SIM_FPS},
     sim::{
-        cell::Cell,
         cell_manager::manager::CellManager,
         entity::{Entity, EntityDef, EntityId},
         particle_manager::ParticleManager,
         rb_manager::RbManager,
-        sim_manager::utils::write_entity_to_world,
+        sim_manager::utils::{read_back_entities_from_world, write_entities_to_world},
     },
 };
 
@@ -95,17 +93,12 @@ impl SimManager {
 
     fn cell_update(&mut self, config: &Config, delta_time: f32) {
         // before we tick, write all the entities into the sim world
-        // TODO optimize
-        let entity_ids: Vec<EntityId> = self.entities.keys().copied().collect();
-        let mut cells_written_by_entity: Vec<(EntityId, Vec<(u8, u8, i32, i32)>)> = Vec::new();
-
-        for entity_id in entity_ids {
-            let cells_written = write_entity_to_world(self, entity_id, self.cell_manager.seqno);
-            cells_written_by_entity.push((entity_id, cells_written));
-        }
+        let cells_written_by_entity = write_entities_to_world(self);
 
+        // tick
         self.cell_manager.tick(config.use_threading);
 
+        // update entities
         let entity_ids: Vec<EntityId> = self.entities.keys().cloned().collect();
         for id in entity_ids {
             let entity = self.entities.get_mut(&id);
@@ -117,6 +110,7 @@ impl SimManager {
             if let Some(entity) = entity
                 && let Some(result) = entity.update(&mut ctx, delta_time)
             {
+                // process entity update results
                 for d in result.deferred_destructions {
                     self.destroy_entity(d);
                 }
@@ -124,53 +118,7 @@ impl SimManager {
         }
 
         // after we tick, remove the written entity cells and update the entities
-        // TODO optimize
-        for (entity_id, cells_written) in cells_written_by_entity {
-            if let Some(entity) = self.entities.get_mut(&entity_id) {
-                let entity_cells = entity.data.cells.as_mut().unwrap();
-                let mut should_update_entity = false;
-
-                for (lx, ly, x, y) in cells_written {
-                    // update the entity
-                    // TODO optimize
-                    let new_local_cell =
-                        self.cell_manager.get_cell_from_game_position(x, y).unwrap();
-                    if !new_local_cell.entity_integrated() {
-                        // this means that the entity changed in some way, so we should recompute its shape
-                        // TODO wait N frames to debounce this
-                        should_update_entity = true;
-                    }
-                    // we do this unconditionally because it's cheaper than checking if it actually needs to be updated
-                    // and because we don't have a good way to track changes to cell state
-                    entity_cells.set_cell_at_local_position(
-                        IVec2::new(lx as i32, ly as i32),
-                        new_local_cell,
-                    );
-
-                    // update the world
-                    // TODO optimize
-                    self.cell_manager
-                        .set_cell_from_game_position(x, y, Cell::void(), false);
-                }
-
-                if should_update_entity {
-                    if let Some(new_collider) = entity.compute_collider() {
-                        self.rb_manager
-                            .physics_manager
-                            .world
-                            .remove_collider(entity.data.collider_h.unwrap());
-
-                        let new_handle = self
-                            .rb_manager
-                            .physics_manager
-                            .world
-                            .insert_collider(new_collider, Some(entity.data.rb_h.unwrap()));
-
-                        entity.data.collider_h = Some(new_handle);
-                    }
-                }
-            }
-        }
+        read_back_entities_from_world(self, cells_written_by_entity);
     }
 
     fn physics_update(&mut self, delta_time: f32) {