tidy up and multiplayer now works

Cargo.lock

···
 ]
 
 [[package]]
-name = "client"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "bevy",
- "dotenvy",
- "felix-net",
-]
-
-[[package]]
 name = "codespan-reporting"
 version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "felix-client"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bevy",
+ "dotenvy",
+ "felix-net",
+ "tokio",
+]
+
+[[package]]
 name = "felix-net"
 version = "0.1.0"
 dependencies = [
···
 ]
 
 [[package]]
+name = "felix-server"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bevy_math",
+ "dotenvy",
+ "felix-net",
+ "nanoid",
+]
+
+[[package]]
 name = "find-msvc-tools"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "adler2",
  "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "server"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "bevy_math",
- "dotenvy",
- "felix-net",
- "nanoid",
-]
-
-[[package]]
 name = "sharded-slab"
 version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7664a098b8e616bdfcc2dc0e9ac44eb231eedf41db4e9fe95d8d32ec728dedad"
+dependencies = [
+ "libc",
+]
 
 [[package]]
 name = "simd-adler32"
···
 checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"
 dependencies = [
  "serde",
+]
+
+[[package]]
+name = "socket2"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
···
 checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
+name = "tokio"
+version = "1.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "toml_datetime"
 version = "0.7.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
 version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
···
  "windows_aarch64_gnullvm 0.52.6",
  "windows_aarch64_msvc 0.52.6",
  "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm",
+ "windows_i686_gnullvm 0.52.6",
  "windows_i686_msvc 0.52.6",
  "windows_x86_64_gnu 0.52.6",
  "windows_x86_64_gnullvm 0.52.6",
