stuff i wrote while bored at uni

src/client/debug_camera.rs

···
+use std::f32::consts::PI;
+
+use bevy::{ input::mouse::MouseMotion, prelude::* };
+
+use crate::net::client::component::ClientNetworkingManager;
+
+#[derive(Component)]
+pub struct DebugCamera{
+  pitch: f32,
+  yaw: f32
+}
+
+impl Default for DebugCamera{
+  fn default() -> Self {
+    Self {
+      pitch: 0.0,
+      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(
+  mut query: Query<(&mut DebugCamera, &mut Transform)>,
+
+  time: Res<Time>,
+
+  keys: Res<ButtonInput<KeyCode>>,
+  mouse_buttons: Res<ButtonInput<MouseButton>>,
+  mut mouse_motion: MessageReader<MouseMotion>,
+){
+  let mut delta_time = time.delta_secs();
+  if keys.pressed(KeyCode::ShiftLeft){ delta_time *= 2.0; }
+
+  let ( mut debug, mut transform ) = query.single_mut().unwrap();
+
+  for ev in mouse_motion.read(){
+    if mouse_buttons.pressed(MouseButton::Right){
+      debug.pitch -= ev.delta.y * delta_time * 0.1;
+      debug.yaw -= ev.delta.x * delta_time * 0.1;
+    }
+  }
+
+  transform.rotation = Quat::from_euler(EulerRot::YXZ, debug.yaw, debug.pitch, 0.0);
+
+  if keys.pressed(KeyCode::KeyW){
+    let dir = transform.forward();
+    transform.translation += dir * delta_time;
+  } else if keys.pressed(KeyCode::KeyS){
+    let dir = -transform.forward();
+    transform.translation += dir * delta_time;
+  }
+
+  if keys.pressed(KeyCode::KeyA){
+    let dir = transform.left();
+    transform.translation += dir * delta_time;
+  } else if keys.pressed(KeyCode::KeyD){
+    let dir = -transform.left();
+    transform.translation += dir * delta_time;
+  }
+
+  if keys.pressed(KeyCode::KeyE){
+    let dir = transform.up();
+    transform.translation += dir * delta_time;
+  } else if keys.pressed(KeyCode::KeyQ){
+    let dir = -transform.up();
+    transform.translation += dir * delta_time;
+  }
+}

src/engine/debug_camera.rs

···
-use std::f32::consts::PI;
-
-use bevy::{ input::mouse::MouseMotion, prelude::* };
-
-#[derive(Component)]
-pub struct DebugCamera{
-  pitch: f32,
-  yaw: f32
-}
-
-impl Default for DebugCamera{
-  fn default() -> Self {
-    Self {
-      pitch: 0.0,
-      yaw: -PI / 2.0
-    }
-  }
-}
-
-pub fn setup(
-  mut query: Query<(&mut DebugCamera, &mut Transform)>,
-  time: Res<Time>,
-
-  keys: Res<ButtonInput<KeyCode>>,
-  mouse_buttons: Res<ButtonInput<MouseButton>>,
-  mut mouse_motion: MessageReader<MouseMotion>,
-){
-  let mut delta_time = time.delta_secs();
-  if keys.pressed(KeyCode::ShiftLeft){ delta_time *= 2.0; }
-
-  for ( mut debug, mut transform ) in &mut query{
-    for ev in mouse_motion.read(){
-      if mouse_buttons.pressed(MouseButton::Right){
-        debug.pitch -= ev.delta.y * delta_time * 0.1;
-        debug.yaw -= ev.delta.x * delta_time * 0.1;
-      }
-    }
-
-    transform.rotation = Quat::from_euler(EulerRot::YXZ, debug.yaw, debug.pitch, 0.0);
-
-    if keys.pressed(KeyCode::KeyW){
-      let dir = transform.forward();
-      transform.translation += dir * delta_time;
-    } else if keys.pressed(KeyCode::KeyS){
-      let dir = -transform.forward();
-      transform.translation += dir * delta_time;
-    }
-
-    if keys.pressed(KeyCode::KeyA){
-      let dir = transform.left();
-      transform.translation += dir * delta_time;
-    } else if keys.pressed(KeyCode::KeyD){
-      let dir = -transform.left();
-      transform.translation += dir * delta_time;
-    }
-
-    if keys.pressed(KeyCode::KeyE){
-      let dir = transform.up();
-      transform.translation += dir * delta_time;
-    } else if keys.pressed(KeyCode::KeyQ){
-      let dir = -transform.up();
-      transform.translation += dir * delta_time;
-    }
-  }
-}

src/main.rs

···
-use bevy::app::{ App, Startup };
-
 mod net;
 mod util;
 
 #[cfg(feature = "client")]
-mod engine;
+mod client;
 
 fn main() {
-  let mut app = App::new();
-  app.add_systems(Startup, move || net::handle_net().expect("Network Module Failed."));
+
+  #[cfg(not(feature = "client"))]
+  net::handle_net().expect("Network Module Failed.");
 
   #[cfg(feature = "client")]
   {
-    use bevy::{DefaultPlugins, app::Update};
-    app.add_plugins(DefaultPlugins);
+    use std::sync::mpsc::channel;
 
-    app.add_systems(Startup, engine::setup);
-    app.add_systems(Update, engine::debug_camera::setup);
-  }
+    use bevy::{DefaultPlugins, app::{App, FixedUpdate, Startup, Update}, ecs::system::Commands};
 
-  app.run();
+    use crate::net::client::component::ClientNetworkingManager;
+
+    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, client::setup)
+      .add_systems(Startup, move | mut commands: Commands | {
+        commands.spawn(net_manager.clone());
+      })
+      .add_systems(Update, client::debug_camera::update)
+      .add_systems(FixedUpdate, client::debug_camera::fixed_update)
+      .run();
+  }
 }

src/net/client/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();
+  }
+}

