4 files changed, 28 insertions(+), 100 deletions(-)

M crates/unified/src/shared/ecs.rs
M crates/unified/src/shared/net.rs
M crates/unified/src/shared/plugins.rs
M crates/unified/src/shared/thrust.rs

@@ 44,13 44,13 @@ pub struct Player {
     pub client: Entity,
 }
 
-#[derive(Message, Debug, Clone, Serialize, Deserialize, TypePath)]
+#[derive(Message, Debug, Clone)]
 pub struct DragRequestEvent {
     pub drag_target: Entity,
     pub action: DragAction,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub enum DragAction {
     Attach { snap_target: Entity, peer_snap: Entity },
     Free   { position: Vec2, rotation: Quat },


@@ 66,7 66,7 @@ pub struct PlayerStorage {
 
 #[derive(Component, Serialize, Deserialize, Debug)]
 pub struct CanCraft;
-#[derive(Message, Debug, Clone, Serialize, Deserialize, TypePath)]
+#[derive(Message, Debug, Clone)]
 pub struct CraftPartRequest {
     pub crafting_part: Entity,
     pub crafted_part: String,


@@ 92,7 92,7 @@ pub struct Drill {
     pub resource_multiplier: f32,
     pub on_planet: Option<String>,
 }
-#[derive(Message, Debug, Clone, Serialize, Deserialize, TypePath)]
+#[derive(Message, Debug, Clone)]
 pub struct ToggleDrillEvent {
     pub drill_entity: Entity,
 }

@@ 12,12 12,11 @@ use bevy::ecs::system::SystemState;
 use bevy::prelude::*;
 use postcard::{from_bytes, to_allocvec, to_slice, to_vec};
 use crate::prelude::{App, Message};
-use crate::shared::thrust::ThrustSolution;
 //use bevy_replicon::prelude::*;
 use serde::{Deserialize, Serialize};
 use crate::shared::attachment::{Joint, JointOf, PartInShip, Peer, Ship, SnapOf, SnapOfJoint};
 use crate::shared::config::planet::{Planet, PlanetSpring, PlanetSpringJoint};
-use crate::shared::ecs::{CanCraft, CraftPartRequest, DragRequestEvent, Drill, Part, Player, PlayerStorage, SingleStorage, Temperature, ToggleDrillEvent};
+use crate::shared::ecs::{CanCraft, Drill, Part, Player, PlayerStorage, SingleStorage, Temperature};
 use crate::shared::ecs::thruster::{Thruster, ThrusterOfPart};
 
 


@@ 60,13 59,14 @@ use crate::shared::ecs::thruster::{Thruster, ThrusterOfPart};
 }*/
 
 pub fn register_net(app: &mut App) {
-    app
-        .add_server_message::<Hi>()
-
-        .add_client_message::<DragRequestEvent>()
-        .add_client_message::<ToggleDrillEvent>()
-        .add_client_message::<CraftPartRequest>()
-        .add_client_message::<ThrustSolution>();
+    /*app
+        .add_message::<ToClients<Hi>>()
+        .add_message::<Hi>()
+        .add_systems(Update, send_hi_to_client);*/
+}
+pub fn setup_net(app: &mut App) {
+    app.insert_resource(MessageRegistry::default());
+    app.add_systems(PostUpdate, recv_from_server);
 }
 
 #[derive(Message, Deserialize, Serialize, TypePath, MapEntities)]


@@ 76,24 76,12 @@ pub struct Hi {
     pub time_offset: f64,
 }
 
-pub fn setup_net(app: &mut App) {
-    app.insert_resource(ServerMessageRegistry::default());
-    app.insert_resource(ClientMessageRegistry::default());
-    app.add_systems(PostUpdate, recv_from_server);
-    app.add_systems(PostUpdate, recv_from_client);
-}
 #[derive(Message, Deref, Deserialize, Serialize)]
 pub struct ToClients<T: Message + TypePath> {
     #[deref]
     pub message: T,
     pub targets: SendTargets,
 }
-#[derive(Message, Deref, Deserialize, Serialize)]
-pub struct FromClients<T: Message + TypePath> {
-    pub client_id: ClientId,
-    #[deref]
-    pub message: T,
-}
 
 #[derive(Deserialize, Serialize)]
 pub enum SendTargets {


@@ 108,15 96,10 @@ pub enum ClientId {
 }
 
 #[derive(Resource, Default)]
-pub struct ServerMessageRegistry {
+pub struct MessageRegistry {
     forward: HashMap<String, LaneIndex>,
     reverse: HashMap<LaneIndex, fn(Vec<u8>, &mut World)>,
 }
-#[derive(Resource, Default)]
-pub struct ClientMessageRegistry {
-    forward: HashMap<String, LaneIndex>,
-    reverse: HashMap<LaneIndex, fn(Vec<u8>, ClientId, &mut World)>,
-}
 
 static COUNTER: AtomicU32 = AtomicU32::new(0);
 fn get_lane_index() -> LaneIndex {


@@ 124,47 107,29 @@ fn get_lane_index() -> LaneIndex {
 }
 
 pub trait NetAppExt {
-    fn add_server_message<T: Message + TypePath + Serialize + for<'a> Deserialize<'a>>(&mut self) -> &mut Self;
-    fn add_client_message<T: Message + TypePath + Serialize + for<'a> Deserialize<'a>>(&mut self) -> &mut Self;
+    fn add_server_message<T: Clone + Message + TypePath + Serialize + for<'a> Deserialize<'a>>(&mut self) -> &mut Self;
 }
 impl NetAppExt for App {
-    fn add_server_message<T: Message + TypePath + Serialize + for<'a> Deserialize<'a>>(&mut self) -> &mut Self {
+    fn add_server_message<T: Clone + Message + TypePath + Serialize + for<'a> Deserialize<'a>>(&mut self) -> &mut Self {
         self
             .add_message::<ToClients<T>>()
             .add_message::<T>()
-            .add_systems(Startup, register_server_message::<T>)
+            .add_systems(Startup, register_message::<T>)
             .add_systems(Update, send_to_client::<T>)
     }
-    fn add_client_message<T: Message + TypePath + Serialize + for<'a> Deserialize<'a>>(&mut self) -> &mut Self {
-        self
-            .add_message::<FromClients<T>>()
-            .add_message::<T>()
-            .add_systems(Startup, register_client_message::<T>)
-            .add_systems(Update, send_to_server::<T>)
-    }
 }
-fn register_server_message<T: Message + TypePath + for<'a> Deserialize<'a>>(mut registry: ResMut<ServerMessageRegistry>) {
+fn register_message<T: Message + TypePath + for<'a> Deserialize<'a>>(mut registry: ResMut<MessageRegistry>) {
     registry.forward.insert(T::type_path().to_string(), get_lane_index());
     registry.reverse.insert(get_lane_index(), |payload: Vec<u8>, world: &mut World| {
         let message = from_bytes::<T>(&payload).expect(&format!("Failed to deserialize message of type {}", T::type_path()));
         world.write_message(message).expect("Could not send message to game");
     });
 }
-fn register_client_message<T: Message + TypePath + for<'a> Deserialize<'a>>(mut registry: ResMut<ClientMessageRegistry>) {
-    registry.forward.insert(T::type_path().to_string(), get_lane_index());
-    registry.reverse.insert(get_lane_index(), |payload: Vec<u8>, client_id: ClientId, world: &mut World| {
-        let message = from_bytes::<T>(&payload).expect(&format!("Failed to deserialize message of type {}", T::type_path()));
-        world.write_message(FromClients {
-            client_id,
-            message,
-        }).expect("Could not send message to game");
-    });
-}
 
-fn send_to_client<M: Message + TypePath + Serialize>(
+fn send_to_client<M: Clone + Message + TypePath + Serialize>(
     mut messages: MessageReader<ToClients<M>>,
     mut clients: Query<(Entity, &mut Transport), With<ChildOf>>,
-    message_registry: Res<ServerMessageRegistry>,
+    message_registry: Res<MessageRegistry>,
 ) {
     for message in messages.read() {
         match &message.targets {


@@ 193,28 158,12 @@ fn send_to_client<M: Message + TypePath + Serialize>(
         }
     }
 }
-fn send_to_server<M: Message + TypePath + Serialize>(
-    mut messages: MessageReader<M>,
-    mut sessions: Query<&mut Transport, Without<ChildOf>>,
-    message_registry: Res<ClientMessageRegistry>,
-) {
-    for message in messages.read() {
-        for mut transport in &mut sessions {
-            transport.send.push(
-                *message_registry.forward.get(M::type_path())
-                    .expect("Failed to get message lane; the message likely isn't serialized yet"),
-                to_allocvec(&message).expect("Failed to serialize message").into(),
-                Instant::now(),
-            ).expect("Failed to send message");
-        }
-    }
-}
 fn recv_from_server(
     world: &mut World
 ) {
     let mut system_state: SystemState<(
         Query<&mut Transport, Without<ChildOf>>,
-        Res<ServerMessageRegistry>,
+        Res<MessageRegistry>,
     )> = SystemState::new(world);
     let (mut sessions, message_registry) = system_state.get_mut(world);
     let mut messages = Vec::new();


@@ 232,26 181,3 @@ fn recv_from_server(
         message_fn(payload, world);
     }
 }
-fn recv_from_client(
-    world: &mut World
-) {
-    let mut system_state: SystemState<(
-        Query<(Entity, &mut Transport), With<ChildOf>>,
-        Res<ClientMessageRegistry>,
-    )> = SystemState::new(world);
-    let (mut clients, message_registry) = system_state.get_mut(world);
-    let mut messages = Vec::new();
-    for (client_entity, mut transport) in clients.iter_mut() {
-        for message in transport.recv.msgs.drain() {
-            let payload = message.payload;
-            let message_fn = message_registry.reverse.get(&message.lane).expect("Packet was sent across a lane that didn't have a message assigned to it yet");
-            messages.push((payload, ClientId::Client(client_entity), *message_fn));
-        }
-        for _ in transport.recv.acks.drain() {
-
-        }
-    }
-    for (payload, client_id, message_fn) in messages {
-        message_fn(payload, client_id, world);
-    }
-}

@@ 1,6 1,6 @@
 use aeronet_transport::AeronetTransportPlugin;
 use crate::shared::ecs::{CraftPartRequest, DragRequestEvent, TimeOffset, ToggleDrillEvent};
-use crate::shared::net::{register_net, setup_net};
+use crate::shared::net::register_net;
 use crate::shared::thrust::ThrustSolution;
 use bevy::app::{App, PluginGroup, PluginGroupBuilder};
 use bevy::diagnostic::DiagnosticsPlugin;


@@ 42,7 42,6 @@ impl PluginGroup for SharedPluginGroup {
             .add(physics_setup_plugin)
             //.add(register_replication)
             .add(register_everything)
-            .add(setup_net)
             .add(register_net)
             .add(world_config_plugin)
 


@@ 55,6 54,10 @@ impl PluginGroup for SharedPluginGroup {
 }
 
 pub fn register_everything(app: &mut App) {
+    app.add_message::<DragRequestEvent>();
+    app.add_message::<ToggleDrillEvent>();
+    app.add_message::<CraftPartRequest>();
+    app.add_message::<ThrustSolution>();
 }
 
 fn physics_setup_plugin(app: &mut App) {

@@ 1,11 1,10 @@
 use std::collections::BTreeSet;
-use bevy::{prelude::{Component, Entity, Message, Resource}, reflect::TypePath};
-use serde::{Deserialize, Serialize};
+use bevy::prelude::{Component, Entity, Message, Resource};
 
 /// A thrust solution, found by the thrust solver on the client.
 /// `thrusters_on` is the set of thrusters that should be on.
 /// Any thrusters not in this set should be off.
-#[derive(Eq, PartialEq, Debug, Clone, Resource, Component, Message, Serialize, Deserialize, TypePath)]
+#[derive(Eq, PartialEq, Debug, Clone, Resource, Component, Message)]
 pub struct ThrustSolution {
     pub thrusters_on: BTreeSet<Entity>,
     pub converged: bool