···
 ]
 
 [[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link 0.2.1",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
 name = "windows-threading"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
 name = "windows_x86_64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
 name = "winit"

client/Cargo.toml

···
 [package]
-name = "client"
+name = "felix-client"
 version = "0.1.0"
 edition = "2024"
 
···
 bevy = "0.17.3"
 dotenvy = "0.15.7"
 felix-net = { path = '../net' }
+tokio = { version = "1.48.0", features = ["full"] }

client/src/components/mod.rs

···
+pub mod debug_camera;
+pub mod network_interface;
+pub mod remote_player;

client/src/components/network_interface.rs

···
+use std::collections::HashMap;
+
+use bevy::prelude::*;
+use felix_net::{packet::PacketTypes, packets::update_server_position::UpdateServerPositions};
+
+use crate::{debug_camera::DebugCamera, net::{NetClientCommand, connection::Connection}, remote_player::RemotePlayer};
+
+pub fn fixed_update(
+  mut query: Query<(&mut DebugCamera, &mut Transform)>,
+  mut networking: Query<&mut Connection>,
+
+  mut commands: Commands,
+  mut meshes: ResMut<Assets<Mesh>>,
+  mut materials: ResMut<Assets<StandardMaterial>>,
+
+  players: Query<(Entity, &mut RemotePlayer)>
+){
+  let ( _, transform ) = query.single_mut().unwrap();
+  let mut net_manager = networking.single_mut().unwrap();
+
+  let update_pos_packet = UpdateServerPositions {
+    position: transform.translation.clone(),
+    rotation: transform.rotation.clone()
+  };
+
+  net_manager.try_send_unreliable(update_pos_packet).unwrap();
+
+
+  if let Ok(ev) = net_manager.recv_event(){
+    match ev{
+      NetClientCommand::Connected(id) => {
+        println!("[INFO] Connected to server as {}", id);
+      }
+      NetClientCommand::Disconnected => {
+        println!("[WARN] Disconnected from server.");
+      }
+      NetClientCommand::RecvPacket(packet) => {
+        match packet{
+          PacketTypes::PlayerJoinPacket(packet) => {
+            join_players(vec![packet.id], &mut commands, &mut meshes, &mut materials);
+          }
+          PacketTypes::PlayerListPacket(packet) => {
+            join_players(packet.ids, &mut commands, &mut meshes, &mut materials);
+          }
+          PacketTypes::PlayerLeavePacket(packet) => {
+            leave_player(packet.id, &mut commands, players);
+          }
+          PacketTypes::UpdateClientsPositions(packet) => {
+            let mut map = HashMap::new();
+
+            for ( id, pos, rot ) in packet.players{
+              map.insert(id, (pos, rot)); }
+
+            for ( _, mut player ) in players{
+              let ( pos, rot ) = map.get(&player.id).unwrap();
+
+              player.pos = *pos;
+              player.rot = *rot;
+            }
+          }
+          _ => {}
+        }
+      }
+    }
+  }
+}
+
+fn join_players(
+  players: Vec<String>,
+
+  commands: &mut Commands,
+  meshes: &mut ResMut<Assets<Mesh>>,
+  materials: &mut ResMut<Assets<StandardMaterial>>,
+){
+  for id in players{
+    commands.spawn((
+      Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
+      MeshMaterial3d(materials.add(Color::WHITE)),
+      Transform::from_xyz(0.0, 0.0, 0.0),
+      RemotePlayer { id, ..Default::default() }
+    ));
+  }
+}
+
+fn leave_player(
+  id: String,
+
+  commands: &mut Commands,
+
+  players: Query<(Entity, &mut RemotePlayer)>
+){
+  for ( entity, player ) in players{
+    if id == player.id{
+      commands.entity(entity).despawn();
+      break;
+    }
+  }
+}

client/src/components/remote_player.rs

···
+use bevy::{ecs::{component::Component, system::Query}, math::{Quat, Vec3}, transform::components::Transform};
+
+#[derive(Component, Debug, Default)]
+pub struct RemotePlayer{
+  pub id: String,
+
+  pub pos: Vec3,
+  pub rot: Quat
+}
+
+
+pub fn update(
+  players: Query<(&mut Transform, &RemotePlayer)>
+){
+  for ( mut transform, player ) in players{
+    transform.translation = Vec3::lerp(transform.translation, player.pos, 0.5);
+    transform.rotation = Quat::lerp(transform.rotation, player.rot, 0.5);
+  }
+}

client/src/debug_camera.rs client/src/components/debug_camera.rs

···
 
 use bevy::{ input::mouse::MouseMotion, prelude::* };
 
-use crate::net::component::ClientNetworkingManager;
-
 #[derive(Component)]
 pub struct DebugCamera{
   pitch: f32,
···
       yaw: -PI / 2.0
     }
   }
-}
-
-pub fn fixed_update(
-  mut query: Query<(&mut DebugCamera, &mut Transform)>,
-  mut networking: Query<&mut ClientNetworkingManager>
-){
-  let ( _, transform ) = query.single_mut().unwrap();
-  let net_manager = networking.single_mut().unwrap();
-
-  net_manager.update_server_position(transform.translation.clone(), transform.rotation.clone());
 }
 
 pub fn update(

client/src/main.rs

···
-use std::sync::mpsc::channel;
-
 use bevy::{DefaultPlugins, app::{App, FixedUpdate, Startup, Update}, ecs::system::Commands};
 
-use crate::{net::component::ClientNetworkingManager, setup::setup};
-
-mod debug_camera;
+use crate::{components::{debug_camera, network_interface, remote_player}, setup::setup};
 
+mod components;
 mod setup;
 mod net;
 
 fn main() {
   dotenvy::dotenv().unwrap();
 
-  let (sender, recv) = channel();
-  let net_manager = ClientNetworkingManager::from(sender);
-
-  net::handle_net(recv).expect("Network Module Failed.");
-
   App::new()
     .add_plugins(DefaultPlugins)
     .add_systems(Startup, setup)
-    .add_systems(Startup, move | mut commands: Commands | {
-      commands.spawn(net_manager.clone());
+    .add_systems(Startup, move | mut commands: Commands |{
+      commands.spawn(net::handle_net().expect("Network Module Failed."));
     })
     .add_systems(Update, debug_camera::update)
-    .add_systems(FixedUpdate, debug_camera::fixed_update)
+    .add_systems(Update, remote_player::update)
+    .add_systems(FixedUpdate, network_interface::fixed_update)
     .run();
 }

client/src/net/component.rs

···
-use std::sync::mpsc::Sender;
-
-use bevy::{ecs::component::Component, math::{Quat, Vec3}};
-
-#[derive(Debug, Clone)]
-pub enum ClientNetworkingManagerCommand{
-  UpdatePlayerPosition(Vec3, Quat),
-}
-
-#[derive(Component, Debug, Clone)]
-pub struct ClientNetworkingManager{
-  cmd: Sender<ClientNetworkingManagerCommand>
-}
-
-impl From<Sender<ClientNetworkingManagerCommand>> for ClientNetworkingManager{
-  fn from(value: Sender<ClientNetworkingManagerCommand>) -> Self {
-    Self {
-      cmd: value
-    }
-  }
-}
-
-impl ClientNetworkingManager{
-  pub fn update_server_position(&self, pos: Vec3, rot: Quat){
-    self.cmd.send(ClientNetworkingManagerCommand::UpdatePlayerPosition(pos, rot)).unwrap();
-  }
-}

client/src/net/connection.rs

···
-use std::{io::{Read, Write}, net::{SocketAddr, TcpStream, UdpSocket}, sync::mpsc::Sender, thread};
+use std::{io::{Read, Write}, net::{SocketAddr, TcpStream, UdpSocket}, thread};
+use bevy::ecs::component::Component;
+use tokio::sync::broadcast::{self, Receiver, Sender};
 
-use felix_net::{packet::{self, Packet, PacketTypes}, packets::{link_udp::LinkUDP, notify_connection_info::NotifyConnectionInfo}};
+use felix_net::{buffer::Buffer, packet::{self, Packet, PacketTypes}, packets::{link_udp::LinkUDP, notify_connection_info::NotifyConnectionInfo}};
 
 use crate::net::NetClientCommand;
 
 
-#[derive(Debug)]
+#[derive(Component, Debug)]
 pub struct Connection{
   tcp: TcpStream,
 
   udp: UdpSocket,
   udp_server_address: SocketAddr,
 
+  net_recv: Receiver<NetClientCommand>,
+
   pub id: String
 }
 
 impl Connection{
-  pub fn new( stream: TcpStream, udp: UdpSocket, udp_server_address: SocketAddr, cmd: Sender<NetClientCommand> ) -> Self{
+  pub fn new( stream: TcpStream, udp: UdpSocket, udp_server_address: SocketAddr ) -> Self{
+    let ( event_sender, event_recv ) = broadcast::channel(32);
+
     let mut conn = Self {
       tcp: stream,
 
       udp,
       udp_server_address,
 
+      net_recv: event_recv,
+
       id: "".to_owned()
     };
 
-    conn.start_listener_thread(cmd).unwrap();
+    conn.start_listener_thread(event_sender).unwrap();
 
     let packet = NotifyConnectionInfo { id: conn.id.clone() };
     conn.send_reliable(packet).unwrap();
···
       while let Ok((length, addr)) = udp_1.recv_from(&mut buf){
         if addr != srv_addr{ continue; }
 
-        let msg = &buf[0..length];
-        let packet = packet::parse(msg.into());
+        let mut msg: Buffer = (&buf[0..length]).into();
 
-        cmd_1.send(NetClientCommand::RecvPacket(packet)).unwrap();
+        while msg.left() > 0{
+          let packet = packet::parse(&mut msg);
+          cmd_1.send(NetClientCommand::RecvPacket(packet)).unwrap();
+        }
       }
     });
 
···
       while let Ok(length) = tcp.read(&mut buf){
         if length == 0 { break; }
 
-        let msg = &buf[0..length];
-        let packet = packet::parse(msg.into());
+        let mut msg: Buffer = (&buf[0..length]).into();
+
+        while msg.left() > 0{
+          let packet = packet::parse(&mut msg);
 
-        match packet{
-          PacketTypes::NotifyConnectionInfo(info) => {
-            cmd.send(NetClientCommand::Connected(info.id.clone())).unwrap();
+          match packet{
+            PacketTypes::NotifyConnectionInfo(info) => {
+              cmd.send(NetClientCommand::Connected(info.id.clone())).unwrap();
 
-            let packet = LinkUDP { id: info.id };
-            let packet: Vec<_> = packet.to_buf().into();
+              let packet = LinkUDP { id: info.id };
+              let packet: Vec<_> = packet.to_buf().into();
 
-            udp.send_to(&packet, "127.0.0.1:2603").unwrap();
-          },
-          _ => {
-            cmd.send(NetClientCommand::RecvPacket(packet)).unwrap();
+              udp.send_to(&packet, "127.0.0.1:2603").unwrap();
+            },
+            _ => {
+              cmd.send(NetClientCommand::RecvPacket(packet)).unwrap();
+            }
           }
         }
       }
···
     });
 
     Ok(())
+  }
+
+  pub fn recv_event(&mut self) -> anyhow::Result<NetClientCommand>{
+    Ok(self.net_recv.try_recv()?)
   }
 
   pub fn send_reliable(&mut self, packet: impl Packet) -> anyhow::Result<()>{

client/src/net/mod.rs

···
-use std::{net::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpStream, UdpSocket}, sync::mpsc::{Receiver, channel}, thread};
+use std::{env, net::{TcpStream, ToSocketAddrs, UdpSocket}};
 
-use bevy::math::{Quat, Vec3};
-use felix_net::{packet::PacketTypes, packets::update_server_position::UpdateServerPositions};
+use bevy::prelude::*;
+use felix_net::packet::PacketTypes;
 
-use crate::net::{component::ClientNetworkingManagerCommand, connection::Connection};
+use crate::net::connection::Connection;
 
-pub mod component;
-mod connection;
+pub mod connection;
 
+#[derive(Debug, Clone)]
 pub enum NetClientCommand{
   Connected(String),
   Disconnected,
-  UpdatePlayerPosition(Vec3, Quat),
   RecvPacket(PacketTypes)
 }
 
-pub fn ipv4_address(a: u8, b: u8, c: u8, d: u8, port: u16) -> SocketAddr{
-  SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(a, b, c, d), port))
-}
+pub fn handle_net() -> anyhow::Result<Connection>{
+  let addr = env::var("HOST")?.to_socket_addrs()?.nth(0).unwrap();
 
-pub fn handle_net(cmd: Receiver<ClientNetworkingManagerCommand>) -> anyhow::Result<()>{
-  let tcp = TcpStream::connect("127.0.0.1:2603")?;
+  let tcp = TcpStream::connect(addr)?;
   let udp = UdpSocket::bind("0.0.0.0:0")?;
 
-  let ( sender_cmd, recv ) = channel();
-  let sender_cmd_1 = sender_cmd.clone();
-
-  thread::spawn(move || {
-    while let Ok(cmd) = cmd.recv(){
-      match cmd{
-        ClientNetworkingManagerCommand::UpdatePlayerPosition(pos, rot) =>
-          sender_cmd_1.send(NetClientCommand::UpdatePlayerPosition(pos, rot)).unwrap(),
-      }
-    }
-  });
-
-  thread::spawn(move || {
-    let mut conn = Connection::new(tcp, udp, ipv4_address(127, 0, 0, 1, 2603), sender_cmd);
-
-    while let Ok(cmd) = recv.recv(){
-      match cmd{
-        NetClientCommand::Connected(id) => {
-          println!("[INFO] Connected to server as {}", id);
-          conn.id = id;
-        },
-        NetClientCommand::Disconnected => {
-          println!("[WARN] Disconnected from server.");
-        },
-        NetClientCommand::UpdatePlayerPosition(pos, rot) => {
-          let packet = UpdateServerPositions { position: pos, rotation: rot };
-          conn.try_send_unreliable(packet).unwrap();
-        },
-        NetClientCommand::RecvPacket(packet) => {
-          match packet{
-            PacketTypes::PlayerJoinPacket(player) => {
-              dbg!(player);
-            },
-            PacketTypes::PlayerListPacket(players) => {
-              dbg!(players);
-            },
-            PacketTypes::PlayerLeavePacket(player) => {
-              dbg!(player);
-            },
-            _ => {}
-          }
-        }
-      }
-    }
-  });
-
-  Ok(())
+  let conn = Connection::new(tcp, udp, addr);
+  Ok(conn)
 }

net/src/buffer.rs

···
     Self { dat: vec![], pointer: 0 }
   }
 
+  pub fn left(&self) -> usize{
+    self.dat.len() - self.pointer
+  }
+
   pub fn pointer(&mut self, val: usize){
     self.pointer = val;
   }

net/src/packet.rs

···
   }
 };
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum PacketTypes{
   NotifyConnectionInfo(NotifyConnectionInfo),
   LinkUDP(LinkUDP),
···
 }
 
 pub trait Packet{
-  fn from_buf(buf: Buffer) -> Self;
+  fn from_buf(buf: &mut Buffer) -> Self;
   fn to_buf(&self) -> Buffer;
 }
 
