7 files changed, 62 insertions(+), 33 deletions(-)

M Cargo.lock
A client.tar.gz
M server/Cargo.toml
M server/src/handler.rs
M server/src/main.rs
M server/src/manager.rs
M server/src/timer.rs

@@ 919,10 919,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "978aa494585d3ca4ad74929863093e87cac9790d81fe7aba2b3dc2890643a0fc"
 
 [[package]]
-name = "parry2d"
+name = "parry2d-f64"
 version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49c6edd297a40754e762344dbeb454bdfb51472f03280473065b9b0898008ce3"
+checksum = "4a1bf555d44a3be6c6b6acdea1614af50b12987b4b9651c812d3219e8136c336"
 dependencies = [
  "approx",
  "arrayvec",


@@ 1070,10 1070,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "rapier2d"
+name = "rapier2d-f64"
 version = "0.17.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f94d294a9b96694c14888dd0e8ce77620dcc4f2f49264109ef835fa5e2285b84"
+checksum = "392a5f19aead4a587efae46873e42abd8f95044cae99d029e2cc11f1c12a6bb4"
 dependencies = [
  "approx",
  "arrayvec",


@@ 1084,7 1084,7 @@ dependencies = [
  "nalgebra",
  "num-derive",
  "num-traits",
- "parry2d",
+ "parry2d-f64",
  "rustc-hash",
  "simba",
  "vec_map",


@@ 1372,7 1372,7 @@ dependencies = [
  "lazy_static",
  "log",
  "nalgebra",
- "rapier2d",
+ "rapier2d-f64",
  "rmp-serde",
  "serde",
  "serde_json",

@@ 22,7 22,7 @@ log = "0.4"
 simple_logger = "4.1"
 starkingdoms-protocol = { version = "0.1.0", path = "../protocol" }
 lazy_static = "1.4.0"
-rapier2d = { version = "0.17.2", features = [ "simd-stable" ] }
+rapier2d-f64 = { version = "0.17.2", features = [ "simd-stable" ] }
 nalgebra = "0.32.2"
 
 [build-dependencies]

@@ 7,7 7,7 @@ use futures::{FutureExt, SinkExt, StreamExt};
 use hyper::upgrade::Upgraded;
 use log::{error, info, warn};
 use nalgebra::vector;
-use rapier2d::prelude::{RigidBodyBuilder, RigidBodyType, ColliderBuilder};
+use rapier2d_f64::prelude::{RigidBodyBuilder, RigidBodyType, ColliderBuilder};
 use tokio::sync::RwLock;
 use tokio::sync::mpsc::Receiver;
 use tokio_tungstenite::WebSocketStream;


@@ 38,6 38,11 @@ pub async fn handle_client(mgr: ClientManager, data: Arc<RwLock<PhysicsData>>, r
                         y
                     }).await?;
                 }
+                ClientHandlerMessage::PlanetData { planets } => {
+                    send!(client_tx, &MessageS2C::PlanetData {
+                        planets
+                    }).await?;
+                }
             }
         } else {
             info!("channel closed, shutting down");


@@ 121,21 126,6 @@ pub async fn handle_client(mgr: ClientManager, data: Arc<RwLock<PhysicsData>>, r
 
                                 mgr.players.write().await.insert(remote_addr, Player { handle: player_handle });
                             }
-
-                            // TODO: Proper planet and position data
-                            // TODO: This is only for testing of the planet rendering code
-                            // TODO: !!!!!!!!!! REMOVE THIS WHEN PLANETS ACTUALLY EXIST !!!!!!!!!!
-                            send!(client_tx, &MessageS2C::PlanetData {
-                                planets: vec![
-                                    ProtocolPlanet {
-                                        planet_type: PlanetType::Earth,
-                                        radius: 1f64,
-                                        x: 0f64,
-                                        y: 0f64
-                                    }
-                                ]
-                            }).await?;
-                            // TODO: Remove above testing code when planets, yk, actually exist
                         },
                         MessageC2S::Goodbye { reason } => {
                             info!("client sent goodbye: {:?}", reason);

@@ 5,7 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 rapier2d::prelude::{MultibodyJointSet, ImpulseJointSet, ColliderSet, RigidBodySet, NarrowPhase, BroadPhase, IslandManager, CCDSolver, IntegrationParameters};
+use rapier2d_f64::prelude::{MultibodyJointSet, ImpulseJointSet, ColliderSet, RigidBodySet, NarrowPhase, BroadPhase, IslandManager, CCDSolver, IntegrationParameters, ColliderBuilder, RigidBodyBuilder, RigidBodyHandle};
 use tokio_tungstenite::WebSocketStream;
 use tungstenite::{handshake};
 use futures::stream::StreamExt;


@@ 24,7 24,7 @@ pub mod timer;
 #[macro_use]
 pub mod macros;
 
-const SCALE: f32 = 10.0;
+const SCALE: f64 = 10.0;
 
 async fn handle_request(mut request: Request<Body>, remote_addr: SocketAddr, mgr: ClientManager, physics_data: Arc<RwLock<PhysicsData>>) -> Result<Response<Body>, Infallible> {
     match (request.uri().path(), request.headers().contains_key(header::UPGRADE)) {


@@ 167,6 167,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()));
 }
 
 #[tokio::main]


