4 files changed, 37 insertions(+), 25 deletions(-)

M server/src/main.rs
M server/src/manager.rs
M server/src/planet.rs
M server/src/timer.rs

@@ 5,6 5,7 @@ use hyper::{Body, header, Request, Response, Server, server::conn::AddrStream, S
 use hyper::service::{make_service_fn, service_fn};
 use manager::PhysicsData;
 use nalgebra::vector;
+use planet::Planets;
 use rapier2d_f64::prelude::{MultibodyJointSet, ImpulseJointSet, ColliderSet, RigidBodySet, NarrowPhase, BroadPhase, IslandManager, CCDSolver, IntegrationParameters, ColliderBuilder, RigidBodyBuilder, RigidBodyHandle};
 use tokio_tungstenite::WebSocketStream;
 use tungstenite::{handshake};


@@ 168,7 169,7 @@ lazy_static! {
         multibody_joint_set: MultibodyJointSet::new(),
         ccd_solver: CCDSolver::new(),
     }));
-    static ref WORLD_DATA: Arc<RwLock<Vec<RigidBodyHandle>>> = Arc::new(RwLock::new(Vec::new()));
+    static ref PLANETS: Arc<RwLock<Planets>> = Arc::new(RwLock::new(Planets::default()));
 }
 
 #[tokio::main]


@@ 198,22 199,16 @@ async fn main() {
         let mut rigid_body_set = data_handle.rigid_body_set.clone();
         let mut collider_set = data_handle.collider_set.clone();
 
-        let earth_collider = ColliderBuilder::ball(1000.0 / SCALE).build();
-        let earth_body = RigidBodyBuilder::fixed()
-            .additional_mass(1000.0);
-        let earth_handle = rigid_body_set.insert(earth_body);
-
-        collider_set.insert_with_parent(earth_collider, earth_handle, &mut rigid_body_set);
+        let mut planets = PLANETS.write().await;
+        planets.planets = Planets::new(&mut rigid_body_set, &mut collider_set).planets;
 
         data_handle.rigid_body_set = rigid_body_set;
         data_handle.collider_set = collider_set;
-
-        WORLD_DATA.write().await.push(earth_handle);
     }
 
     let mgr_timer = CMGR.clone();
     let physics_data = DATA.clone();
-    let world_data = WORLD_DATA.clone();
+    let world_data = PLANETS.clone();
     let _timer_thread = tokio::spawn(async move {
         timer_main(mgr_timer, physics_data, world_data).await;
     });

@@ 57,7 57,7 @@ impl PhysicsData {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum ClientHandlerMessage {
     Tick,
     ChatMessage { from: String, message: String },

@@ 1,20 1,24 @@
 use rapier2d_f64::prelude::{RigidBodyHandle, RigidBodySet, ColliderBuilder, RigidBodyBuilder, ColliderSet};
+use starkingdoms_protocol::{PlanetType, ProtocolPlanet};
 
-use crate::SCALE;
+use crate::{SCALE, manager::ClientHandlerMessage};
 
+#[derive(Clone)]
 pub struct Planet {
+    pub planet_type: PlanetType,
     pub body_handle: RigidBodyHandle,
     pub position: (f64, f64),
     pub radius: f64,
     pub mass: f64
 }
 
+#[derive(Default, Clone)]
 pub struct Planets {
     pub planets: Vec<Planet>,
 }
 
 impl Planets {
-    pub fn make_planet(planets: &mut Vec<Planet>, mass: f64, radius: f64, position: (f64, f64), rigid_body_set: &mut RigidBodySet, collider_set: &mut ColliderSet) {
+    pub fn make_planet(planets: &mut Vec<Planet>, planet_type: PlanetType, mass: f64, radius: f64, position: (f64, f64), rigid_body_set: &mut RigidBodySet, collider_set: &mut ColliderSet) {
         let collider = ColliderBuilder::ball(1000.0 / SCALE)
             .build();
         let body = RigidBodyBuilder::fixed()


@@ 24,6 28,7 @@ impl Planets {
         collider_set.insert_with_parent(collider, body_handle, rigid_body_set);
 
         planets.push(Planet {
+            planet_type,
             body_handle,
             position,
             radius,


@@ 36,6 41,7 @@ impl Planets {
         
         let _earth = Planets::make_planet(
             &mut planets,
+            PlanetType::Earth,
             2000.0,
             1000.0,
             (0.0, 0.0),


@@ 45,4 51,23 @@ impl Planets {
 
         Planets { planets }
     }
+
+    pub fn to_protocol(&self) -> ClientHandlerMessage {
+        let mut message = ClientHandlerMessage::PlanetData {
+            planets: Vec::new()
+        };
+
+        for planet in self.planets.clone() {
+            if let ClientHandlerMessage::PlanetData { mut planets } = message.clone() {
+                planets.push(ProtocolPlanet {
+                    planet_type: planet.planet_type,
+                    x: planet.position.0 * SCALE,
+                    y: planet.position.1 * SCALE,
+                    radius: planet.radius,
+                });
+            }
+        }
+
+        message
+    }
 }

@@ 5,9 5,9 @@ use log::{error};
 use rapier2d_f64::prelude::{PhysicsPipeline, RigidBodyHandle};
 use starkingdoms_protocol::{ProtocolPlanet, PlanetType};
 use tokio::{time::sleep, sync::RwLock};
-use crate::{manager::{ClientHandlerMessage, ClientManager, PhysicsData}, SCALE};
+use crate::{manager::{ClientHandlerMessage, ClientManager, PhysicsData}, SCALE, planet::Planets};
 
-pub async fn timer_main(mgr: ClientManager, physics_data: Arc<RwLock<PhysicsData>>, world_data: Arc<RwLock<Vec<RigidBodyHandle>>>) {
+pub async fn timer_main(mgr: ClientManager, physics_data: Arc<RwLock<PhysicsData>>, world_data: Arc<RwLock<Planets>>) {
     let mut pipeline = PhysicsPipeline::new();
     loop {
         sleep(Duration::from_millis(5)).await;


@@ 40,16 40,8 @@ pub async fn timer_main(mgr: ClientManager, physics_data: Arc<RwLock<PhysicsData
                         }
                     };
                     let world = world_data.read().await;
-                    let earth_handle = world.get(0).unwrap();
-                    let earth_body = data.rigid_body_set.get(*earth_handle).unwrap();
-                    //let earth_collider = data.collider_set.get(earth_body.colliders()[0]).unwrap();
-                    let protocol_earth = ProtocolPlanet {
-                        planet_type: PlanetType::Earth,
-                        x: earth_body.translation().x * SCALE,
-                        y: earth_body.translation().y * SCALE,
-                        radius: 1000.0,
-                    };
-                    match client_thread.tx.send(ClientHandlerMessage::PlanetData { planets: vec![protocol_earth] }).await {
+                    let planet_data = world.to_protocol();
+                    match client_thread.tx.send(planet_data).await {
                         Ok(_) => (),
                         Err(e) => {
                             error!("unable to send earth packet: {}", e);