From 6f32ab87309de4b52af255bf8f56f785f084c97f Mon Sep 17 00:00:00 2001
From: ghostlyzsh <pokeball.181818@gmail.com>
Date: Thu, 20 Apr 2023 22:58:05 -0500
Subject: [PATCH] added lifespans to modules

---
 client/src/index.ts   |  1 -
 server/src/entity.rs  | 10 ++++++++++
 server/src/manager.rs |  1 +
 server/src/timer.rs   | 31 +++++++++++++++++++++++++------
 4 files changed, 36 insertions(+), 7 deletions(-)

diff --git a/client/src/index.ts b/client/src/index.ts
index 45be676a0d4d2e2a74b5c002df385034ccdd0bc2..d4be2f5405404789a0a6a4e43deebf9ea0c3a04e 100644
--- a/client/src/index.ts
+++ b/client/src/index.ts
@@ -212,7 +212,6 @@ async function client_main(server: string, username: string, texture_quality: st
 
         for (let i = 0; i < global.modules.length; i++) {
             let module = global.modules[i];
-            console.log(module);
             // @ts-ignore
             let tex = global.spritesheet!["frames"][module_type_to_tex_id(module.moduleType)];
 
diff --git a/server/src/entity.rs b/server/src/entity.rs
index 7baf9f7abfa4aa1ae74c5da530bf9985ba517fc3..1d7d80aa339daa2ae032f464889a5596fc6b5f35 100644
--- a/server/src/entity.rs
+++ b/server/src/entity.rs
@@ -97,6 +97,16 @@ impl EntityHandler {
         }
         module_count
     }
+    pub fn get_from_module(&self, p_module: &Module) -> Option<EntityId> {
+        for (id, entity) in self.entities.iter() {
+            if let Entity::Module(module) = entity {
+                if module.handle == p_module.handle {
+                    return Some(*id);
+                }
+            }
+        }
+        None
+    }
 
     pub fn gravity(&self, position: (f64, f64), mass: f64) -> (f64, f64) {
         let mut direction = Vector2::zeros();
diff --git a/server/src/manager.rs b/server/src/manager.rs
index 5d696a9eb574e3891b9ab416c32a42edc8192991..37b2e35b26382e7053f455dfc49ce279d2c366c9 100644
--- a/server/src/manager.rs
+++ b/server/src/manager.rs
@@ -37,6 +37,7 @@ impl Player {
 pub struct Module {
     pub handle: RigidBodyHandle,
     pub module_type: ModuleType,
+    pub lifetime: f64,
 }
 
 #[derive(Default, Clone)]
diff --git a/server/src/timer.rs b/server/src/timer.rs
index bbdd4bb3b97d5a90af692279e07d093f1d0cd0ea..1e87a7d84133207be73de2ea9e73b8413ee633a8 100644
--- a/server/src/timer.rs
+++ b/server/src/timer.rs
@@ -13,7 +13,7 @@ use crate::orbit::orbit::{calculate_point_on_orbit, calculate_world_position_of_
 
 pub const ROTATIONAL_FORCE: f64 = 100.0;
 pub const LATERAL_FORCE: f64 = 100.0;
-pub const MODULE_SPAWN: f64 = 3000.0;
+pub const MODULE_SPAWN: f64 = 3.0;
 pub const MODULE_MAX: u32 = 10;
 
 pub async fn timer_main(mgr: ClientManager, physics_data_orig: Arc<RwLock<PhysicsData>>, entities: Arc<RwLock<EntityHandler>>) {
@@ -66,8 +66,7 @@ pub async fn timer_main(mgr: ClientManager, physics_data_orig: Arc<RwLock<Physic
         let mut protocol_players = vec![];
 
         {
-            if module_timer > 1.0 && entities.read().await.get_module_count() < MODULE_MAX {
-                debug!("module spawn");
+            if module_timer > MODULE_SPAWN && entities.read().await.get_module_count() < MODULE_MAX {
                 module_timer = 0.;
 
                 let mut rigid_body_set = physics_data.rigid_body_set.clone();
@@ -93,17 +92,37 @@ pub async fn timer_main(mgr: ClientManager, physics_data_orig: Arc<RwLock<Physic
                 let module = Module {
                     handle: module_handler,
                     module_type: ModuleType::Cargo,
+                    lifetime: 0.0,
                 };
                 entities.write().await.entities.insert(get_entity_id(), Entity::Module(module));
             }
-            for module in entities.read().await.get_modules().iter() {
+            let mut entities = entities.write().await;
+            for mut module in entities.get_modules().iter_mut() {
                 let module_handle = module.handle;
                 let module_body = physics_data.rigid_body_set.get_mut(module_handle).unwrap();
                 module_body.reset_forces(true);
                 module_body.reset_torques(true);
-                let planets = entities.read().await;
-                let grav_force = planets.gravity((module_body.translation().x, module_body.translation().y), module_body.mass());
+                let grav_force = entities.gravity((module_body.translation().x, module_body.translation().y), module_body.mass());
                 module_body.apply_impulse(vector![grav_force.0, grav_force.1], true);
+                let id = entities.get_from_module(module).unwrap();
+                if let Entity::Module(p_module) = entities.entities.get_mut(&id).unwrap() {
+                    p_module.lifetime += 5./1000.;
+                }
+                if module.lifetime > 80. {
+                    let mut rigid_body_set = physics_data.rigid_body_set.clone();
+                    let mut island_manager = physics_data.island_manager.clone();
+                    let mut collider_set = physics_data.collider_set.clone();
+                    let mut impulse_joint_set = physics_data.impulse_joint_set.clone();
+                    let mut multibody_joint_set = physics_data.multibody_joint_set.clone();
+                    rigid_body_set.remove(module.handle, &mut island_manager, &mut collider_set,
+                                            &mut impulse_joint_set, &mut multibody_joint_set, true);
+                    physics_data.rigid_body_set = rigid_body_set;
+                    physics_data.collider_set = collider_set;
+                    physics_data.island_manager = island_manager;
+                    physics_data.impulse_joint_set = impulse_joint_set;
+                    physics_data.multibody_joint_set = multibody_joint_set;
+                    entities.entities.remove(&id);
+                }
             }
         }