-pub fn parse(mut buf: Buffer) -> PacketTypes{
+pub fn parse(buf: &mut Buffer) -> PacketTypes{
   let id = buf.get_u16();
 
   match id{

net/src/packets/link_udp.rs

···
 use crate::{buffer::Buffer, packet::Packet};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct LinkUDP{
   pub id: String
 }
···
     buf
   }
 
-  fn from_buf(mut buf: Buffer) -> Self {
+  fn from_buf(buf: &mut Buffer) -> Self {
     Self { id: buf.get_str() }
   }
 }

net/src/packets/notify_connection_info.rs

···
 use crate::{buffer::Buffer, packet::Packet};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct NotifyConnectionInfo{
   pub id: String
 }
···
     buf
   }
 
-  fn from_buf(mut buf: Buffer) -> Self {
+  fn from_buf(buf: &mut Buffer) -> Self {
     Self { id: buf.get_str() }
   }
 }

net/src/packets/null.rs

···
 use crate::{buffer::Buffer, packet::Packet};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Null;
 
 impl Packet for Null{
···
     Buffer::empty()
   }
 
-  fn from_buf(_: Buffer) -> Self {
+  fn from_buf(_buf: &mut Buffer) -> Self {
     Self {}
   }
 }

net/src/packets/player_join_packet.rs

···
     buf
   }
 