@@ 189,11 190,31 @@ async fn main() {
         }
     });
 
+    // make earth
+    {
+        let mut data_handle = DATA.write().await;
+
+        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);
+
+        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 _timer_thread = tokio::spawn(async move {
-        timer_main(mgr_timer, physics_data).await;
+        timer_main(mgr_timer, physics_data, world_data).await;
     });
 
     let server = Server::bind(&addr).serve(make_svc);

@@ 3,8 3,9 @@ use std::collections::HashMap;
 use std::net::SocketAddr;
 use std::sync::Arc;
 
-use rapier2d::na::{Vector2};
-use rapier2d::prelude::{IntegrationParameters, PhysicsPipeline, IslandManager, BroadPhase, NarrowPhase, ImpulseJointSet, MultibodyJointSet, CCDSolver, RigidBodySet, ColliderSet, RigidBodyHandle};
+use rapier2d_f64::na::{Vector2};
+use rapier2d_f64::prelude::{IntegrationParameters, PhysicsPipeline, IslandManager, BroadPhase, NarrowPhase, ImpulseJointSet, MultibodyJointSet, CCDSolver, RigidBodySet, ColliderSet, RigidBodyHandle};
+use starkingdoms_protocol::ProtocolPlanet;
 use tokio::sync::mpsc::Sender;
 use tokio::sync::RwLock;
 


@@ 27,10 28,9 @@ pub struct ClientHandler {
 
 #[derive(Clone, Default)]
 pub struct PhysicsData {
-    pub gravity: Vector2<f32>,
+    pub gravity: Vector2<f64>,
     pub integration_parameters: IntegrationParameters,
-    pub island_manager: IslandManager,
-    pub broad_phase: BroadPhase,
+    pub island_manager: IslandManager, pub broad_phase: BroadPhase,
     pub narrow_phase: NarrowPhase,
     pub rigid_body_set: RigidBodySet,
     pub collider_set: ColliderSet,


@@ 62,4 62,5 @@ pub enum ClientHandlerMessage {
     Tick,
     ChatMessage { from: String, message: String },
     Position { x: f64, y: f64 },
+    PlanetData { planets: Vec<ProtocolPlanet> },
 }

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


@@ 28,6 29,22 @@ pub async fn timer_main(mgr: ClientManager, physics_data: Arc<RwLock<PhysicsData
                             error!("unable to send position packet: {}", e);
                         }
                     };
+                    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 {
+                        Ok(_) => (),
+                        Err(e) => {
+                            error!("unable to send earth packet: {}", e);
+                        }
+                    };
                 }
                 Err(e) => {
                     error!("unable to update a client thread: {}", e);