src/net/client/mod.rs

···
-use std::{io::Read, net::{TcpStream, UdpSocket}, thread};
+use std::{net::{TcpStream, UdpSocket}, sync::mpsc::{Receiver, channel}, thread};
 
-use crate::net::{packet::{self, Packet, PacketTypes}, packets::link_udp::LinkUDP};
+use bevy::math::{Quat, Vec3};
 
-pub fn handle_net_client() -> anyhow::Result<()>{
-  let mut tcp = TcpStream::connect("127.0.0.1:2603")?;
-  let udp = UdpSocket::bind("0.0.0.0:0")?;
+use crate::{net::{client::component::ClientNetworkingManagerCommand, connection::Connection, packet::PacketTypes, packets::update_server_position::UpdateServerPositions}, util::net::ipv4_address};
 
-  // TODO: Proper player networking controller
+pub mod component;
 
-  thread::spawn(move || {
-    let mut buf = [0; 1024];
+pub enum NetClientCommand{
+  Connected(String),
+  Disconnected,
+  UpdatePlayerPosition(Vec3, Quat),
+  RecvPacket(PacketTypes)
+}
 
-    while let Ok(length) = tcp.read(&mut buf){
-      if length == 0 { break; }
+pub fn handle_net_client(cmd: Receiver<ClientNetworkingManagerCommand>) -> anyhow::Result<()>{
+  let tcp = TcpStream::connect("127.0.0.1:2603")?;
+  let udp = UdpSocket::bind("0.0.0.0:0")?;
 
-      let msg = &buf[0..length];
-      let packet = packet::parse(msg.into());
+  let ( sender_cmd, recv ) = channel();
+  let sender_cmd_1 = sender_cmd.clone();
 
-      match packet{
-        PacketTypes::NotifyConnectionInfo(info) => {
-          dbg!(&info);
+  thread::spawn(move || {
+    while let Ok(cmd) = cmd.recv(){
+      match cmd{
+        ClientNetworkingManagerCommand::UpdatePlayerPosition(pos, rot) =>
+          sender_cmd_1.send(NetClientCommand::UpdatePlayerPosition(pos, rot)).unwrap(),
+      }
+    }
+  });
 
-          let packet = LinkUDP { id: info.id };
-          let packet: Vec<_> = packet.to_buf().into();
+  thread::spawn(move || {
+    let mut conn = Connection::new(tcp, udp,ipv4_address(127, 0, 0, 1, 2603), sender_cmd);
 
-          udp.send_to(&packet, "127.0.0.1:2603").unwrap();
+    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);
+            },
+            _ => {}
+          }
+        }
       }
     }
-
-    println!("[WARN] Client disconnected from server");
   });
 
   Ok(())

src/net/connection.rs

···
+use std::{fs, io::{Read, Write}, net::{SocketAddr, TcpStream, UdpSocket}, sync::mpsc::Sender, thread};
+
+use nanoid::nanoid;
+
+#[cfg(feature = "client")]
+use crate::net::{client::NetClientCommand, packets::link_udp::LinkUDP};
+#[cfg(not(feature = "client"))]
+use crate::net::{server::NetServerCommand, packets::notify_connection_info::NotifyConnectionInfo};
+
+use crate::net::packet::{self, Packet, PacketTypes};
+
+#[derive(Debug)]
+pub struct Connection{
+  tcp: TcpStream,
+
+  #[cfg(not(feature = "client"))]
+  udp: Option<SocketAddr>,
+  #[cfg(not(feature = "client"))]
+  main_thread_sender: Sender<NetServerCommand>,
+
+  #[cfg(feature = "client")]
+  udp: UdpSocket,
+  #[cfg(feature = "client")]
+  udp_server_address: SocketAddr,
+
+  pub id: String
+}
+
+impl Connection{
+  #[cfg(not(feature = "client"))]
+  pub fn new( stream: TcpStream, cmd: Sender<NetServerCommand> ) -> Self{
+    let mut conn = Self {
+      tcp: stream,
+      main_thread_sender: cmd.clone(),
+      udp: None,
+
+      id: nanoid!()
+    };
+
+    conn.start_listener_thread(cmd).unwrap();
+
+    let packet = NotifyConnectionInfo::from(&conn);
+    conn.send_reliable(packet).unwrap();
+
+    conn
+  }
+
+  #[cfg(not(feature = "client"))]
+  fn start_listener_thread(&self, cmd: Sender<NetServerCommand>) -> anyhow::Result<()>{
+    let mut stream = self.tcp.try_clone()?;
+    let id = self.id.clone();
+
+    thread::spawn(move || {
+      let mut buf = [0; 1024];
+      while let Ok(length) = stream.read(&mut buf) {
+        if length == 0 { break; }
+        let msg = &buf[0..length];
+
+        let packet = packet::parse(msg.into());
+      }
+
+      cmd.send(NetServerCommand::PlayerDisconnect(id)).unwrap();
+    });
+
+    Ok(())
+  }
+
+  #[cfg(feature = "client")]
+  pub fn new( tcp: TcpStream, udp: UdpSocket, udp_server_address: SocketAddr, cmd: Sender<NetClientCommand> ) -> Self{
+    let mut conn = Self {
+      tcp: tcp,
+      udp: udp,
+      udp_server_address: udp_server_address,
+
+      id: "".to_owned()
+    };
+
+    conn.start_listener_thread(cmd).unwrap();
+
+    conn
+  }
+
+  #[cfg(feature = "client")]
+  fn start_listener_thread(&self, cmd: Sender<NetClientCommand>) -> anyhow::Result<()>{
+    let mut tcp = self.tcp.try_clone()?;
+    let udp = self.udp.try_clone()?;
+
+    let udp_1 = self.udp.try_clone()?;
+    let cmd_1 = cmd.clone();
+
+    let srv_addr = self.udp_server_address.clone();
+
+    thread::spawn(move || { // UDP RECV THREAD
+      let mut buf = [0; 1024];
+
+      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());
+
+        cmd_1.send(NetClientCommand::RecvPacket(packet)).unwrap();
+      }
+    });
+
+    thread::spawn(move || { // TCP RECV THREAD
+      let mut buf = [0; 1024];
+
+      while let Ok(length) = tcp.read(&mut buf){
+        if length == 0 { break; }
+
+        let msg = &buf[0..length];
+        let packet = packet::parse(msg.into());
+
+        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();
+
+            udp.send_to(&packet, "127.0.0.1:2603").unwrap();
+          },
+          _ => {
+            cmd.send(NetClientCommand::RecvPacket(packet)).unwrap();
+          }
+        }
+      }
+
+      cmd.send(NetClientCommand::Disconnected).unwrap();
+    });
+
+    Ok(())
+  }
+
+  #[cfg(not(feature = "client"))]
+  pub fn connect_udp(&mut self, address: SocketAddr){
+    self.udp = Some(address);
+  }
+
+  pub fn send_reliable(&mut self, packet: impl Packet) -> anyhow::Result<()>{
+    let buf: Vec<u8> = packet.to_buf().into();
+    self.tcp.write(&buf)?;
+
+    Ok(())
+  }
+
+  pub fn try_send_unreliable(&mut self, packet: impl Packet) -> anyhow::Result<()>{
+    let buf: Vec<u8> = packet.to_buf().into();
+
+    #[cfg(not(feature = "client"))]
+    {
+      if let Some(addr) = self.udp{
+        self.main_thread_sender.send(NetServerCommand::SendOverUDP(buf, addr))?;
+      } else{
+        println!("[WARN] Cannot send unreliable packet to {}, using TCP instead.", self.id);
+        self.tcp.write(&buf)?;
+      }
+    }
+
+    #[cfg(feature = "client")]
+    self.udp.send_to(&buf, self.udp_server_address)?;
+
+    Ok(())
+  }
+}

