From 4279d28c2cf5a79370990b2e8dd30e07f38e8ec2 Mon Sep 17 00:00:00 2001
From: starwolf <ramses@starwolves.io>
Date: Mon, 1 Jan 2024 21:25:54 +0100
Subject: [PATCH 1/6] Support custom schedules.

---
 bevy_renet/examples/simple.rs |  8 ++---
 bevy_renet/src/lib.rs         | 55 ++++++++++++++++++++++++++++++-----
 bevy_renet/src/steam.rs       | 42 +++++++++++++++++++++-----
 bevy_renet/src/transport.rs   | 43 ++++++++++++++++++++++-----
 demo_bevy/src/bin/client.rs   |  2 +-
 demo_bevy/src/bin/server.rs   |  2 +-
 6 files changed, 124 insertions(+), 28 deletions(-)

diff --git a/bevy_renet/examples/simple.rs b/bevy_renet/examples/simple.rs
index 5244b526..991126f3 100644
--- a/bevy_renet/examples/simple.rs
+++ b/bevy_renet/examples/simple.rs
@@ -98,8 +98,8 @@ fn main() {
     app.init_resource::<Lobby>();
 
     if is_host {
-        app.add_plugins(RenetServerPlugin);
-        app.add_plugins(NetcodeServerPlugin);
+        app.add_plugins(RenetServerPlugin::default());
+        app.add_plugins(NetcodeServerPlugin::default());
         let (server, transport) = new_renet_server();
         app.insert_resource(server);
         app.insert_resource(transport);
@@ -109,8 +109,8 @@ fn main() {
             (server_update_system, server_sync_players, move_players_system).run_if(resource_exists::<RenetServer>()),
         );
     } else {
-        app.add_plugins(RenetClientPlugin);
-        app.add_plugins(NetcodeClientPlugin);
+        app.add_plugins(RenetClientPlugin::default());
+        app.add_plugins(NetcodeClientPlugin::default());
         app.init_resource::<PlayerInput>();
         let (client, transport) = new_renet_client();
         app.insert_resource(client);
diff --git a/bevy_renet/src/lib.rs b/bevy_renet/src/lib.rs
index d76b1103..cfe8c39f 100644
--- a/bevy_renet/src/lib.rs
+++ b/bevy_renet/src/lib.rs
@@ -1,6 +1,6 @@
 pub use renet;
 
-use bevy::prelude::*;
+use bevy::{ecs::schedule::ScheduleLabel, prelude::*, utils::intern::Interned};
 
 use renet::{RenetClient, RenetServer, ServerEvent};
 
@@ -27,21 +27,56 @@ pub struct RenetReceive;
 /// This system set runs in PostUpdate.
 #[derive(Debug, SystemSet, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct RenetSend;
+#[derive(Debug, SystemSet, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum CoreSet {
+    Pre,
+    Post,
+}
 
-pub struct RenetServerPlugin;
+pub struct RenetServerPlugin {
+    pub pre_schedule: Interned<dyn ScheduleLabel>,
+    pub post_schedule: Interned<dyn ScheduleLabel>,
+}
 
-pub struct RenetClientPlugin;
+pub struct RenetClientPlugin {
+    pub pre_schedule: Interned<dyn ScheduleLabel>,
+    pub post_schedule: Interned<dyn ScheduleLabel>,
+}
+
+impl Default for RenetServerPlugin {
+    fn default() -> Self {
+        Self {
+            pre_schedule: PreUpdate.intern(),
+            post_schedule: PostUpdate.intern(),
+        }
+    }
+}
+impl Default for RenetClientPlugin {
+    fn default() -> Self {
+        Self {
+            pre_schedule: PreUpdate.intern(),
+            post_schedule: PostUpdate.intern(),
+        }
+    }
+}
 
 impl Plugin for RenetServerPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<Events<ServerEvent>>();
-        app.add_systems(PreUpdate, Self::update_system.run_if(resource_exists::<RenetServer>()));
         app.add_systems(
-            PreUpdate,
+            self.pre_schedule,
+            Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetServer>()),
+        );
+        app.add_systems(
+            self.pre_schedule,
             Self::emit_server_events_system
                 .run_if(resource_exists::<RenetServer>())
-                .after(Self::update_system),
+                .after(Self::update_system)
+                .in_set(CoreSet::Pre),
         );
+        if self.post_schedule == self.pre_schedule {
+            app.configure_sets(self.post_schedule, (CoreSet::Pre, CoreSet::Post));
+        }
     }
 }
 
@@ -59,7 +94,13 @@ impl RenetServerPlugin {
 
 impl Plugin for RenetClientPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(PreUpdate, Self::update_system.run_if(resource_exists::<RenetClient>()));
+        app.add_systems(
+            self.pre_schedule,
+            Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetClient>()),
+        );
+        if self.post_schedule == self.pre_schedule {
+            app.configure_sets(self.post_schedule, (CoreSet::Pre, CoreSet::Post));
+        }
     }
 }
 
diff --git a/bevy_renet/src/steam.rs b/bevy_renet/src/steam.rs
index d9b08efa..0e4deba3 100644
--- a/bevy_renet/src/steam.rs
+++ b/bevy_renet/src/steam.rs
@@ -6,9 +6,32 @@ use crate::{RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
 
 pub use renet_steam::{AccessPermission, SteamClientTransport, SteamServerConfig, SteamServerTransport};
 
-pub struct SteamServerPlugin;
+pub struct SteamServerPlugin {
+    pub pre_schedule: Interned<dyn ScheduleLabel>,
+    pub post_schedule: Interned<dyn ScheduleLabel>,
+}
+
+pub struct SteamClientPlugin {
+    pub pre_schedule: Interned<dyn ScheduleLabel>,
+    pub post_schedule: Interned<dyn ScheduleLabel>,
+}
 
-pub struct SteamClientPlugin;
+impl Default for SteamServerPlugin {
+    fn default() -> Self {
+        Self {
+            pre_schedule: PreUpdate.intern(),
+            post_schedule: PostUpdate.intern(),
+        }
+    }
+}
+impl Default for SteamClientPlugin {
+    fn default() -> Self {
+        Self {
+            pre_schedule: PreUpdate.intern(),
+            post_schedule: PostUpdate.intern(),
+        }
+    }
+}
 
 #[derive(Debug, Event)]
 pub struct SteamTransportError(pub SteamError);
@@ -22,17 +45,20 @@ impl std::fmt::Display for SteamTransportError {
 impl Plugin for SteamServerPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
-            PreUpdate,
+            self.pre_schedule,
             Self::update_system
                 .in_set(RenetReceive)
+                .in_set(CoreSet::Pre)
                 .run_if(resource_exists::<RenetServer>())
                 .after(RenetServerPlugin::update_system)
                 .before(RenetServerPlugin::emit_server_events_system),
         );
 
         app.add_systems(
-            PostUpdate,
-            (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit).run_if(resource_exists::<RenetServer>()),
+            self.post_schedule,
+            (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
+                .in_set(CoreSet::Post)
+                .run_if(resource_exists::<RenetServer>()),
         );
     }
 }
