From d128f26234cf10b506de2e05f524a941d5691df3 Mon Sep 17 00:00:00 2001 From: c0repwn3r Date: Thu, 13 Apr 2023 23:26:52 -0400 Subject: [PATCH] translate server to protobuf protocol --- Cargo.lock | 1 - client/src/input/mod.rs | 37 -------- client/src/lib.rs | 10 ++- protocol/src/lib.rs | 149 ++++++++++++++++++++++++++++++++- protocol/src/pbuf/planet.proto | 2 +- server/Cargo.toml | 1 - server/src/handler.rs | 135 ++++++++++++++++------------- server/src/macros.rs | 15 ++-- server/src/main.rs | 2 +- server/src/manager.rs | 7 +- server/src/planet.rs | 14 ++-- server/src/timer.rs | 16 ++-- 12 files changed, 262 insertions(+), 127 deletions(-) delete mode 100644 client/src/input/mod.rs diff --git a/Cargo.lock b/Cargo.lock index bc8c6b831e8a8251b692236f131828c366e924cf..b95ba2b4f4de72e7d1ed78fb10d766f973567fd4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1585,7 +1585,6 @@ dependencies = [ "log", "nalgebra", "rapier2d-f64", - "rmp-serde", "serde", "serde_json", "simple_logger", diff --git a/client/src/input/mod.rs b/client/src/input/mod.rs deleted file mode 100644 index a768e2fa2d06c7011374dce4131a0ff3f0d28c08..0000000000000000000000000000000000000000 --- a/client/src/input/mod.rs +++ /dev/null @@ -1,37 +0,0 @@ -use std::error::Error; -use async_trait::async_trait; - -/* -Functions the input subsystem needs to perform: -- init -- register and unregister event handlers for: - - mouse movement - - keydown, keyup, keypress - - clicks - */ - -#[async_trait] -pub trait InputSubsystem { - async fn init() -> Result> where Self: Sized; - - async fn register_on_mouse_move(&mut self, id: &str, callback: dyn FnMut(OnMouseMoveEvent)) -> Result<(), Box>; - async fn unregister_on_mouse_move(&mut self, id: &str) -> Result<(), Box>; - - async fn register_on_key_down(&mut self, id: &str, callback: dyn FnMut(OnKeyDownEvent)) -> Result<(), Box>; - async fn unregister_on_key_down(&mut self, id: &str) -> Result<(), Box>; - - async fn register_on_key_up(&mut self, id: &str, callback: dyn FnMut(OnKeyUpEvent)) -> Result<(), Box>; - async fn unregister_on_key_up(&mut self, id: &str) -> Result<(), Box>; - - async fn register_on_keypress(&mut self, id: &str, callback: dyn FnMut(OnKeypressEvent)) -> Result<(), Box>; - async fn unregister_on_keypress(&mut self, id: &str) -> Result<(), Box>; - - async fn register_on_click(&mut self, id: &str, callback: dyn FnMut(OnClickEvent)) -> Result<(), Box>; - async fn unregister_on_click(&mut self, id: &str) -> Result<(), Box>; -} - -pub struct OnMouseMoveEvent {} -pub struct OnKeyDownEvent {} -pub struct OnKeyUpEvent {} -pub struct OnKeypressEvent {} -pub struct OnClickEvent {} \ No newline at end of file diff --git a/client/src/lib.rs b/client/src/lib.rs index 9a53e169ab1fd6fc8b0fb24cac53a7df45840f52..ed79d6711921d30fd976d30558be02dc7aee0c19 100644 --- a/client/src/lib.rs +++ b/client/src/lib.rs @@ -16,7 +16,6 @@ use futures::SinkExt; use lazy_static::lazy_static; use std::sync::Arc; use std::sync::RwLock; - use async_recursion::async_recursion; use futures::FutureExt; use wasm_bindgen_futures::JsFuture; @@ -33,7 +32,13 @@ pub mod macros; pub mod chat; pub mod rendering; pub mod textures; -pub mod input; + +pub struct Buttons { + up: bool, + right: bool, + down: bool, + left: bool +} #[wasm_bindgen] extern { @@ -70,6 +75,7 @@ lazy_static! { y: 0f64, players: vec![] })); + pub static ref BUTTONS: Arc = Arc::new(Buttons { up: false, left: false, right: false, down: false }); } pub const MAX_CONNECTION_TRIES: i32 = 10; diff --git a/protocol/src/lib.rs b/protocol/src/lib.rs index c001c58fbb1d528246c49c1b5c1cea5ae5f84992..a860ceec7d8241d908aebb907b5a59dc2744b5ca 100644 --- a/protocol/src/lib.rs +++ b/protocol/src/lib.rs @@ -1 +1,148 @@ -include!(concat!(env!("OUT_DIR"), "/protos/mod.rs")); \ No newline at end of file +use std::error::Error; +use protobuf::{Enum, Message}; +use crate::message_c2s::{MessageC2SChat, MessageC2SGoodbye, MessageC2SHello, MessageC2SPing}; +use crate::message_s2c::{MessageS2CChat, MessageS2CGoodbye, MessageS2CHello, MessageS2CPlanetData, MessageS2CPlayersUpdate, MessageS2CPong}; +use crate::starkingdoms_protocol::PacketWrapper; +include!(concat!(env!("OUT_DIR"), "/protos/mod.rs")); + +pub const PROTOCOL_VERSION: u32 = 1; + +#[derive(Debug)] +pub enum MessageC2S { + Hello(MessageC2SHello), + Goodbye(MessageC2SGoodbye), + Chat(MessageC2SChat), + Ping(MessageC2SPing) +} + +#[derive(Debug)] +pub enum MessageS2C { + Hello(MessageS2CHello), + Goodbye(MessageS2CGoodbye), + Chat(MessageS2CChat), + Pong(MessageS2CPong), + PlayersUpdate(MessageS2CPlayersUpdate), + PlanetData(MessageS2CPlanetData) +} + +impl TryFrom<&[u8]> for MessageC2S { + type Error = Box; + + fn try_from(value: &[u8]) -> Result { + let pkt = starkingdoms_protocol::PacketWrapper::parse_from_bytes(value)?; + + let deser_pkt = match pkt.packet_id { + _id if _id == message_c2s::message_c2shello::Packet_info::type_.value() as i64 => { + MessageC2S::Hello(MessageC2SHello::parse_from_bytes(&pkt.packet_data)?) + }, + _id if _id == message_c2s::message_c2sgoodbye::Packet_info::type_.value() as i64 => { + MessageC2S::Goodbye(MessageC2SGoodbye::parse_from_bytes(&pkt.packet_data)?) + }, + _id if _id == message_c2s::message_c2schat::Packet_info::type_.value() as i64 => { + MessageC2S::Chat(MessageC2SChat::parse_from_bytes(&pkt.packet_data)?) + }, + _id if _id == message_c2s::message_c2sping::Packet_info::type_.value() as i64 => { + MessageC2S::Ping(MessageC2SPing::parse_from_bytes(&pkt.packet_data)?) + } + _ => { return Err("Not a C2S packet".into()); } + }; + + Ok(deser_pkt) + } +} + +impl TryInto> for MessageC2S { + type Error = Box; + + fn try_into(self) -> Result, Self::Error> { + let (pkt_id, pkt_bytes) = match self { + MessageC2S::Hello(p) => { + (message_c2s::message_c2shello::Packet_info::type_.value(), p.write_to_bytes()?) + } + MessageC2S::Goodbye(p) => { + (message_c2s::message_c2sgoodbye::Packet_info::type_.value(), p.write_to_bytes()?) + } + MessageC2S::Chat(p) => { + (message_c2s::message_c2schat::Packet_info::type_.value(), p.write_to_bytes()?) + } + MessageC2S::Ping(p) => { + (message_c2s::message_c2sping::Packet_info::type_.value(), p.write_to_bytes()?) + } + }; + + let pkt = PacketWrapper { + packet_id: pkt_id as i64, + packet_data: pkt_bytes, + special_fields: Default::default(), + }; + + Ok(pkt.write_to_bytes()?) + } +} + +impl TryFrom<&[u8]> for MessageS2C { + type Error = Box; + + fn try_from(value: &[u8]) -> Result { + let pkt = PacketWrapper::parse_from_bytes(value)?; + + let deser_pkt = match pkt.packet_id { + _id if _id == message_s2c::message_s2chello::Packet_info::type_.value() as i64 => { + MessageS2C::Hello(MessageS2CHello::parse_from_bytes(&pkt.packet_data)?) + }, + _id if _id == message_s2c::message_s2cgoodbye::Packet_info::type_.value() as i64 => { + MessageS2C::Goodbye(MessageS2CGoodbye::parse_from_bytes(&pkt.packet_data)?) + }, + _id if _id == message_s2c::message_s2cchat::Packet_info::type_.value() as i64 => { + MessageS2C::Chat(MessageS2CChat::parse_from_bytes(&pkt.packet_data)?) + }, + _id if _id == message_s2c::message_s2cpong::Packet_info::type_.value() as i64 => { + MessageS2C::Pong(MessageS2CPong::parse_from_bytes(&pkt.packet_data)?) + }, + _id if _id == message_s2c::message_s2cplayers_update::Packet_info::type_.value() as i64 => { + MessageS2C::PlayersUpdate(MessageS2CPlayersUpdate::parse_from_bytes(&pkt.packet_data)?) + }, + _id if _id == message_s2c::message_s2cplanet_data::Packet_info::type_.value() as i64 => { + MessageS2C::PlanetData(MessageS2CPlanetData::parse_from_bytes(&pkt.packet_data)?) + }, + _ => { return Err("Not a S2C packet".into()); } + }; + + Ok(deser_pkt) + } +} + +impl TryInto> for MessageS2C { + type Error = Box; + + fn try_into(self) -> Result, Self::Error> { + let (pkt_id, pkt_bytes) = match self { + MessageS2C::Hello(p) => { + (message_s2c::message_s2chello::Packet_info::type_.value(), p.write_to_bytes()?) + } + MessageS2C::Goodbye(p) => { + (message_s2c::message_s2cgoodbye::Packet_info::type_.value(), p.write_to_bytes()?) + } + MessageS2C::Chat(p) => { + (message_s2c::message_s2cchat::Packet_info::type_.value(), p.write_to_bytes()?) + } + MessageS2C::Pong(p) => { + (message_s2c::message_s2cpong::Packet_info::type_.value(), p.write_to_bytes()?) + } + MessageS2C::PlayersUpdate(p) => { + (message_s2c::message_s2cplayers_update::Packet_info::type_.value(), p.write_to_bytes()?) + } + MessageS2C::PlanetData(p) => { + (message_s2c::message_s2cplanet_data::Packet_info::type_.value(), p.write_to_bytes()?) + } + }; + + let pkt = PacketWrapper { + packet_id: pkt_id as i64, + packet_data: pkt_bytes, + special_fields: Default::default(), + }; + + Ok(pkt.write_to_bytes()?) + } +} \ No newline at end of file diff --git a/protocol/src/pbuf/planet.proto b/protocol/src/pbuf/planet.proto index b85a736ff6d0210a3f8a450912e5dd03f8a1b60c..516cd81ac40b6cc4bf001fe361a8d912440a5c94 100644 --- a/protocol/src/pbuf/planet.proto +++ b/protocol/src/pbuf/planet.proto @@ -2,7 +2,7 @@ syntax = "proto3"; package protocol.planet; message Planet { - PlanetType type = 1; // Type of the planet + PlanetType planet_type = 1; // Type of the planet float x = 2; // Translation on the X axis, in game units float y = 3; // Translation on the Y axis, in game units float radius = 4; // The radius of the planet extending out from (x, y) diff --git a/server/Cargo.toml b/server/Cargo.toml index 9672d415311701cec3093e48886dfa866fda7bec..d975d0ef8bfa6640d3aa0cd06a3f33d0aca5e0f8 100644 --- a/server/Cargo.toml +++ b/server/Cargo.toml @@ -12,7 +12,6 @@ slp-description = "A StarKingdoms.TK server" [dependencies] tokio = { version = "1.27", features = ["macros", "sync", "rt-multi-thread"] } serde = { version = "1", features = ["derive"] } -rmp-serde = { version = "1" } serde_json = "1" futures = { version = "0.3", default-features = false } hyper = { version = "0.14", features = ["server", "http1", "http2", "tcp"] } diff --git a/server/src/handler.rs b/server/src/handler.rs index 55c66fb710da0e377b1c7c3bfed3491352bb92dd..1342e326e6c8733120205a747af5e9198aac80a0 100644 --- a/server/src/handler.rs +++ b/server/src/handler.rs @@ -12,8 +12,10 @@ use tokio::sync::RwLock; use tokio::sync::mpsc::Receiver; use tokio_tungstenite::WebSocketStream; use tungstenite::Message; -use starkingdoms_protocol::{GoodbyeReason, MessageC2S, MessageS2C, PROTOCOL_VERSION, State}; -use starkingdoms_protocol::GoodbyeReason::PingPongTimeout; +use starkingdoms_protocol::goodbye_reason::GoodbyeReason; +use starkingdoms_protocol::message_s2c::{MessageS2CChat, MessageS2CGoodbye, MessageS2CHello, MessageS2CPlanetData, MessageS2CPlayersUpdate, MessageS2CPong}; +use starkingdoms_protocol::{MessageS2C, MessageC2S, PROTOCOL_VERSION}; +use starkingdoms_protocol::state::State; use crate::manager::{ClientHandlerMessage, ClientManager, PhysicsData, Player}; use crate::{send, recv, SCALE}; @@ -29,24 +31,30 @@ pub async fn handle_client(mgr: ClientManager, data: Arc>, r ClientHandlerMessage::Tick => {} // this intentionally does nothing, ClientHandlerMessage::ChatMessage { from, message } => { if matches!(state, State::Play) { - send!(client_tx, &MessageS2C::Chat { + let msg = MessageS2C::Chat(MessageS2CChat { + from, message, - from - }).await?; + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; } } ClientHandlerMessage::PlayersUpdate { players } => { if matches!(state, State::Play) { - send!(client_tx, &MessageS2C::PlayersUpdate { - players - }).await?; + let msg = MessageS2C::PlayersUpdate(MessageS2CPlayersUpdate { + players, + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; } } ClientHandlerMessage::PlanetData { planets } => { if matches!(state, State::Play) { - send!(client_tx, &MessageS2C::PlanetData { - planets - }).await?; + let msg = MessageS2C::PlanetData(MessageS2CPlanetData { + planets, + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; } } } @@ -57,9 +65,11 @@ pub async fn handle_client(mgr: ClientManager, data: Arc>, r if ping_timeout < SystemTime::now() { error!("[{}] ping timeout", remote_addr); - send!(client_tx, &MessageS2C::Goodbye { - reason: PingPongTimeout - }).await?; + let msg = MessageS2C::Goodbye(MessageS2CGoodbye { + reason: GoodbyeReason::PingPongTimeout.into(), + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; break; } @@ -67,51 +77,57 @@ pub async fn handle_client(mgr: ClientManager, data: Arc>, r match state { State::Handshake => { match pkt { - MessageC2S::Hello { version, requested_username, next_state } => { - if !matches!(next_state, State::Play) { - error!("client sent unexpected state {:?} (expected: Play)", next_state); - send!(client_tx, &MessageS2C::Goodbye { - reason: GoodbyeReason::UnexpectedNextState, - }).await?; + MessageC2S::Hello(pkt) => { + if !matches!(pkt.next_state.unwrap(), State::Play) { + error!("client sent unexpected state {:?} (expected: Play)", pkt.next_state); + let msg = MessageS2C::Goodbye(MessageS2CGoodbye { + reason: GoodbyeReason::UnexpectedNextState.into(), + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; break; } // check version - if version != PROTOCOL_VERSION { - error!("client sent incompatible version {} (expected: {})", version, PROTOCOL_VERSION); - send!(client_tx, &MessageS2C::Goodbye { - reason: GoodbyeReason::UnsupportedProtocol { - supported: PROTOCOL_VERSION, - got: version, - }, - }).await?; + if pkt.version != PROTOCOL_VERSION { + error!("client sent incompatible version {} (expected: {})", pkt.version, PROTOCOL_VERSION); + let msg = MessageS2C::Goodbye(MessageS2CGoodbye { + reason: GoodbyeReason::UnsupportedProtocol.into(), + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; break; } // determine if we can give them that username { - if mgr.usernames.read().await.values().any(|u| *u == requested_username) { - error!("client requested username {} but it is in use", requested_username); - send!(client_tx, &MessageS2C::Goodbye { - reason: GoodbyeReason::UsernameTaken, - }).await?; + if mgr.usernames.read().await.values().any(|u| *u == pkt.requested_username) { + error!("client requested username {} but it is in use", pkt.requested_username); + let msg: Vec = MessageS2C::Goodbye(MessageS2CGoodbye { + reason: GoodbyeReason::UsernameTaken.into(), + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; break; } } // username is fine { - mgr.usernames.write().await.insert(remote_addr, requested_username.clone()); + mgr.usernames.write().await.insert(remote_addr, pkt.requested_username.clone()); } - send!(client_tx, &MessageS2C::Hello { - version, - given_username: requested_username.clone(), - next_state, - }).await?; + let msg = MessageS2C::Hello(MessageS2CHello { + version: pkt.version, + given_username: pkt.requested_username.clone(), + special_fields: Default::default(), + next_state: pkt.next_state, + }).try_into()?; - state = next_state; - username = requested_username; + send!(client_tx, msg).await?; + + state = pkt.next_state.unwrap(); + username = pkt.requested_username; // make player rigidbody { @@ -134,15 +150,17 @@ pub async fn handle_client(mgr: ClientManager, data: Arc>, r mgr.players.write().await.insert(remote_addr, Player { handle: player_handle }); } }, - MessageC2S::Goodbye { reason } => { - info!("client sent goodbye: {:?}", reason); + MessageC2S::Goodbye(pkt) => { + info!("client sent goodbye: {:?}", pkt.reason); break; }, _ => { error!("client sent unexpected packet {:?} for state {:?}", pkt, state); - send!(client_tx, &MessageS2C::Goodbye { - reason: GoodbyeReason::UnexpectedPacket, - }).await?; + let msg = MessageS2C::Goodbye(MessageS2CGoodbye { + reason: GoodbyeReason::UnexpectedPacket.into(), + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; break; } } @@ -151,20 +169,22 @@ pub async fn handle_client(mgr: ClientManager, data: Arc>, r match pkt { MessageC2S::Hello { .. } => { error!("client sent unexpected packet {:?} for state {:?}", pkt, state); - send!(client_tx, &MessageS2C::Goodbye { - reason: GoodbyeReason::UnexpectedPacket, - }).await?; + let msg = MessageS2C::Goodbye(MessageS2CGoodbye { + reason: GoodbyeReason::UnexpectedPacket.into(), + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; break; }, - MessageC2S::Goodbye { reason } => { - info!("client sent goodbye: {:?}", reason); + MessageC2S::Goodbye(pkt) => { + info!("client sent goodbye: {:?}", pkt.reason); break; }, - MessageC2S::Chat { message } => { - info!("[{}] CHAT: [{}] {}", remote_addr, username, message); + MessageC2S::Chat(pkt) => { + info!("[{}] CHAT: [{}] {}", remote_addr, username, pkt.message); for (_addr, client_thread) in mgr.handlers.read().await.iter() { - match client_thread.tx.send(ClientHandlerMessage::ChatMessage { from: username.clone(), message: message.clone() }).await { + match client_thread.tx.send(ClientHandlerMessage::ChatMessage { from: username.clone(), message: pkt.message.clone() }).await { Ok(_) => (), Err(e) => { error!("unable to update a client thread: {}", e); @@ -172,8 +192,11 @@ pub async fn handle_client(mgr: ClientManager, data: Arc>, r } } }, - MessageC2S::Ping {} => { - send!(client_tx, &MessageS2C::Pong {}).await?; + MessageC2S::Ping(_) => { + let msg = MessageS2C::Pong(MessageS2CPong { + special_fields: Default::default(), + }).try_into()?; + send!(client_tx, msg).await?; ping_timeout = SystemTime::now() + Duration::from_secs(10); } } diff --git a/server/src/macros.rs b/server/src/macros.rs index c4420ece3ab21070aba3f4be1bcb1946db4b8799..56a3e2dccd8f87a095fe6236b9d76b5c488deea7 100644 --- a/server/src/macros.rs +++ b/server/src/macros.rs @@ -1,13 +1,16 @@ -use serde::{Serialize}; use tungstenite::Message; #[macro_export] macro_rules! send { ($writer:expr,$pkt:expr) => { - $writer.send($crate::macros::__generic_packet_to_message($pkt).unwrap()) + $writer.send($crate::macros::_generic_pkt_into($pkt)) }; } +pub fn _generic_pkt_into(p: Vec) -> Message { + Message::from(p) +} + #[macro_export] macro_rules! recv { ($reader:expr) => { @@ -17,7 +20,7 @@ macro_rules! recv { match msg { Ok(msg) => { if msg.is_binary() { - match rmp_serde::from_slice(&msg.into_data()) { + match MessageC2S::try_from(msg.into_data().as_slice()) { Ok(d) => Ok(Some(d)), Err(e) => { log::error!("error deserializing message: {}", e); @@ -52,7 +55,7 @@ macro_rules! recv_now { match msg { Ok(msg) => { if msg.is_binary() { - match rmp_serde::from_slice(&msg.into_data()) { + match MessageC2S::try_from(&msg.into_data()) { Ok(d) => Ok(Some(d)), Err(e) => { log::error!("error deserializing message: {}", e); @@ -74,8 +77,4 @@ macro_rules! recv_now { } } }; -} - -pub fn __generic_packet_to_message(pkt: &T) -> Result { - rmp_serde::to_vec(&pkt).map(Message::from) } \ No newline at end of file diff --git a/server/src/main.rs b/server/src/main.rs index df2e5bd5d730c04ebe152ff870572463b19b41ff..0ecff410e119cd116b262f08aa80a35e6fdfc5e2 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -6,7 +6,7 @@ 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 rapier2d_f64::prelude::{MultibodyJointSet, ImpulseJointSet, ColliderSet, RigidBodySet, NarrowPhase, BroadPhase, IslandManager, CCDSolver, IntegrationParameters}; use tokio_tungstenite::WebSocketStream; use tungstenite::{handshake}; use futures::stream::StreamExt; diff --git a/server/src/manager.rs b/server/src/manager.rs index 215519f694e35a92afd2d0cb2790bcd9cb8ba25c..3b246bc69d70b6941d0a0964507b9ca0b34c0e40 100644 --- a/server/src/manager.rs +++ b/server/src/manager.rs @@ -1,11 +1,8 @@ use std::collections::HashMap; - use std::net::SocketAddr; use std::sync::Arc; - use rapier2d_f64::na::{Vector2}; use rapier2d_f64::prelude::{IntegrationParameters, PhysicsPipeline, IslandManager, BroadPhase, NarrowPhase, ImpulseJointSet, MultibodyJointSet, CCDSolver, RigidBodySet, ColliderSet, RigidBodyHandle}; -use starkingdoms_protocol::{ProtocolPlanet, ProtocolPlayer}; use tokio::sync::mpsc::Sender; use tokio::sync::RwLock; @@ -61,6 +58,6 @@ impl PhysicsData { pub enum ClientHandlerMessage { Tick, ChatMessage { from: String, message: String }, - PlayersUpdate { players: Vec }, - PlanetData { planets: Vec }, + PlayersUpdate { players: Vec }, + PlanetData { planets: Vec }, } diff --git a/server/src/planet.rs b/server/src/planet.rs index 04e425aa1eb8871a231fd994f109336bea058d4c..310d1b1ba92d05bb5a0af0a0cddc114f4a70614a 100644 --- a/server/src/planet.rs +++ b/server/src/planet.rs @@ -1,6 +1,6 @@ use nalgebra::{Vector2, vector}; use rapier2d_f64::prelude::{RigidBodyHandle, RigidBodySet, ColliderBuilder, RigidBodyBuilder, ColliderSet}; -use starkingdoms_protocol::{PlanetType, ProtocolPlanet}; +use starkingdoms_protocol::planet::PlanetType; use crate::{SCALE, manager::ClientHandlerMessage}; @@ -71,11 +71,13 @@ impl Planets { let mut planets = vec![]; for planet in self.planets.clone() { - planets.push(ProtocolPlanet { - planet_type: planet.planet_type, - x: planet.position.0 * SCALE, - y: planet.position.1 * SCALE, - radius: planet.radius, // DO NOT * SCALE + // TODO: Adjust codegen to use f64 + planets.push(starkingdoms_protocol::planet::Planet { + planet_type: planet.planet_type.into(), + x: (planet.position.0 * SCALE) as f32, + y: (planet.position.1 * SCALE) as f32, + radius: planet.radius as f32, // DO NOT * SCALE + special_fields: Default::default(), }); } diff --git a/server/src/timer.rs b/server/src/timer.rs index eb6df7c18bdf831763b99e5c68f1d31c74b37955..6cd850376520bdb05f9a437f08dc72bab11a6034 100644 --- a/server/src/timer.rs +++ b/server/src/timer.rs @@ -1,11 +1,9 @@ - use std::{time::Duration, sync::Arc}; use log::{error}; - use nalgebra::vector; -use rapier2d_f64::prelude::{PhysicsPipeline, RigidBodyHandle}; -use starkingdoms_protocol::{ProtocolPlanet, PlanetType, ProtocolPlayer}; +use rapier2d_f64::prelude::{PhysicsPipeline}; use tokio::{time::sleep, sync::RwLock}; +use starkingdoms_protocol::player::Player; use crate::{manager::{ClientHandlerMessage, ClientManager, PhysicsData}, SCALE, planet::Planets}; pub async fn timer_main(mgr: ClientManager, physics_data: Arc>, world_data: Arc>) { @@ -35,11 +33,13 @@ pub async fn timer_main(mgr: ClientManager, physics_data: Arc