src/net/mod.rs

···
 #[cfg(feature = "client")]
-mod client;
+use std::sync::mpsc::Receiver;
+
+#[cfg(feature = "client")]
+use crate::net::client::component::ClientNetworkingManagerCommand;
 
+#[cfg(feature = "client")]
+pub mod client;
+
+#[cfg(not(feature = "client"))]
 mod server;
 
 mod packet;
 mod packets;
 mod buffer;
 
-pub fn handle_net() -> anyhow::Result<()>{
-  #[cfg(feature = "client")]
-  return client::handle_net_client();
+mod connection;
 
+#[cfg(feature = "client")]
+pub fn handle_net( cmd: Receiver<ClientNetworkingManagerCommand> ) -> anyhow::Result<()>{
+  client::handle_net_client(cmd)
+}
+
+  #[cfg(not(feature = "client"))]
+pub fn handle_net() -> anyhow::Result<()>{
   server::handle_net_server()
 }

src/net/packet.rs

···
 use crate::net::{
   buffer::Buffer,
   packets::{
-    link_udp::LinkUDP,
-    notify_connection_info::NotifyConnectionInfo,
-    null::Null, update_server_position::UpdateServerPositions
+    link_udp::LinkUDP, notify_connection_info::NotifyConnectionInfo, null::Null, player_join_packet::PlayerJoinPacket, player_leave_packet::PlayerLeavePacket, player_list_packet::PlayerListPacket, update_server_position::UpdateServerPositions
   }
 };
 
 #[derive(Debug)]
 pub enum PacketTypes{
-  UpdateServerPositions(UpdateServerPositions),
   NotifyConnectionInfo(NotifyConnectionInfo),
   LinkUDP(LinkUDP),
+
+  UpdateServerPositions(UpdateServerPositions),
+
+  PlayerJoinPacket(PlayerJoinPacket),
+  PlayerListPacket(PlayerListPacket),
+  PlayerLeavePacket(PlayerLeavePacket),
+
   Null(Null)
 }
 
···
   match id{
     0 => PacketTypes::NotifyConnectionInfo(NotifyConnectionInfo::from_buf(buf)),
     1 => PacketTypes::LinkUDP(LinkUDP::from_buf(buf)),
+
     2 => PacketTypes::UpdateServerPositions(UpdateServerPositions::from_buf(buf)),
+
+    3 => PacketTypes::PlayerJoinPacket(PlayerJoinPacket::from_buf(buf)),
+    4 => PacketTypes::PlayerListPacket(PlayerListPacket::from_buf(buf)),
+    5 => PacketTypes::PlayerLeavePacket(PlayerLeavePacket::from_buf(buf)),
+
     _ => PacketTypes::Null(Null::from_buf(buf))
   }
 }