@@ -68,16 +94,18 @@ impl Plugin for SteamClientPlugin {
         app.add_event::<SteamTransportError>();
 
         app.add_systems(
-            PreUpdate,
+            self.pre_schedule,
             Self::update_system
                 .in_set(RenetReceive)
+                .in_set(CoreSet::Pre)
                 .run_if(resource_exists::<SteamClientTransport>())
                 .run_if(resource_exists::<RenetClient>())
                 .after(RenetClientPlugin::update_system),
         );
         app.add_systems(
-            PostUpdate,
+            self.post_schedule,
             (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
+                .in_set(CoreSet::Post)
                 .run_if(resource_exists::<SteamClientTransport>())
                 .run_if(resource_exists::<RenetClient>()),
         );
diff --git a/bevy_renet/src/transport.rs b/bevy_renet/src/transport.rs
index e1b451bd..80372ec2 100644
--- a/bevy_renet/src/transport.rs
+++ b/bevy_renet/src/transport.rs
@@ -3,22 +3,46 @@ use renet::{
     RenetClient, RenetServer,
 };
 
-use bevy::{app::AppExit, prelude::*};
+use bevy::{app::AppExit, ecs::schedule::ScheduleLabel, prelude::*, utils::intern::Interned};
 
-use crate::{RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
+use crate::{CoreSet, RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
 
-pub struct NetcodeServerPlugin;
+pub struct NetcodeServerPlugin {
+    pub pre_schedule: Interned<dyn ScheduleLabel>,
+    pub post_schedule: Interned<dyn ScheduleLabel>,
+}
+
+pub struct NetcodeClientPlugin {
+    pub pre_schedule: Interned<dyn ScheduleLabel>,
+    pub post_schedule: Interned<dyn ScheduleLabel>,
+}
 
-pub struct NetcodeClientPlugin;
+impl Default for NetcodeServerPlugin {
+    fn default() -> Self {
+        Self {
+            pre_schedule: PreUpdate.intern(),
+            post_schedule: PostUpdate.intern(),
+        }
+    }
+}
+impl Default for NetcodeClientPlugin {
+    fn default() -> Self {
+        Self {
+            pre_schedule: PreUpdate.intern(),
+            post_schedule: PostUpdate.intern(),
+        }
+    }
+}
 
 impl Plugin for NetcodeServerPlugin {
     fn build(&self, app: &mut App) {
         app.add_event::<NetcodeTransportError>();
 
         app.add_systems(
-            PreUpdate,
+            self.pre_schedule,
             Self::update_system
                 .in_set(RenetReceive)
+                .in_set(CoreSet::Pre)
                 .run_if(resource_exists::<NetcodeServerTransport>())
                 .run_if(resource_exists::<RenetServer>())
                 .after(RenetServerPlugin::update_system)
@@ -26,8 +50,9 @@ impl Plugin for NetcodeServerPlugin {
         );
 
         app.add_systems(
-            PostUpdate,
+            self.post_schedule,
             (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
+                .in_set(CoreSet::Post)
                 .run_if(resource_exists::<NetcodeServerTransport>())
                 .run_if(resource_exists::<RenetServer>()),
         );
@@ -62,16 +87,18 @@ impl Plugin for NetcodeClientPlugin {
         app.add_event::<NetcodeTransportError>();
 
         app.add_systems(
-            PreUpdate,
+            self.pre_schedule,
             Self::update_system
                 .in_set(RenetReceive)
+                .in_set(CoreSet::Pre)
                 .run_if(resource_exists::<NetcodeClientTransport>())
                 .run_if(resource_exists::<RenetClient>())
                 .after(RenetClientPlugin::update_system),
         );
         app.add_systems(
-            PostUpdate,
+            self.post_schedule,
             (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
+                .in_set(CoreSet::Post)
                 .run_if(resource_exists::<NetcodeClientTransport>())
                 .run_if(resource_exists::<RenetClient>()),
         );
diff --git a/demo_bevy/src/bin/client.rs b/demo_bevy/src/bin/client.rs
index c742929e..fd96361c 100644
--- a/demo_bevy/src/bin/client.rs
+++ b/demo_bevy/src/bin/client.rs
@@ -124,7 +124,7 @@ fn add_steam_network(app: &mut App) {
 fn main() {
     let mut app = App::new();
     app.add_plugins(DefaultPlugins);
-    app.add_plugins(RenetClientPlugin);
+    app.add_plugins(RenetClientPlugin::default());
     app.add_plugins(LookTransformPlugin);
     app.add_plugins(FrameTimeDiagnosticsPlugin);
     app.add_plugins(LogDiagnosticsPlugin::default());
diff --git a/demo_bevy/src/bin/server.rs b/demo_bevy/src/bin/server.rs
index c59ed34f..b9faf77f 100644
--- a/demo_bevy/src/bin/server.rs
+++ b/demo_bevy/src/bin/server.rs
@@ -89,7 +89,7 @@ fn main() {
     let mut app = App::new();
     app.add_plugins(DefaultPlugins);
 
-    app.add_plugins(RenetServerPlugin);
+    app.add_plugins(RenetServerPlugin::default());
     app.add_plugins(FrameTimeDiagnosticsPlugin);
     app.add_plugins(LogDiagnosticsPlugin::default());
     app.add_plugins(EguiPlugin);

From 6ef0a1969fb6923a0c18645bb217aadaec4c4667 Mon Sep 17 00:00:00 2001
From: starwolf <ramses@starwolves.io>
Date: Mon, 1 Jan 2024 21:38:07 +0100
Subject: [PATCH 2/6] Structure passed schedules.

---
 bevy_renet/src/lib.rs       | 45 +++++++++++++++++--------------------
 bevy_renet/src/steam.rs     |  6 ++---
 bevy_renet/src/transport.rs | 39 +++++++++-----------------------
 3 files changed, 32 insertions(+), 58 deletions(-)

diff --git a/bevy_renet/src/lib.rs b/bevy_renet/src/lib.rs
index cfe8c39f..d475e591 100644
--- a/bevy_renet/src/lib.rs
+++ b/bevy_renet/src/lib.rs
@@ -33,49 +33,44 @@ pub enum CoreSet {
     Post,
 }
 
-pub struct RenetServerPlugin {
-    pub pre_schedule: Interned<dyn ScheduleLabel>,
-    pub post_schedule: Interned<dyn ScheduleLabel>,
-}
-
-pub struct RenetClientPlugin {
-    pub pre_schedule: Interned<dyn ScheduleLabel>,
-    pub post_schedule: Interned<dyn ScheduleLabel>,
+pub struct NetSchedules {
+    pub pre: Interned<dyn ScheduleLabel>,
+    pub post: Interned<dyn ScheduleLabel>,
 }
 
-impl Default for RenetServerPlugin {
+impl Default for NetSchedules {
     fn default() -> Self {
         Self {
-            pre_schedule: PreUpdate.intern(),
-            post_schedule: PostUpdate.intern(),
+            pre: PreUpdate.intern(),
+            post: PostUpdate.intern(),
         }
     }
 }
-impl Default for RenetClientPlugin {
-    fn default() -> Self {
-        Self {
-            pre_schedule: PreUpdate.intern(),
-            post_schedule: PostUpdate.intern(),
-        }
-    }
+#[derive(Default)]
+pub struct RenetServerPlugin {
+    pub schedules: NetSchedules,
+}
+#[derive(Default)]
+pub struct RenetClientPlugin {
+    pub schedules: NetSchedules,
 }
 
 impl Plugin for RenetServerPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<Events<ServerEvent>>();
         app.add_systems(
-            self.pre_schedule,
+            self.schedules.pre,
             Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetServer>()),
         );
         app.add_systems(
-            self.pre_schedule,
+            self.schedules.pre,
             Self::emit_server_events_system
                 .run_if(resource_exists::<RenetServer>())
                 .after(Self::update_system)
                 .in_set(CoreSet::Pre),
         );
-        if self.post_schedule == self.pre_schedule {
-            app.configure_sets(self.post_schedule, (CoreSet::Pre, CoreSet::Post));
+        if self.schedules.post == self.schedules.pre {
+            app.configure_sets(self.schedules.post, (CoreSet::Pre, CoreSet::Post));
         }
     }
 }
@@ -95,11 +90,11 @@ impl RenetServerPlugin {
 impl Plugin for RenetClientPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
-            self.pre_schedule,
+            self.schedules.pre,
             Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetClient>()),
         );
-        if self.post_schedule == self.pre_schedule {
-            app.configure_sets(self.post_schedule, (CoreSet::Pre, CoreSet::Post));
+        if self.schedules.post == self.schedules.pre {
+            app.configure_sets(self.schedules.post, (CoreSet::Pre, CoreSet::Post));
         }
     }
 }
diff --git a/bevy_renet/src/steam.rs b/bevy_renet/src/steam.rs
index 0e4deba3..136a6147 100644
--- a/bevy_renet/src/steam.rs
+++ b/bevy_renet/src/steam.rs
@@ -7,13 +7,11 @@ use crate::{RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
 pub use renet_steam::{AccessPermission, SteamClientTransport, SteamServerConfig, SteamServerTransport};
 
 pub struct SteamServerPlugin {
-    pub pre_schedule: Interned<dyn ScheduleLabel>,
-    pub post_schedule: Interned<dyn ScheduleLabel>,
+    pub schedules: NetSchedules,
 }
 
 pub struct SteamClientPlugin {
-    pub pre_schedule: Interned<dyn ScheduleLabel>,
-    pub post_schedule: Interned<dyn ScheduleLabel>,
+    pub schedules: NetSchedules,
 }
 
 impl Default for SteamServerPlugin {
diff --git a/bevy_renet/src/transport.rs b/bevy_renet/src/transport.rs
index 80372ec2..f7013684 100644
--- a/bevy_renet/src/transport.rs
+++ b/bevy_renet/src/transport.rs
@@ -3,35 +3,16 @@ use renet::{
     RenetClient, RenetServer,
 };
 
-use bevy::{app::AppExit, ecs::schedule::ScheduleLabel, prelude::*, utils::intern::Interned};
-
-use crate::{CoreSet, RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
+use bevy::{app::AppExit, prelude::*};
 
+use crate::{CoreSet, NetSchedules, RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
+#[derive(Default)]
 pub struct NetcodeServerPlugin {
-    pub pre_schedule: Interned<dyn ScheduleLabel>,
-    pub post_schedule: Interned<dyn ScheduleLabel>,
+    pub schedules: NetSchedules,
 }
-
+#[derive(Default)]
 pub struct NetcodeClientPlugin {
-    pub pre_schedule: Interned<dyn ScheduleLabel>,
-    pub post_schedule: Interned<dyn ScheduleLabel>,
-}
-
-impl Default for NetcodeServerPlugin {
-    fn default() -> Self {
-        Self {
-            pre_schedule: PreUpdate.intern(),
-            post_schedule: PostUpdate.intern(),
-        }
-    }
-}
-impl Default for NetcodeClientPlugin {
-    fn default() -> Self {
-        Self {
-            pre_schedule: PreUpdate.intern(),
-            post_schedule: PostUpdate.intern(),
-        }
-    }
+    pub schedules: NetSchedules,
 }
 
 impl Plugin for NetcodeServerPlugin {
@@ -39,7 +20,7 @@ impl Plugin for NetcodeServerPlugin {
         app.add_event::<NetcodeTransportError>();
 
         app.add_systems(
-            self.pre_schedule,
+            self.schedules.pre,
             Self::update_system
                 .in_set(RenetReceive)
                 .in_set(CoreSet::Pre)
@@ -50,7 +31,7 @@ impl Plugin for NetcodeServerPlugin {
         );
 
         app.add_systems(
-            self.post_schedule,
+            self.schedules.post,
             (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
                 .in_set(CoreSet::Post)
                 .run_if(resource_exists::<NetcodeServerTransport>())
@@ -87,7 +68,7 @@ impl Plugin for NetcodeClientPlugin {
         app.add_event::<NetcodeTransportError>();
 
         app.add_systems(
-            self.pre_schedule,
+            self.schedules.pre,
             Self::update_system
                 .in_set(RenetReceive)
                 .in_set(CoreSet::Pre)
@@ -96,7 +77,7 @@ impl Plugin for NetcodeClientPlugin {
                 .after(RenetClientPlugin::update_system),
         );
         app.add_systems(
-            self.post_schedule,
+            self.schedules.post,
             (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
                 .in_set(CoreSet::Post)
                 .run_if(resource_exists::<NetcodeClientTransport>())

From 559e9b1f09968ba4c8642fd10a0a1d8650f8178b Mon Sep 17 00:00:00 2001
From: starwolf <ramses@starwolves.io>
Date: Mon, 1 Jan 2024 21:46:45 +0100
Subject: [PATCH 3/6] NetSchedules derive clone and copy.

---
 bevy_renet/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bevy_renet/src/lib.rs b/bevy_renet/src/lib.rs
index d475e591..d5d7717c 100644
--- a/bevy_renet/src/lib.rs
+++ b/bevy_renet/src/lib.rs
@@ -32,7 +32,7 @@ pub enum CoreSet {
     Pre,
     Post,
 }
-
+#[derive(Clone, Copy)]
 pub struct NetSchedules {
     pub pre: Interned<dyn ScheduleLabel>,
     pub post: Interned<dyn ScheduleLabel>,

From 666330f30ea59cffd66b7c61df7988716255f71f Mon Sep 17 00:00:00 2001
From: starwolf <ramses@starwolves.io>
Date: Mon, 1 Jan 2024 21:53:25 +0100
Subject: [PATCH 4/6] Chain CoreSet in the right plugins.

---
 bevy_renet/src/lib.rs       | 6 ------
 bevy_renet/src/transport.rs | 6 ++++++
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/bevy_renet/src/lib.rs b/bevy_renet/src/lib.rs
index d5d7717c..d9a3e7ad 100644
--- a/bevy_renet/src/lib.rs
+++ b/bevy_renet/src/lib.rs
@@ -69,9 +69,6 @@ impl Plugin for RenetServerPlugin {
                 .after(Self::update_system)
                 .in_set(CoreSet::Pre),
         );
-        if self.schedules.post == self.schedules.pre {
-            app.configure_sets(self.schedules.post, (CoreSet::Pre, CoreSet::Post));
-        }
     }
 }
 
@@ -93,9 +90,6 @@ impl Plugin for RenetClientPlugin {
             self.schedules.pre,
             Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetClient>()),
         );
-        if self.schedules.post == self.schedules.pre {
-            app.configure_sets(self.schedules.post, (CoreSet::Pre, CoreSet::Post));
-        }
     }
 }
 
diff --git a/bevy_renet/src/transport.rs b/bevy_renet/src/transport.rs
index f7013684..5bffc1f5 100644
--- a/bevy_renet/src/transport.rs
+++ b/bevy_renet/src/transport.rs
@@ -37,6 +37,9 @@ impl Plugin for NetcodeServerPlugin {
                 .run_if(resource_exists::<NetcodeServerTransport>())
                 .run_if(resource_exists::<RenetServer>()),
         );
+        if self.schedules.post == self.schedules.pre {
+            app.configure_sets(self.schedules.post, (CoreSet::Pre, CoreSet::Post).chain());
+        }
     }
 }
 
@@ -83,6 +86,9 @@ impl Plugin for NetcodeClientPlugin {
                 .run_if(resource_exists::<NetcodeClientTransport>())
                 .run_if(resource_exists::<RenetClient>()),
         );
+        if self.schedules.post == self.schedules.pre {
+            app.configure_sets(self.schedules.post, (CoreSet::Pre, CoreSet::Post).chain());
+        }
     }
 }
 

From 32607904219f8140ba9a5d6c5b9dcb43a6e1e134 Mon Sep 17 00:00:00 2001
From: starwolf <ramses@starwolves.io>
Date: Tue, 12 Mar 2024 17:44:10 +0100
Subject: [PATCH 5/6] Update to 0.13 .

---
 README.md                                     |   4 +-
 bevy_renet/Cargo.toml                         |  14 +--
 bevy_renet/README.md                          |   1 +
 bevy_renet/examples/simple.rs                 |  28 ++---
 bevy_renet/src/lib.rs                         |  52 ++++----
 bevy_renet/src/transport.rs                   |  38 +++---
 demo_bevy/Cargo.toml                          |  25 ++--
 demo_bevy/src/bin/client.rs                   |  48 +++-----
 demo_bevy/src/bin/server.rs                   |  13 +-
 demo_bevy/src/lib.rs                          |  16 +--
 demo_chat/Cargo.toml                          |   8 +-
 renet/Cargo.toml                              |   8 +-
 renet/src/channel/unreliable.rs               |   7 ++
 renet/src/lib.rs                              |   5 +
 renet_steam/Cargo.toml                        |  12 +-
 renet_steam/README.md                         | 112 +++++++++++++++++-
 .../src/steam.rs => renet_steam/src/bevy.rs   |  69 ++++-------
 renet_steam/src/client.rs                     |   9 +-
 renet_steam/src/lib.rs                        |   3 +
 renet_steam/src/server.rs                     |  13 +-
 renet_visualizer/Cargo.toml                   |   8 +-
 renet_visualizer/src/lib.rs                   |   6 +-
 renetcode/Cargo.toml                          |   2 +-
 renetcode/src/client.rs                       |   4 +-
 renetcode/src/lib.rs                          |   3 -
 renetcode/src/token.rs                        |   6 +-
 26 files changed, 301 insertions(+), 213 deletions(-)
 rename bevy_renet/src/steam.rs => renet_steam/src/bevy.rs (53%)

diff --git a/README.md b/README.md
index 5f8f82c4..6fc40683 100644
--- a/README.md
+++ b/README.md
@@ -33,7 +33,7 @@ let send_type = SendType::ReliableOrdered {
     resend_time: Duration::from_millis(300)
 };
 
-// Garantee of message delivery but not order
+// Guarantee of message delivery but not order
 let send_type = SendType::ReliableUnordered {
     resend_time: Duration::from_millis(300)
 };
@@ -190,6 +190,8 @@ Simple chat application made with egui to demonstrate how you could handle error
 
 Checkout [bevy_renet](https://github.com/lucaspoffo/renet/tree/master/bevy_renet) if you want to use renet as a plugin with the [Bevy engine](https://bevyengine.org/).
 
+Checkout [renet_steam](https://github.com/lucaspoffo/renet/tree/master/renet_steam) if you want to use the steam transport layer instead of the default one.
+
 ## Visualizer
 
 Checkout [renet_visualizer](https://github.com/lucaspoffo/renet/tree/master/renet_visualizer) for a egui plugin to plot metrics data from renet clients and servers:
diff --git a/bevy_renet/Cargo.toml b/bevy_renet/Cargo.toml
index 9fc703cc..c8fae06d 100644
--- a/bevy_renet/Cargo.toml
+++ b/bevy_renet/Cargo.toml
@@ -6,7 +6,7 @@ keywords = ["gamedev", "networking"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/lucaspoffo/renet"
-version = "0.0.10"
+version = "0.0.11"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -14,19 +14,17 @@ version = "0.0.10"
 default = ["transport"]
 serde = ["renet/serde"]
 transport = ["renet/transport"]
-steam = ["renet_steam"]
 
 [[example]]
 name = "simple"
 required-features = ["serde", "transport"]
 
 [dependencies]
-bevy = {version = "0.12", default-features = false}
-renet = {path = "../renet", version = "0.0.14", default-features=false, features = ["bevy"]}
-renet_steam = { path = "../renet_steam", version = "0.0.1", features = [ "bevy" ], optional = true }
+bevy = {version = "0.13", default-features = false}
+renet = {path = "../renet", version = "0.0.15", default-features=false, features = ["bevy"]}
 
 [dev-dependencies]
-bevy = {version = "0.12", default-features = false, features = ["bevy_core_pipeline", "bevy_render", "bevy_asset", "bevy_pbr", "x11", "tonemapping_luts", "ktx2", "zstd"]}
-bincode = "1.3.1"
-env_logger = "0.10.0"
+bevy = {version = "0.13", default-features = false, features = ["bevy_core_pipeline", "bevy_render", "bevy_asset", "bevy_pbr", "x11", "tonemapping_luts", "ktx2", "zstd"]}
+bincode = "1.3"
+env_logger = "0.11"
 serde = {version = "1.0", features = ["derive"]}
diff --git a/bevy_renet/README.md b/bevy_renet/README.md
index ac9853ee..b57035a2 100644
--- a/bevy_renet/README.md
+++ b/bevy_renet/README.md
@@ -124,6 +124,7 @@ If you want a more complex example you can checkout the [demo_bevy](https://gith
 
 |bevy|bevy_renet|
 |---|---|
+|0.13|0.0.11|
 |0.12|0.0.10|
 |0.11|0.0.9|
 |0.10|0.0.8|
diff --git a/bevy_renet/examples/simple.rs b/bevy_renet/examples/simple.rs
index 991126f3..66c0a084 100644
--- a/bevy_renet/examples/simple.rs
+++ b/bevy_renet/examples/simple.rs
@@ -1,4 +1,4 @@
-use bevy::prelude::{shape::Plane, *};
+use bevy::{prelude::*, render::mesh::PlaneMeshBuilder};
 use bevy_renet::{
     client_connected,
     renet::{
@@ -106,7 +106,7 @@ fn main() {
 
         app.add_systems(
             Update,
-            (server_update_system, server_sync_players, move_players_system).run_if(resource_exists::<RenetServer>()),
+            (server_update_system, server_sync_players, move_players_system).run_if(resource_exists::<RenetServer>),
         );
     } else {
         app.add_plugins(RenetClientPlugin::default());
@@ -118,7 +118,7 @@ fn main() {
 
         app.add_systems(
             Update,
-            (player_input, client_send_input, client_sync_players).run_if(client_connected()),
+            (player_input, client_send_input, client_sync_players).run_if(client_connected),
         );
     }
 
@@ -143,8 +143,8 @@ fn server_update_system(
                 // Spawn player cube
                 let player_entity = commands
                     .spawn(PbrBundle {
-                        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
-                        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+                        mesh: meshes.add(Cuboid::from_size(Vec3::splat(1.0))),
+                        material: materials.add(Color::rgb(0.8, 0.7, 0.6)),
                         transform: Transform::from_xyz(0.0, 0.5, 0.0),
                         ..Default::default()
                     })
@@ -210,8 +210,8 @@ fn client_sync_players(
                 println!("Player {} connected.", id);
                 let player_entity = commands
                     .spawn(PbrBundle {
-                        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
-                        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+                        mesh: meshes.add(Cuboid::from_size(Vec3::splat(1.0))),
+                        material: materials.add(Color::rgb(0.8, 0.7, 0.6)),
                         transform: Transform::from_xyz(0.0, 0.5, 0.0),
                         ..Default::default()
                     })
@@ -246,8 +246,8 @@ fn client_sync_players(
 fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials: ResMut<Assets<StandardMaterial>>) {
     // plane
     commands.spawn(PbrBundle {
-        mesh: meshes.add(Mesh::from(Plane::from_size(5.0))),
-        material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
+        mesh: meshes.add(Mesh::from(PlaneMeshBuilder::from_size(Vec2::splat(5.0)))),
+        material: materials.add(Color::rgb(0.3, 0.5, 0.3)),
         ..Default::default()
     });
     // light
@@ -267,11 +267,11 @@ fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials
     });
 }
 
-fn player_input(keyboard_input: Res<Input<KeyCode>>, mut player_input: ResMut<PlayerInput>) {
-    player_input.left = keyboard_input.pressed(KeyCode::A) || keyboard_input.pressed(KeyCode::Left);
-    player_input.right = keyboard_input.pressed(KeyCode::D) || keyboard_input.pressed(KeyCode::Right);
-    player_input.up = keyboard_input.pressed(KeyCode::W) || keyboard_input.pressed(KeyCode::Up);
-    player_input.down = keyboard_input.pressed(KeyCode::S) || keyboard_input.pressed(KeyCode::Down);
+fn player_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut player_input: ResMut<PlayerInput>) {
+    player_input.left = keyboard_input.pressed(KeyCode::KeyA) || keyboard_input.pressed(KeyCode::ArrowLeft);
+    player_input.right = keyboard_input.pressed(KeyCode::KeyD) || keyboard_input.pressed(KeyCode::ArrowRight);
+    player_input.up = keyboard_input.pressed(KeyCode::KeyW) || keyboard_input.pressed(KeyCode::ArrowUp);
+    player_input.down = keyboard_input.pressed(KeyCode::KeyS) || keyboard_input.pressed(KeyCode::ArrowDown);
 }
 
 fn client_send_input(player_input: Res<PlayerInput>, mut client: ResMut<RenetClient>) {
diff --git a/bevy_renet/src/lib.rs b/bevy_renet/src/lib.rs
index d9a3e7ad..06ef3115 100644
--- a/bevy_renet/src/lib.rs
+++ b/bevy_renet/src/lib.rs
@@ -7,9 +7,6 @@ use renet::{RenetClient, RenetServer, ServerEvent};
 #[cfg(feature = "transport")]
 pub mod transport;
 
-#[cfg(feature = "steam")]
-pub mod steam;
-
 /// This system set is where all transports receive messages
 ///
 /// If you want to ensure data has arrived in the [`RenetClient`] or [`RenetServer`], then schedule your
@@ -27,6 +24,7 @@ pub struct RenetReceive;
 /// This system set runs in PostUpdate.
 #[derive(Debug, SystemSet, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct RenetSend;
+
 #[derive(Debug, SystemSet, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum CoreSet {
     Pre,
@@ -37,7 +35,6 @@ pub struct NetSchedules {
     pub pre: Interned<dyn ScheduleLabel>,
     pub post: Interned<dyn ScheduleLabel>,
 }
-
 impl Default for NetSchedules {
     fn default() -> Self {
         Self {
@@ -60,14 +57,15 @@ impl Plugin for RenetServerPlugin {
         app.init_resource::<Events<ServerEvent>>();
         app.add_systems(
             self.schedules.pre,
-            Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetServer>()),
+            Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetServer>),
         );
         app.add_systems(
             self.schedules.pre,
             Self::emit_server_events_system
-                .run_if(resource_exists::<RenetServer>())
-                .after(Self::update_system)
-                .in_set(CoreSet::Pre),
+                .in_set(RenetReceive)
+                .run_if(resource_exists::<RenetServer>)
+                .in_set(CoreSet::Pre)
+                .after(Self::update_system),
         );
     }
 }
@@ -88,7 +86,7 @@ impl Plugin for RenetClientPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
             self.schedules.pre,
-            Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetClient>()),
+            Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetClient>),
         );
     }
 }
@@ -99,43 +97,39 @@ impl RenetClientPlugin {
     }
 }
 
-pub fn client_connected() -> impl FnMut(Option<Res<RenetClient>>) -> bool {
-    |client| match client {
+pub fn client_connected(client: Option<Res<RenetClient>>) -> bool {
+    match client {
         Some(client) => client.is_connected(),
         None => false,
     }
 }
 
-pub fn client_disconnected() -> impl FnMut(Option<Res<RenetClient>>) -> bool {
-    |client| match client {
+pub fn client_disconnected(client: Option<Res<RenetClient>>) -> bool {
+    match client {
         Some(client) => client.is_disconnected(),
         None => true,
     }
 }
 
-pub fn client_connecting() -> impl FnMut(Option<Res<RenetClient>>) -> bool {
-    |client| match client {
+pub fn client_connecting(client: Option<Res<RenetClient>>) -> bool {
+    match client {
         Some(client) => client.is_connecting(),
         None => false,
     }
 }
 
-pub fn client_just_connected() -> impl FnMut(Local<bool>, Option<Res<RenetClient>>) -> bool {
-    |mut last_connected: Local<bool>, client| {
-        let connected = client.map(|client| client.is_connected()).unwrap_or(false);
+pub fn client_just_connected(mut last_connected: Local<bool>, client: Option<Res<RenetClient>>) -> bool {
+    let connected = client.map(|client| client.is_connected()).unwrap_or(false);
 
-        let just_connected = !*last_connected && connected;
-        *last_connected = connected;
-        just_connected
-    }
+    let just_connected = !*last_connected && connected;
+    *last_connected = connected;
+    just_connected
 }
 
-pub fn client_just_disconnected() -> impl FnMut(Local<bool>, Option<Res<RenetClient>>) -> bool {
-    |mut last_connected: Local<bool>, client| {
-        let disconnected = client.map(|client| client.is_disconnected()).unwrap_or(true);
+pub fn client_just_disconnected(mut last_connected: Local<bool>, client: Option<Res<RenetClient>>) -> bool {
+    let disconnected = client.map(|client| client.is_disconnected()).unwrap_or(true);
 
-        let just_disconnected = *last_connected && disconnected;
-        *last_connected = !disconnected;
-        just_disconnected
-    }
+    let just_disconnected = *last_connected && disconnected;
+    *last_connected = !disconnected;
+    just_disconnected
 }
diff --git a/bevy_renet/src/transport.rs b/bevy_renet/src/transport.rs
index 5bffc1f5..76ce4f17 100644
--- a/bevy_renet/src/transport.rs
+++ b/bevy_renet/src/transport.rs
@@ -6,6 +6,7 @@ use renet::{
 use bevy::{app::AppExit, prelude::*};
 
 use crate::{CoreSet, NetSchedules, RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
+
 #[derive(Default)]
 pub struct NetcodeServerPlugin {
     pub schedules: NetSchedules,
@@ -24,8 +25,8 @@ impl Plugin for NetcodeServerPlugin {
             Self::update_system
                 .in_set(RenetReceive)
                 .in_set(CoreSet::Pre)
-                .run_if(resource_exists::<NetcodeServerTransport>())
-                .run_if(resource_exists::<RenetServer>())
+                .run_if(resource_exists::<NetcodeServerTransport>)
+                .run_if(resource_exists::<RenetServer>)
                 .after(RenetServerPlugin::update_system)
                 .before(RenetServerPlugin::emit_server_events_system),
         );
@@ -33,9 +34,9 @@ impl Plugin for NetcodeServerPlugin {
         app.add_systems(
             self.schedules.post,
             (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
-                .in_set(CoreSet::Post)
-                .run_if(resource_exists::<NetcodeServerTransport>())
-                .run_if(resource_exists::<RenetServer>()),
+                .run_if(resource_exists::<NetcodeServerTransport>)
+                .run_if(resource_exists::<RenetServer>)
+                .in_set(CoreSet::Post),
         );
         if self.schedules.post == self.schedules.pre {
             app.configure_sets(self.schedules.post, (CoreSet::Pre, CoreSet::Post).chain());
@@ -44,7 +45,7 @@ impl Plugin for NetcodeServerPlugin {
 }
 
 impl NetcodeServerPlugin {
-    fn update_system(
+    pub fn update_system(
         mut transport: ResMut<NetcodeServerTransport>,
         mut server: ResMut<RenetServer>,
         time: Res<Time>,
@@ -55,7 +56,7 @@ impl NetcodeServerPlugin {
         }
     }
 
-    fn send_packets(mut transport: ResMut<NetcodeServerTransport>, mut server: ResMut<RenetServer>) {
+    pub fn send_packets(mut transport: ResMut<NetcodeServerTransport>, mut server: ResMut<RenetServer>) {
         transport.send_packets(&mut server);
     }
 
@@ -74,26 +75,23 @@ impl Plugin for NetcodeClientPlugin {
             self.schedules.pre,
             Self::update_system
                 .in_set(RenetReceive)
-                .in_set(CoreSet::Pre)
-                .run_if(resource_exists::<NetcodeClientTransport>())
-                .run_if(resource_exists::<RenetClient>())
-                .after(RenetClientPlugin::update_system),
+                .run_if(resource_exists::<NetcodeClientTransport>)
+                .run_if(resource_exists::<RenetClient>)
+                .after(RenetClientPlugin::update_system)
+                .in_set(CoreSet::Pre),
         );
         app.add_systems(
             self.schedules.post,
             (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
-                .in_set(CoreSet::Post)
-                .run_if(resource_exists::<NetcodeClientTransport>())
-                .run_if(resource_exists::<RenetClient>()),
+                .run_if(resource_exists::<NetcodeClientTransport>)
+                .run_if(resource_exists::<RenetClient>)
+                .in_set(CoreSet::Post),
         );
-        if self.schedules.post == self.schedules.pre {
-            app.configure_sets(self.schedules.post, (CoreSet::Pre, CoreSet::Post).chain());
-        }
     }
 }
 
 impl NetcodeClientPlugin {
-    fn update_system(
+    pub fn update_system(
         mut transport: ResMut<NetcodeClientTransport>,
         mut client: ResMut<RenetClient>,
         time: Res<Time>,
@@ -104,7 +102,7 @@ impl NetcodeClientPlugin {
         }
     }
 
-    fn send_packets(
+    pub fn send_packets(
         mut transport: ResMut<NetcodeClientTransport>,
         mut client: ResMut<RenetClient>,
         mut transport_errors: EventWriter<NetcodeTransportError>,
@@ -114,7 +112,7 @@ impl NetcodeClientPlugin {
         }
     }
 
-    fn disconnect_on_exit(exit: EventReader<AppExit>, mut transport: ResMut<NetcodeClientTransport>) {
+    pub fn disconnect_on_exit(exit: EventReader<AppExit>, mut transport: ResMut<NetcodeClientTransport>) {
         if !exit.is_empty() {
             transport.disconnect();
         }
diff --git a/demo_bevy/Cargo.toml b/demo_bevy/Cargo.toml
index 224f6a6c..098e1f6b 100644
--- a/demo_bevy/Cargo.toml
+++ b/demo_bevy/Cargo.toml
@@ -12,16 +12,25 @@ path = "src/bin/server.rs"
 
 [features]
 transport = ["bevy_renet/transport"]
-steam = ["bevy_renet/steam", "steamworks"]
+steam = ["dep:renet_steam", "steamworks"]
 
 [dependencies]
-bevy = {version = "0.12", default-features = false, features = ["bevy_core_pipeline", "bevy_render", "bevy_asset", "bevy_pbr", "x11", "tonemapping_luts", "ktx2", "zstd"]}
+bevy = { version = "0.13", default-features = false, features = [
+    "bevy_core_pipeline",
+    "bevy_render",
+    "bevy_asset",
+    "bevy_pbr",
+    "x11",
+    "tonemapping_luts",
+    "ktx2",
+    "zstd",
+] }
 bevy_renet = { path = "../bevy_renet", features = ["serde"] }
+renet_steam = { path = "../renet_steam", features = ["bevy"], optional = true }
 serde = { version = "1.0", features = ["derive"] }
-bincode = "1.3.1"
-bevy_egui = "0.23.0"
+bincode = "1.3"
+bevy_egui = "0.25"
 renet_visualizer = { path = "../renet_visualizer", features = ["bevy"] }
-smooth-bevy-cameras = "0.10"
-fastrand = "2.0.0"
-
-steamworks = { git = "https://github.com/Noxime/steamworks-rs", rev = "a4dfe2a", optional = true }
+smooth-bevy-cameras = "0.11"
+fastrand = "2.0"
+steamworks = { version = "0.11", optional = true }
diff --git a/demo_bevy/src/bin/client.rs b/demo_bevy/src/bin/client.rs
index fd96361c..9e657e79 100644
--- a/demo_bevy/src/bin/client.rs
+++ b/demo_bevy/src/bin/client.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use bevy::{
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
-    prelude::{shape::Icosphere, *},
+    prelude::*,
     window::PrimaryWindow,
 };
 use bevy_egui::{EguiContexts, EguiPlugin};
@@ -48,7 +48,7 @@ fn add_netcode_network(app: &mut App) {
 
     app.add_plugins(bevy_renet::transport::NetcodeClientPlugin);
 
-    app.configure_sets(Update, Connected.run_if(client_connected()));
+    app.configure_sets(Update, Connected.run_if(client_connected));
 
     let client = RenetClient::new(connection_config());
 
@@ -82,7 +82,7 @@ fn add_netcode_network(app: &mut App) {
 
 #[cfg(feature = "steam")]
 fn add_steam_network(app: &mut App) {
-    use bevy_renet::steam::{SteamClientPlugin, SteamClientTransport, SteamTransportError};
+    use renet_steam::bevy::{SteamClientPlugin, SteamClientTransport, SteamTransportError};
     use steamworks::{SingleClient, SteamId};
 
     let (steam_client, single) = steamworks::Client::init_app(480).unwrap();
@@ -101,7 +101,7 @@ fn add_steam_network(app: &mut App) {
     app.insert_resource(transport);
     app.insert_resource(CurrentClientId(steam_client.user().steam_id().raw()));
 
-    app.configure_sets(Update, Connected.run_if(client_connected()));
+    app.configure_sets(Update, Connected.run_if(client_connected));
 
     app.insert_non_send_resource(single);
     fn steam_callbacks(client: NonSend<SingleClient>) {
@@ -161,7 +161,7 @@ fn update_visulizer_system(
     mut visualizer: ResMut<RenetClientVisualizer<200>>,
     client: Res<RenetClient>,
     mut show_visualizer: Local<bool>,
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
 ) {
     visualizer.add_network_info(client.network_info());
     if keyboard_input.just_pressed(KeyCode::F1) {
@@ -173,16 +173,16 @@ fn update_visulizer_system(
 }
 
 fn player_input(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
     mut player_input: ResMut<PlayerInput>,
-    mouse_button_input: Res<Input<MouseButton>>,
+    mouse_button_input: Res<ButtonInput<MouseButton>>,
     target_query: Query<&Transform, With<Target>>,
     mut player_commands: EventWriter<PlayerCommand>,
 ) {
-    player_input.left = keyboard_input.pressed(KeyCode::A) || keyboard_input.pressed(KeyCode::Left);
-    player_input.right = keyboard_input.pressed(KeyCode::D) || keyboard_input.pressed(KeyCode::Right);
-    player_input.up = keyboard_input.pressed(KeyCode::W) || keyboard_input.pressed(KeyCode::Up);
-    player_input.down = keyboard_input.pressed(KeyCode::S) || keyboard_input.pressed(KeyCode::Down);
+    player_input.left = keyboard_input.pressed(KeyCode::KeyA) || keyboard_input.pressed(KeyCode::ArrowLeft);
+    player_input.right = keyboard_input.pressed(KeyCode::KeyD) || keyboard_input.pressed(KeyCode::ArrowRight);
+    player_input.up = keyboard_input.pressed(KeyCode::KeyW) || keyboard_input.pressed(KeyCode::ArrowUp);
+    player_input.down = keyboard_input.pressed(KeyCode::KeyS) || keyboard_input.pressed(KeyCode::ArrowDown);
 
     if mouse_button_input.just_pressed(MouseButton::Left) {
         let target_transform = target_query.single();
@@ -221,8 +221,8 @@ fn client_sync_players(
             ServerMessages::PlayerCreate { id, translation, entity } => {
                 println!("Player {} connected.", id);
                 let mut client_entity = commands.spawn(PbrBundle {
-                    mesh: meshes.add(Mesh::from(shape::Capsule::default())),
-                    material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+                    mesh: meshes.add(Mesh::from(Capsule3d::default())),
+                    material: materials.add(Color::rgb(0.8, 0.7, 0.6)),
                     transform: Transform::from_xyz(translation[0], translation[1], translation[2]),
                     ..Default::default()
                 });
@@ -251,14 +251,8 @@ fn client_sync_players(
             }
             ServerMessages::SpawnProjectile { entity, translation } => {
                 let projectile_entity = commands.spawn(PbrBundle {
-                    mesh: meshes.add(
-                        Mesh::try_from(Icosphere {
-                            radius: 0.1,
-                            subdivisions: 5,
-                        })
-                        .unwrap(),
-                    ),
-                    material: materials.add(Color::rgb(1.0, 0.0, 0.0).into()),
+                    mesh: meshes.add(Mesh::from(Sphere::new(0.1))),
+                    material: materials.add(Color::rgb(1.0, 0.0, 0.0)),
                     transform: Transform::from_translation(translation.into()),
                     ..Default::default()
                 });
@@ -300,7 +294,7 @@ fn update_target_system(
     let mut target_transform = target_query.single_mut();
     if let Some(cursor_pos) = primary_window.single().cursor_position() {
         if let Some(ray) = camera.viewport_to_world(camera_transform, cursor_pos) {
-            if let Some(distance) = ray.intersect_plane(Vec3::Y, Vec3::Y) {
+            if let Some(distance) = ray.intersect_plane(Vec3::Y, Plane3d::new(Vec3::Y)) {
                 target_transform.translation = ray.direction * distance + ray.origin;
             }
         }
@@ -326,14 +320,8 @@ fn setup_camera(mut commands: Commands) {
 fn setup_target(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials: ResMut<Assets<StandardMaterial>>) {
     commands
         .spawn(PbrBundle {
-            mesh: meshes.add(
-                Mesh::try_from(Icosphere {
-                    radius: 0.1,
-                    subdivisions: 5,
-                })
-                .unwrap(),
-            ),
-            material: materials.add(Color::rgb(1.0, 0.0, 0.0).into()),
+            mesh: meshes.add(Mesh::from(Sphere::new(0.1))),
+            material: materials.add(Color::rgb(1.0, 0.0, 0.0)),
             transform: Transform::from_xyz(0.0, 0., 0.0),
             ..Default::default()
         })
diff --git a/demo_bevy/src/bin/server.rs b/demo_bevy/src/bin/server.rs
index b9faf77f..b57111aa 100644
--- a/demo_bevy/src/bin/server.rs
+++ b/demo_bevy/src/bin/server.rs
@@ -59,8 +59,9 @@ fn add_netcode_network(app: &mut App) {
 
 #[cfg(feature = "steam")]
 fn add_steam_network(app: &mut App) {
-    use bevy_renet::steam::{AccessPermission, SteamServerConfig, SteamServerPlugin, SteamServerTransport};
     use demo_bevy::connection_config;
+    use renet_steam::bevy::{SteamServerConfig, SteamServerPlugin, SteamServerTransport};
+    use renet_steam::AccessPermission;
     use steamworks::SingleClient;
 
     let (steam_client, single) = steamworks::Client::init_app(480).unwrap();
@@ -160,8 +161,8 @@ fn server_update_system(
                 let transform = Transform::from_xyz((fastrand::f32() - 0.5) * 40., 0.51, (fastrand::f32() - 0.5) * 40.);
                 let player_entity = commands
                     .spawn(PbrBundle {
-                        mesh: meshes.add(Mesh::from(shape::Capsule::default())),
-                        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+                        mesh: meshes.add(Mesh::from(Capsule3d::default())),
+                        material: materials.add(Color::rgb(0.8, 0.7, 0.6)),
                         transform,
                         ..Default::default()
                     })
@@ -290,7 +291,7 @@ fn projectile_on_removal_system(mut server: ResMut<RenetServer>, mut removed_pro
 }
 
 fn spawn_bot(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut lobby: ResMut<ServerLobby>,
@@ -305,8 +306,8 @@ fn spawn_bot(
         let transform = Transform::from_xyz((fastrand::f32() - 0.5) * 40., 0.51, (fastrand::f32() - 0.5) * 40.);
         let player_entity = commands
             .spawn(PbrBundle {
-                mesh: meshes.add(Mesh::from(shape::Capsule::default())),
-                material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+                mesh: meshes.add(Mesh::from(Capsule3d::default())),
+                material: materials.add(Color::rgb(0.8, 0.7, 0.6)),
                 transform,
                 ..Default::default()
             })
diff --git a/demo_bevy/src/lib.rs b/demo_bevy/src/lib.rs
index c634087b..35f439b6 100644
--- a/demo_bevy/src/lib.rs
+++ b/demo_bevy/src/lib.rs
@@ -1,6 +1,6 @@
 use std::{f32::consts::PI, time::Duration};
 
-use bevy::prelude::{shape::Icosphere, *};
+use bevy::prelude::*;
 use bevy_renet::renet::{ChannelConfig, ClientId, ConnectionConfig, SendType};
 use serde::{Deserialize, Serialize};
 
@@ -133,8 +133,8 @@ pub fn connection_config() -> ConnectionConfig {
 pub fn setup_level(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials: ResMut<Assets<StandardMaterial>>) {
     // plane
     commands.spawn(PbrBundle {
-        mesh: meshes.add(Mesh::from(shape::Box::new(40., 1., 40.))),
-        material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
+        mesh: meshes.add(Mesh::from(Cuboid::new(40., 1., 40.))),
+        material: materials.add(Color::rgb(0.3, 0.5, 0.3)),
         transform: Transform::from_xyz(0.0, -1.0, 0.0),
         ..Default::default()
     });
@@ -170,14 +170,8 @@ pub fn spawn_fireball(
     }
     commands
         .spawn(PbrBundle {
-            mesh: meshes.add(
-                Mesh::try_from(Icosphere {
-                    radius: 0.1,
-                    subdivisions: 5,
-                })
-                .unwrap(),
-            ),
-            material: materials.add(Color::rgb(1.0, 0.0, 0.0).into()),
+            mesh: meshes.add(Sphere { radius: 0.1 }),
+            material: materials.add(Color::rgb(1.0, 0.0, 0.0)),
             transform: Transform::from_translation(translation),
             ..Default::default()
         })
diff --git a/demo_chat/Cargo.toml b/demo_chat/Cargo.toml
index 2c3dac84..c3284251 100644
--- a/demo_chat/Cargo.toml
+++ b/demo_chat/Cargo.toml
@@ -10,8 +10,8 @@ edition = "2021"
 [dependencies]
 renet = { path = "../renet", features = ["transport", "serde"] }
 renet_visualizer = { path = "../renet_visualizer" }
-eframe = "0.23"
+eframe = "0.26"
 serde = { version = "1.0", features = ["derive"] }
-bincode = "1.3.1"
-log = { version = "0.4.11", features = ["std"] }
-env_logger = "0.10.0"
+bincode = "1.3"
+log = { version = "0.4", features = ["std"] }
+env_logger = "0.11"
diff --git a/renet/Cargo.toml b/renet/Cargo.toml
index 6c3b94ca..24805f58 100644
--- a/renet/Cargo.toml
+++ b/renet/Cargo.toml
@@ -7,7 +7,7 @@ keywords = ["gamedev", "networking"]
 license = "MIT OR Apache-2.0"
 readme = "../README.md"
 repository = "https://github.com/lucaspoffo/renet"
-version = "0.0.14"
+version = "0.0.15"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [features]
@@ -17,12 +17,12 @@ transport = ["dep:renetcode"]
 serde = ["dep:serde"]
 
 [dependencies]
-bevy_ecs = { version = "0.12", optional = true }
+bevy_ecs = { version = "0.13", optional = true }
 bytes = "1.1"
 log = "0.4.17"
 octets = "0.2"
-renetcode = { path = "../renetcode", version = "0.0.10", optional = true }
+renetcode = { path = "../renetcode", version = "0.0.11", optional = true }
 serde = {version = "1.0", optional = true}
 
 [dev-dependencies]
-env_logger = "0.10.0"
+env_logger = "0.11"
diff --git a/renet/src/channel/unreliable.rs b/renet/src/channel/unreliable.rs
index ea07b7c2..62f81377 100644
--- a/renet/src/channel/unreliable.rs
+++ b/renet/src/channel/unreliable.rs
@@ -125,6 +125,13 @@ impl SendChannelUnreliable {
             return;
         }
 
+        let num_fragments = message.len() / SLICE_SIZE;
+        if num_fragments > 20 {
+            log::warn!(
+                "Sending an unreliable message with {num_fragments} fragments, messages with this many fragments are susceptible to packet loss. \
+                Consider breaking your message into smaller ones or using a reliable channel");
+        }
+
         self.memory_usage_bytes += message.len();
         self.unreliable_messages.push_back(message);
     }
diff --git a/renet/src/lib.rs b/renet/src/lib.rs
index ef0d2c08..1fa3f7d0 100644
--- a/renet/src/lib.rs
+++ b/renet/src/lib.rs
@@ -56,3 +56,8 @@ impl<'de> serde::Deserialize<'de> for ClientId {
         u64::deserialize(deserializer).map(ClientId::from_raw)
     }
 }
+
+#[cfg(feature = "bevy")]
+impl bevy_ecs::component::Component for ClientId {
+    type Storage = bevy_ecs::component::TableStorage;
+}
diff --git a/renet_steam/Cargo.toml b/renet_steam/Cargo.toml
index 9627dbfc..55400fff 100644
--- a/renet_steam/Cargo.toml
+++ b/renet_steam/Cargo.toml
@@ -11,14 +11,16 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-bevy = ["dep:bevy_ecs"]
+bevy = ["dep:bevy_app", "dep:bevy_ecs", "dep:bevy_renet"]
 
 [dependencies]
-renet = { path = "../renet" }
+renet = { version = "0.0.15", path = "../renet" }
 # its version 0.10 but we need to use the rev because of a missing feature
-steamworks = { git = "https://github.com/Noxime/steamworks-rs", rev = "a4dfe2a" }
+steamworks = "0.11"
 log = "0.4.19"
-bevy_ecs = { version = "0.12", optional = true }
+bevy_ecs = { version = "0.13", optional = true }
+bevy_app = { version = "0.13", optional = true }
+bevy_renet = { version = "0.0.11", optional = true, path = "../bevy_renet" }
 
 [dev-dependencies]
-env_logger = "0.10.0"
+env_logger = "0.11"
diff --git a/renet_steam/README.md b/renet_steam/README.md
index 894f8a45..2b30db8b 100644
--- a/renet_steam/README.md
+++ b/renet_steam/README.md
@@ -1,3 +1,113 @@
 # Renet Steam
+[![Latest version](https://img.shields.io/crates/v/renet_steam.svg)](https://crates.io/crates/renet_steam)
+[![Documentation](https://docs.rs/renet_steam/badge.svg)](https://docs.rs/renet_steam)
+![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
 
-Transport layer for renet using the steamworks.
\ No newline at end of file
+Transport layer for the [renet](https://github.com/lucaspoffo/renet) crate using the steamworks-rs.
+
+## Usage
+
+This crate adds `SteamServerTransport` and `SteamClientTransport` to replace the default transport layer that comes with renet:
+
+#### Server
+
+```rust
+// Setup steam client
+let (steam_client, single) = Client::init_app(480).unwrap();
+steam_client.networking_utils().init_relay_network_access();
+
+// Create renet server
+let connection_config = ConnectionConfig::default();
+let mut server: RenetServer = RenetServer::new(connection_config);
+
+// Create steam transport
+let access_permission = AccessPermission::Public;
+let steam_transport_config = SteamServerConfig {
+    max_clients: 10,
+    access_permission,
+};
+let mut steam_transport = SteamServerTransport::new(&steam_client, steam_transport_config).unwrap();
+
+// Your gameplay loop
+loop {
+    let delta_time = Duration::from_millis(16);
+
+    single.run_callbacks(); // Update steam callbacks
+   
+    server.update(delta_time);
+    steam_transport.update(&mut server);
+
+    // Handle connect/disconnect events
+    while let Some(event) = server.get_event() {
+        match event {
+            ServerEvent::ClientConnected { client_id } => {
+                println!("Client {} connected.", client_id)
+            }
+            ServerEvent::ClientDisconnected { client_id, reason } => {
+                println!("Client {} disconnected: {}", client_id, reason);
+            }
+        }
+    }
+
+    // Code for sending/receiving messages can go here
+    // Check the examples/demos 
+
+    steam_transport.send_packets(&mut server);
+    thread::sleep(delta_time);
+}
+```
+
+#### Client
+
+```rust
+// Setup steam client
+let (steam_client, single) = Client::init_app(480).unwrap();
+steam_client.networking_utils().init_relay_network_access();
+
+// Create renet client
+let connection_config = ConnectionConfig::default();
+let mut client = RenetClient::new(connection_config);
+
+// Create steam transport
+let server_steam_id = SteamId::from_raw(0); // Here goes the steam id of the host
+let mut steam_transport = SteamClientTransport::new(&steam_client, &server_steam_id).unwrap();
+
+// Your gameplay loop
+loop {
+    let delta_time = Duration::from_millis(16);
+
+    single.run_callbacks(); // Update steam callbacks
+    client.update(delta_time);
+    steam_transport.update(&mut client);
+
+    // Code for sending/receiving messages can go here
+    // Check the examples/demos 
+
+    steam_transport.send_packets(&mut client).unwrap();
+    thread::sleep(delta_time);
+}
+```
+
+## Example
+
+You can try the steam echo example with (steam needs to be running in the background):
+
+- server: `cargo run --example echo server`
+- client: `cargo run --example echo client [HOST_STEAM_ID]`
+
+The HOST_STEAM_ID is printed in the console when the server starts.
+
+You can also run the echo example using steam lobbies.
+Only steam users connected to the lobby will be able to connect to the server. In the echo example, they will first try connect to the steam lobby and later to the renet server:
+
+- server: `cargo run --example echo server lobby`
+- client: `cargo run --example echo client [HOST_STEAM_ID] [LOBBY_ID]`
+
+The LOBBY_ID is printed in the console when the server starts.
+
+## Bevy
+
+If you are using bevy, you can enable the `bevy` feature and instead of using the default transport that comes in `bevy_renet` you can use `SteamServerPlugin` and `SteamClientPlugin`, the setup should be similar.
+
+You can check the [Bevy Demo](https://github.com/lucaspoffo/renet/tree/master/demo_bevy) for how to use the default and steam transport switching between them using feature flags.
diff --git a/bevy_renet/src/steam.rs b/renet_steam/src/bevy.rs
similarity index 53%
rename from bevy_renet/src/steam.rs
rename to renet_steam/src/bevy.rs
index 136a6147..a8d52ea9 100644
--- a/bevy_renet/src/steam.rs
+++ b/renet_steam/src/bevy.rs
@@ -1,35 +1,15 @@
-use bevy::{app::AppExit, prelude::*};
+use bevy_app::{prelude::*, AppExit};
+use bevy_ecs::prelude::*;
 use renet::{RenetClient, RenetServer};
-use renet_steam::steamworks::SteamError;
+use steamworks::SteamError;
 
-use crate::{RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
+use bevy_renet::{RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
 
-pub use renet_steam::{AccessPermission, SteamClientTransport, SteamServerConfig, SteamServerTransport};
+pub use crate::{AccessPermission, SteamClientTransport, SteamServerConfig, SteamServerTransport};
 
-pub struct SteamServerPlugin {
-    pub schedules: NetSchedules,
-}
-
-pub struct SteamClientPlugin {
-    pub schedules: NetSchedules,
-}
+pub struct SteamServerPlugin;
 
-impl Default for SteamServerPlugin {
-    fn default() -> Self {
-        Self {
-            pre_schedule: PreUpdate.intern(),
-            post_schedule: PostUpdate.intern(),
-        }
-    }
-}
-impl Default for SteamClientPlugin {
-    fn default() -> Self {
-        Self {
-            pre_schedule: PreUpdate.intern(),
-            post_schedule: PostUpdate.intern(),
-        }
-    }
-}
+pub struct SteamClientPlugin;
 
 #[derive(Debug, Event)]
 pub struct SteamTransportError(pub SteamError);
@@ -43,32 +23,29 @@ impl std::fmt::Display for SteamTransportError {
 impl Plugin for SteamServerPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
-            self.pre_schedule,
+            PreUpdate,
             Self::update_system
                 .in_set(RenetReceive)
-                .in_set(CoreSet::Pre)
-                .run_if(resource_exists::<RenetServer>())
+                .run_if(resource_exists::<RenetServer>)
                 .after(RenetServerPlugin::update_system)
                 .before(RenetServerPlugin::emit_server_events_system),
         );
 
         app.add_systems(
-            self.post_schedule,
-            (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
-                .in_set(CoreSet::Post)
-                .run_if(resource_exists::<RenetServer>()),
+            PostUpdate,
+            (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit).run_if(resource_exists::<RenetServer>),
         );
     }
 }
 
 impl SteamServerPlugin {
-    fn update_system(mut transport: Option<NonSendMut<SteamServerTransport>>, mut server: ResMut<RenetServer>) {
+    pub fn update_system(mut transport: Option<NonSendMut<SteamServerTransport>>, mut server: ResMut<RenetServer>) {
         if let Some(transport) = transport.as_mut() {
             transport.update(&mut server);
         }
     }
 
-    fn send_packets(mut transport: Option<NonSendMut<SteamServerTransport>>, mut server: ResMut<RenetServer>) {
+    pub fn send_packets(mut transport: Option<NonSendMut<SteamServerTransport>>, mut server: ResMut<RenetServer>) {
         if let Some(transport) = transport.as_mut() {
             transport.send_packets(&mut server);
         }
@@ -92,30 +69,28 @@ impl Plugin for SteamClientPlugin {
         app.add_event::<SteamTransportError>();
 
         app.add_systems(
-            self.pre_schedule,
+            PreUpdate,
             Self::update_system
                 .in_set(RenetReceive)
-                .in_set(CoreSet::Pre)
-                .run_if(resource_exists::<SteamClientTransport>())
-                .run_if(resource_exists::<RenetClient>())
+                .run_if(resource_exists::<SteamClientTransport>)
+                .run_if(resource_exists::<RenetClient>)
                 .after(RenetClientPlugin::update_system),
         );
         app.add_systems(
-            self.post_schedule,
+            PostUpdate,
             (Self::send_packets.in_set(RenetSend), Self::disconnect_on_exit)
-                .in_set(CoreSet::Post)
-                .run_if(resource_exists::<SteamClientTransport>())
-                .run_if(resource_exists::<RenetClient>()),
+                .run_if(resource_exists::<SteamClientTransport>)
+                .run_if(resource_exists::<RenetClient>),
         );
     }
 }
 
 impl SteamClientPlugin {
-    fn update_system(mut transport: ResMut<SteamClientTransport>, mut client: ResMut<RenetClient>) {
+    pub fn update_system(mut transport: ResMut<SteamClientTransport>, mut client: ResMut<RenetClient>) {
         transport.update(&mut client);
     }
 
-    fn send_packets(
+    pub fn send_packets(
         mut transport: ResMut<SteamClientTransport>,
         mut client: ResMut<RenetClient>,
         mut transport_errors: EventWriter<SteamTransportError>,
@@ -125,7 +100,7 @@ impl SteamClientPlugin {
         }
     }
 
-    fn disconnect_on_exit(exit: EventReader<AppExit>, mut transport: ResMut<SteamClientTransport>) {
+    pub fn disconnect_on_exit(exit: EventReader<AppExit>, mut transport: ResMut<SteamClientTransport>) {
         if !exit.is_empty() {
             transport.disconnect();
         }
diff --git a/renet_steam/src/client.rs b/renet_steam/src/client.rs
index 2e9f58ec..b84e5d37 100644
--- a/renet_steam/src/client.rs
+++ b/renet_steam/src/client.rs
@@ -129,10 +129,11 @@ impl SteamClientTransport {
             unreachable!()
         };
 
-        let messages = connection.receive_messages(MAX_MESSAGE_BATCH_SIZE);
-        messages.iter().for_each(|message| {
-            client.process_packet(message.data());
-        });
+        if let Ok(messages) = connection.receive_messages(MAX_MESSAGE_BATCH_SIZE) {
+            messages.iter().for_each(|message| {
+                client.process_packet(message.data());
+            });
+        }
     }
 
     pub fn send_packets(&mut self, client: &mut RenetClient) -> Result<(), SteamError> {
diff --git a/renet_steam/src/lib.rs b/renet_steam/src/lib.rs
index 2c8b2387..b536d7dd 100644
--- a/renet_steam/src/lib.rs
+++ b/renet_steam/src/lib.rs
@@ -3,6 +3,9 @@ const MAX_MESSAGE_BATCH_SIZE: usize = 512;
 mod client;
 mod server;
 
+#[cfg(feature = "bevy")]
+pub mod bevy;
+
 pub use client::SteamClientTransport;
 pub use server::{AccessPermission, SteamServerConfig, SteamServerTransport};
 
diff --git a/renet_steam/src/server.rs b/renet_steam/src/server.rs
index bc73fd83..1c33fc73 100644
--- a/renet_steam/src/server.rs
+++ b/renet_steam/src/server.rs
@@ -141,12 +141,13 @@ impl<T: Manager + 'static> SteamServerTransport<T> {
 
         for (client_id, connection) in self.connections.iter_mut() {
             // TODO this allocates on the side of steamworks.rs and should be avoided, PR needed
-            let messages = connection.receive_messages(MAX_MESSAGE_BATCH_SIZE);
-            messages.iter().for_each(|message| {
-                if let Err(e) = server.process_packet_from(message.data(), *client_id) {
-                    log::error!("Error while processing payload for {}: {}", client_id, e);
-                };
-            });
+            if let Ok(messages) = connection.receive_messages(MAX_MESSAGE_BATCH_SIZE) {
+                messages.iter().for_each(|message| {
+                    if let Err(e) = server.process_packet_from(message.data(), *client_id) {
+                        log::error!("Error while processing payload for {}: {}", client_id, e);
+                    };
+                });
+            }
         }
     }
 
diff --git a/renet_visualizer/Cargo.toml b/renet_visualizer/Cargo.toml
index 67f9f83c..dade101a 100644
--- a/renet_visualizer/Cargo.toml
+++ b/renet_visualizer/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "renet_visualizer"
-version = "0.0.7"
+version = "0.0.8"
 keywords = ["gamedev", "networking"]
 description = "Egui metrics visualizer for the renet crate: Server/Client network library for multiplayer games"
 repository = "https://github.com/lucaspoffo/renet"
@@ -13,6 +13,6 @@ edition = "2021"
 bevy = ["dep:bevy_ecs"]
 
 [dependencies]
-renet = { path = "../renet", version = "0.0.14" }
-egui = "0.23"
-bevy_ecs = { version = "0.12.0", optional = true }
+renet = { path = "../renet", version = "0.0.15" }
+egui = "0.26"
+bevy_ecs = { version = "0.13", optional = true }
diff --git a/renet_visualizer/src/lib.rs b/renet_visualizer/src/lib.rs
index 49b5b343..c6876c7d 100644
--- a/renet_visualizer/src/lib.rs
+++ b/renet_visualizer/src/lib.rs
@@ -362,7 +362,7 @@ fn show_graph(
         let (outer_rect, _) = ui.allocate_exact_size(Vec2::new(style.width + galley.size().x + spacing_x, style.height), Sense::hover());
         let rect = Rect::from_min_size(outer_rect.left_top(), vec2(style.width, style.height));
         let text_pos = rect.right_center() + vec2(spacing_x / 2.0, -galley.size().y / 2.);
-        galley.paint_with_fallback_color(&ui.painter().with_clip_rect(outer_rect), text_pos, style.text_color);
+        ui.painter().with_clip_rect(outer_rect).galley(text_pos, galley, style.text_color);
 
         let body = Shape::Rect(RectShape {
             rect,
@@ -397,7 +397,7 @@ fn show_graph(
             };
             let galley = text.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Button);
             let text_pos = rect.left_top() + Vec2::new(0.0, galley.size().y / 2.) + vec2(spacing_x, 0.0);
-            galley.paint_with_fallback_color(&ui.painter().with_clip_rect(rect), text_pos, style.text_color);
+            ui.painter().with_clip_rect(outer_rect).galley(text_pos, galley, style.text_color);
         }
         {
             let text: WidgetText = match text_format {
@@ -406,7 +406,7 @@ fn show_graph(
             };
             let galley = text.into_galley(ui, Some(false), f32::INFINITY, TextStyle::Button);
             let text_pos = rect.left_bottom() - Vec2::new(0.0, galley.size().y * 1.5) + vec2(spacing_x, 0.0);
-            galley.paint_with_fallback_color(&ui.painter().with_clip_rect(rect), text_pos, style.text_color);
+            ui.painter().with_clip_rect(outer_rect).galley(text_pos, galley, style.text_color);
         }
     });
 }
diff --git a/renetcode/Cargo.toml b/renetcode/Cargo.toml
index afb4e327..48739ac5 100644
--- a/renetcode/Cargo.toml
+++ b/renetcode/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "renetcode"
-version = "0.0.10"
+version = "0.0.11"
 description = "Server/Client network protocol library for multiplayer games"
 keywords = ["gamedev", "networking", "cryptography"]
 repository = "https://github.com/lucaspoffo/renet"
diff --git a/renetcode/src/client.rs b/renetcode/src/client.rs
index b2839438..b69bc196 100644
--- a/renetcode/src/client.rs
+++ b/renetcode/src/client.rs
@@ -1,4 +1,4 @@
-use std::{fmt, net::SocketAddr, time::Duration};
+use std::{error::Error, fmt, net::SocketAddr, time::Duration};
 
 use crate::{
     packet::Packet, replay_protection::ReplayProtection, token::ConnectToken, NetcodeError, NETCODE_CHALLENGE_TOKEN_BYTES,
@@ -85,6 +85,8 @@ impl fmt::Display for DisconnectReason {
     }
 }
 
+impl Error for DisconnectReason {}
+
 impl NetcodeClient {
     pub fn new(current_time: Duration, authentication: ClientAuthentication) -> Result<Self, NetcodeError> {
         let connect_token: ConnectToken = match authentication {
diff --git a/renetcode/src/lib.rs b/renetcode/src/lib.rs
index 06a01ee3..8df45d5f 100644
--- a/renetcode/src/lib.rs
+++ b/renetcode/src/lib.rs
@@ -56,7 +56,4 @@ const NETCODE_CHALLENGE_TOKEN_BYTES: usize = 300;
 const NETCODE_CONNECT_TOKEN_XNONCE_BYTES: usize = 24;
 
 const NETCODE_ADDITIONAL_DATA_SIZE: usize = 13 + 8 + 8;
-
-const NETCODE_TIMEOUT_SECONDS: i32 = 15;
-
 const NETCODE_SEND_RATE: Duration = Duration::from_millis(250);
diff --git a/renetcode/src/token.rs b/renetcode/src/token.rs
index 4ccf5734..72118b06 100644
--- a/renetcode/src/token.rs
+++ b/renetcode/src/token.rs
@@ -10,8 +10,8 @@ use crate::{
     crypto::{dencrypted_in_place_xnonce, encrypt_in_place_xnonce, generate_random_bytes},
     serialize::*,
     NetcodeError, NETCODE_ADDITIONAL_DATA_SIZE, NETCODE_ADDRESS_IPV4, NETCODE_ADDRESS_IPV6, NETCODE_ADDRESS_NONE,
-    NETCODE_CONNECT_TOKEN_PRIVATE_BYTES, NETCODE_CONNECT_TOKEN_XNONCE_BYTES, NETCODE_KEY_BYTES, NETCODE_TIMEOUT_SECONDS,
-    NETCODE_USER_DATA_BYTES, NETCODE_VERSION_INFO,
+    NETCODE_CONNECT_TOKEN_PRIVATE_BYTES, NETCODE_CONNECT_TOKEN_XNONCE_BYTES, NETCODE_KEY_BYTES, NETCODE_USER_DATA_BYTES,
+    NETCODE_VERSION_INFO,
 };
 use chacha20poly1305::aead::Error as CryptoError;
 
@@ -114,7 +114,7 @@ impl ConnectToken {
             server_addresses: private_connect_token.server_addresses,
             client_to_server_key: private_connect_token.client_to_server_key,
             server_to_client_key: private_connect_token.server_to_client_key,
-            timeout_seconds: NETCODE_TIMEOUT_SECONDS,
+            timeout_seconds,
         })
     }
 

From c507ede50473df9c165234f088d6213848cf5ded Mon Sep 17 00:00:00 2001
From: starwolf <ramses@starwolves.io>
Date: Mon, 19 Aug 2024 20:35:20 +0200
Subject: [PATCH 6/6] Merge upstream commits.

---
 bevy_renet/Cargo.toml |  5 ++---
 bevy_renet/src/lib.rs | 17 ++++++++++++-----
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/bevy_renet/Cargo.toml b/bevy_renet/Cargo.toml
index 6cdbf922..68bafcea 100644
--- a/bevy_renet/Cargo.toml
+++ b/bevy_renet/Cargo.toml
@@ -21,11 +21,10 @@ required-features = ["serde", "transport"]
 
 [dependencies]
 bevy = {version = "0.14", default-features = false}
-renet = {path = "../renet", version = "0.0.14", default-features=false, features = ["bevy"]}
-renet_steam = { path = "../renet_steam", version = "0.0.1", features = [ "bevy" ], optional = true }
+renet = {path = "../renet", version = "0.0.16", default-features=false, features = ["bevy"]}
 
 [dev-dependencies]
 bevy = {version = "0.14", default-features = false, features = ["bevy_core_pipeline", "bevy_render", "bevy_asset", "bevy_pbr", "x11", "tonemapping_luts", "ktx2", "zstd"]}
 bincode = "1.3.1"
-env_logger = "0.10.0"
+env_logger = "0.11.0"
 serde = {version = "1.0", features = ["derive"]}
diff --git a/bevy_renet/src/lib.rs b/bevy_renet/src/lib.rs
index 86993459..f7c63c25 100644
--- a/bevy_renet/src/lib.rs
+++ b/bevy_renet/src/lib.rs
@@ -1,6 +1,9 @@
 pub use renet;
 
-use bevy::{ecs::schedule::ScheduleLabel, prelude::*, utils::intern::Interned};
+use bevy::{
+    ecs::{intern::Interned, schedule::ScheduleLabel},
+    prelude::*,
+};
 
 use renet::{RenetClient, RenetServer, ServerEvent};
 
@@ -62,9 +65,10 @@ impl Plugin for RenetServerPlugin {
         app.add_systems(
             self.schedules.pre,
             Self::emit_server_events_system
-            .in_set(RenetReceive)
-            .run_if(resource_exists::<RenetServer>)
-            .in_set(CoreSet::Pre).run_if(resource_exists::<RenetServer>())
+                .in_set(RenetReceive)
+                .run_if(resource_exists::<RenetServer>)
+                .in_set(CoreSet::Pre)
+                .run_if(resource_exists::<RenetServer>)
                 .after(Self::update_system),
         );
     }
@@ -84,7 +88,10 @@ impl RenetServerPlugin {
 
 impl Plugin for RenetClientPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(self.schedules.pre, Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetClient>()));
+        app.add_systems(
+            self.schedules.pre,
+            Self::update_system.in_set(CoreSet::Pre).run_if(resource_exists::<RenetClient>),
+        );
     }
 }