-  fn from_buf(mut buf: Buffer) -> Self {
+  fn from_buf(buf: &mut Buffer) -> Self {
     Self { id: buf.get_str() }
   }
 }

net/src/packets/player_leave_packet.rs

···
     buf
   }
 
-  fn from_buf(mut buf: Buffer) -> Self {
+  fn from_buf(buf: &mut Buffer) -> Self {
     Self { id: buf.get_str() }
   }
 }

net/src/packets/player_list_packet.rs

···
     buf
   }
 
-  fn from_buf(mut buf: Buffer) -> Self {
+  fn from_buf(buf: &mut Buffer) -> Self {
     let mut ids = vec![];
     let length = buf.get_u32();
 

net/src/packets/update_clients_positions.rs

···
     buf
   }
 
-  fn from_buf(mut buf: Buffer) -> Self {
+  fn from_buf(buf: &mut Buffer) -> Self {
     let mut players = vec![];
 
     for _ in 0..buf.get_u32(){

net/src/packets/update_server_position.rs

···
 
 use crate::{buffer::Buffer, packet::Packet};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct UpdateServerPositions{
   pub position: Vec3,
   pub rotation: Quat
···
     buf
   }
 
-  fn from_buf(mut buf: Buffer) -> Self {
+  fn from_buf(buf: &mut Buffer) -> Self {
     Self {
       position: buf.get_vec3(),
       rotation: buf.get_quat()

server/Cargo.toml

···
 [package]
-name = "server"
+name = "felix-server"
 version = "0.1.0"
 edition = "2024"
 

server/src/net/connection.rs

···
 use std::{io::{Read, Write}, net::{SocketAddr, TcpStream}, sync::mpsc::Sender, thread};
 
 use bevy_math::{Quat, Vec3};
-use felix_net::{packet::{self, Packet, PacketTypes}, packets::notify_connection_info::NotifyConnectionInfo};
+use felix_net::{buffer::Buffer, packet::{self, Packet, PacketTypes}, packets::notify_connection_info::NotifyConnectionInfo};
 use nanoid::nanoid;
 
 use crate::net::NetServerCommand;
···
       let mut buf = [0; 1024];
       while let Ok(length) = stream.read(&mut buf) {
         if length == 0 { break; }
-        let msg = &buf[0..length];
+        let mut msg: Buffer = (&buf[0..length]).into();
 
-        let packet = packet::parse(msg.into());
-        cmd.send(NetServerCommand::RecvOverTCP(id.clone(), packet)).unwrap();
+        while msg.left() > 0{
+          let packet = packet::parse(&mut msg);
+          cmd.send(NetServerCommand::RecvOverTCP(id.clone(), packet)).unwrap();
+        }
       }
 
       cmd.send(NetServerCommand::PlayerDisconnect(id)).unwrap();

server/src/net/mod.rs

···
 use std::{collections::HashMap, env, net::{SocketAddr, TcpListener, TcpStream, UdpSocket}, sync::mpsc::channel, thread, time::Duration};
 
-use felix_net::{packet::{self, PacketTypes}, packets::{player_join_packet::PlayerJoinPacket, player_leave_packet::PlayerLeavePacket, player_list_packet::PlayerListPacket, update_clients_positions::UpdateClientsPositions}};
+use felix_net::{buffer::Buffer, packet::{self, PacketTypes}, packets::{player_join_packet::PlayerJoinPacket, player_leave_packet::PlayerLeavePacket, player_list_packet::PlayerListPacket, update_clients_positions::UpdateClientsPositions}};
 
 use crate::net::connection::Connection;
 
···
 
     loop {
       let ( length, address ) = udp_listener.recv_from(&mut buf).unwrap();
+      let mut msg: Buffer = (&buf[0..length]).into();
 
-      let msg = &buf[0..length];
-      let packet = packet::parse(msg.into());
+      while msg.left() > 0{
+        let packet = packet::parse(&mut msg);
 
-      match packet{
-        PacketTypes::LinkUDP(info) => {
-          sender_1.send(NetServerCommand::LinkUDP(info.id, address)).unwrap();
-        }
-        _ => {
-          sender_1.send(NetServerCommand::RecvOverUDP(address, packet)).unwrap();
+        match packet{
+          PacketTypes::LinkUDP(info) => {
+            sender_1.send(NetServerCommand::LinkUDP(info.id, address)).unwrap();
+          }
+          _ => {
+            sender_1.send(NetServerCommand::RecvOverUDP(address, packet)).unwrap();
+          }
         }
       }
     }