src/net/packets/mod.rs

···
 pub mod notify_connection_info;
 pub mod link_udp;
+
 pub mod update_server_position;
+
+pub mod player_join_packet;
+pub mod player_list_packet;
+pub mod player_leave_packet;
 
 pub mod null;

src/net/packets/notify_connection_info.rs

···
-use crate::net::{buffer::Buffer, server::connection::Connection, packet::Packet};
+use crate::net::{buffer::Buffer, connection::Connection, packet::Packet};
 
 #[derive(Debug)]
 pub struct NotifyConnectionInfo{

src/net/packets/player_join_packet.rs

···
+use crate::net::{buffer::Buffer, packet::Packet};
+
+#[derive(Debug, Clone)]
+pub struct PlayerJoinPacket{
+  pub id: String
+}
+
+impl Packet for PlayerJoinPacket{
+  fn to_buf(&self) -> Buffer {
+    let mut buf = Buffer::empty();
+    buf.set_u16(3);
+    buf.set_str(self.id.clone());
+
+    buf
+  }
+
+  fn from_buf(mut buf: Buffer) -> Self {
+    Self { id: buf.get_str() }
+  }
+}

src/net/packets/player_leave_packet.rs

···
+use crate::net::{buffer::Buffer, packet::Packet};
+
+#[derive(Debug, Clone)]
+pub struct PlayerLeavePacket{
+  pub id: String
+}
+
+impl Packet for PlayerLeavePacket{
+  fn to_buf(&self) -> Buffer {
+    let mut buf = Buffer::empty();
+    buf.set_u16(5);
+    buf.set_str(self.id.clone());
+
+    buf
+  }
+
+  fn from_buf(mut buf: Buffer) -> Self {
+    Self { id: buf.get_str() }
+  }
+}

src/net/packets/player_list_packet.rs

···
+use crate::net::{buffer::Buffer, packet::Packet};
+
+#[derive(Debug, Clone)]
+pub struct PlayerListPacket{
+  pub ids: Vec<String>
+}
+
+impl Packet for PlayerListPacket{
+  fn to_buf(&self) -> Buffer {
+    let mut buf = Buffer::empty();
+    buf.set_u16(4);
+    buf.set_u32(self.ids.len() as u32);
+
+    for id in &self.ids{ buf.set_str(id.clone()); }
+    buf
+  }
+
+  fn from_buf(mut buf: Buffer) -> Self {
+    let mut ids = vec![];
+    let length = buf.get_u32();
+
+    for _ in 0..length{ ids.push(buf.get_str()); }
+    Self { ids }
+  }
+}

src/net/server/connection.rs

···
-use std::{fs, io::{Read, Write}, net::{SocketAddr, TcpStream, UdpSocket}, sync::mpsc::Sender, thread};
-
-use nanoid::nanoid;
-
-use crate::net::{packet::Packet, packets::notify_connection_info::NotifyConnectionInfo, server::NetServerCommand};
-
-#[derive(Debug)]
-pub struct Connection{
-  tcp: TcpStream,
-  udp: Option<SocketAddr>,
-
-  pub id: String
-}
-
-impl Connection{
-  pub fn new( stream: TcpStream, cmd: Sender<NetServerCommand> ) -> Self{
-    let mut conn = Self {
-      tcp: stream,
-      udp: None,
-
-      id: nanoid!()
-    };
-
-    conn.start_listener_thread(cmd).unwrap();
-
-    let packet = NotifyConnectionInfo::from(&conn);
-    conn.send_reliable(packet).unwrap();
-
-    conn
-  }
-
-  fn start_listener_thread(&self, cmd: Sender<NetServerCommand>) -> anyhow::Result<()>{
-    let mut stream = self.tcp.try_clone()?;
-    let id = self.id.clone();
-
-    thread::spawn(move || {
-      let mut buf = [0; 1024];
-      while let Ok(length) = stream.read(&mut buf) {
-        if length == 0 { break; }
-        let msg = &buf[0..length];
-      }
-
-      cmd.send(NetServerCommand::PlayerDisconnect(id)).unwrap();
-    });
-
-    Ok(())
-  }
-
-  pub fn connect_udp(&mut self, address: SocketAddr){
-    self.udp = Some(address);
-  }
-
-  pub fn send_reliable(&mut self, packet: impl Packet) -> anyhow::Result<()>{
-    let buf: Vec<u8> = packet.to_buf().into();
-    self.tcp.write(&buf)?;
-
-    Ok(())
-  }
-
-  pub fn try_send_unreliable(&mut self, packet: impl Packet) -> anyhow::Result<()>{
-    let buf: Vec<u8> = packet.to_buf().into();
-
-    if let Some(addr) = self.udp{
-      UdpSocket::bind("0.0.0.0:0")?.send_to(&buf, addr)?; // TODO: Use shared UDP Socket.
-    } else{
-      println!("[WARN] Cannot send unreliable packet to {}, using TCP instead.", self.id);
-      self.tcp.write(&buf)?;
-    }
-
-    Ok(())
-  }
-}

src/net/server/mod.rs

···
 use std::{collections::HashMap, net::{SocketAddr, TcpListener, TcpStream, UdpSocket}, sync::mpsc::channel, thread};
 
-use bevy::math::{Quat, Vec3, VectorSpace};
+use bevy::math::{Quat, Vec3};
 
-use crate::net::{packet::{self, PacketTypes}, server::{connection::Connection, remote_player::RemotePlayer}};
+use crate::net::{connection::Connection, packet::{self, PacketTypes}, packets::{player_join_packet::PlayerJoinPacket, player_leave_packet::PlayerLeavePacket, player_list_packet::{self, PlayerListPacket}}, server::remote_player::RemotePlayer};
 
-pub mod connection;
 pub mod remote_player;
 
 pub enum NetServerCommand{
   CreateConnection(TcpStream),
   LinkUDP(String, SocketAddr),
-  PlayerDisconnect(String)
+  PlayerDisconnect(String),
+  SendOverUDP(Vec<u8>, SocketAddr),
+  RecvOverUDP(SocketAddr, PacketTypes)
 }
 
 pub fn handle_net_server() -> anyhow::Result<()>{
   let tcp_listener = TcpListener::bind("0.0.0.0:2603")?;
+
   let udp_listener = UdpSocket::bind("0.0.0.0:2603")?;
+  let udp_listener_1 = udp_listener.try_clone()?;
 
-  let ( sender_1, recv ) = channel();
-  let sender_2 = sender_1.clone();
-  let sender_3 = sender_1.clone();
+  let ( sender, recv ) = channel();
+  let sender_1 = sender.clone();
+  let sender_2 = sender.clone();
 
   thread::spawn(move || {
     loop {
       let ( socket, _ ) = tcp_listener.accept().unwrap();
-      sender_1.send(NetServerCommand::CreateConnection(socket)).unwrap();
+      sender.send(NetServerCommand::CreateConnection(socket)).unwrap();
     }
   });
 
···
 
       match packet{
         PacketTypes::LinkUDP(info) => {
-          sender_2.send(NetServerCommand::LinkUDP(info.id, address)).unwrap();
+          sender_1.send(NetServerCommand::LinkUDP(info.id, address)).unwrap();
+        }
+        _ => {
+          sender_1.send(NetServerCommand::RecvOverUDP(address, packet)).unwrap();
         }
-        _ => {}
       }
     }
   });
 
-  let mut connections = HashMap::new();
-  let mut players = HashMap::new();
+  let mut connections: HashMap<String, Connection> = HashMap::new();
+  let mut connections_by_address: HashMap<SocketAddr, String> = HashMap::new();
+
+  let mut players: HashMap<String, RemotePlayer> = HashMap::new();
 
   while let Ok(cmd) = recv.recv(){
     match cmd{
       NetServerCommand::CreateConnection(socket) => {
-        let conn = Connection::new(socket, sender_3.clone());
+        let mut conn = Connection::new(socket, sender_2.clone());
         let player = RemotePlayer {
           id: conn.id.clone(),
           position: Vec3::default(),
···
 
         println!("[INFO] Connected {}", conn.id);
 
+        let player_join_packet = PlayerJoinPacket { id: conn.id.clone() };
+
+        for ( _, player ) in &mut connections{
+          player.send_reliable(player_join_packet.clone())?;
+        }
+
+        let player_list_packet = PlayerListPacket {
+          ids: players.iter().map(|(id,_)| id.clone()).collect()
+        };
+
+        conn.send_reliable(player_list_packet).unwrap();
+
         connections.insert(conn.id.clone(), conn);
         players.insert(player.id.clone(), player);
       }
       NetServerCommand::LinkUDP(id, addr) => {
         if let Some(conn) = connections.get_mut(&id){
+          connections_by_address.insert(addr.clone(), id);
           conn.connect_udp(addr);
         }
       },
···
         players.remove(&id);
         connections.remove(&id);
 
+        let player_leave_packet = PlayerLeavePacket { id: id.clone() };
+
+        for ( _, player ) in &mut connections{
+          player.send_reliable(player_leave_packet.clone())?;
+        }
+
         println!("[INFO] Disconnected {}", id);
+      },
+      NetServerCommand::SendOverUDP(buf, addr) => {
+        udp_listener_1.send_to(&buf, addr)?;
+      },
+      NetServerCommand::RecvOverUDP(addr, packet) => {
+        let conn_id = &connections_by_address[&addr];
+        let conn = &connections[conn_id];
+
+
       }
     }
   }

src/util/mod.rs

···
-pub mod angles;
+pub mod angles;
+pub mod net;

src/util/net.rs

···
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
+
+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))
+}