player updating stuff

src/net/client/mod.rs

···
   let mut tcp = TcpStream::connect("127.0.0.1:2603")?;
   let udp = UdpSocket::bind("0.0.0.0:0")?;
 
+  // TODO: Proper player networking controller
+
   thread::spawn(move || {
     let mut buf = [0; 1024];
 

src/net/packet.rs

···
   packets::{
     link_udp::LinkUDP,
     notify_connection_info::NotifyConnectionInfo,
-    null::Null
+    null::Null, update_server_position::UpdateServerPositions
   }
 };
 
 #[derive(Debug)]
 pub enum PacketTypes{
+  UpdateServerPositions(UpdateServerPositions),
   NotifyConnectionInfo(NotifyConnectionInfo),
   LinkUDP(LinkUDP),
   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)),
     _ => PacketTypes::Null(Null::from_buf(buf))
   }
 }

src/net/packets/mod.rs

···
 pub mod notify_connection_info;
 pub mod link_udp;
-pub mod null;
+pub mod update_server_position;
+
+pub mod null;

src/net/packets/update_server_position.rs

···
+use bevy::math::{Quat, Vec3};
+
+use crate::net::{buffer::Buffer, packet::Packet};
+
+#[derive(Debug)]
+pub struct UpdateServerPositions{
+  pub position: Vec3,
+  pub rotation: Quat
+}
+
+impl Packet for UpdateServerPositions{
+  fn to_buf(&self) -> Buffer {
+    let mut buf = Buffer::empty();
+    buf.set_u16(2);
+
+    buf.set_f32(self.position.x);
+    buf.set_f32(self.position.y);
+    buf.set_f32(self.position.z);
+
+    buf.set_f32(self.rotation.x);
+    buf.set_f32(self.rotation.y);
+    buf.set_f32(self.rotation.z);
+    buf.set_f32(self.rotation.w);
+
+    buf
+  }
+
+  fn from_buf(mut buf: Buffer) -> Self {
+    Self {
+      position: Vec3 { x: buf.get_f32(), y: buf.get_f32(), z: buf.get_f32() },
+      rotation: Quat::from_xyzw(buf.get_f32(), buf.get_f32(), buf.get_f32(), buf.get_f32())
+    }
+  }
+}

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 crate::net::{packet::{self, PacketTypes}, server::{connection::Connection, remote_player::RemotePlayer}};
 
 pub mod connection;
···
       NetServerCommand::CreateConnection(socket) => {
         let conn = Connection::new(socket, sender_3.clone());
         let player = RemotePlayer {
-          id: conn.id.clone()
+          id: conn.id.clone(),
+          position: Vec3::default(),
+          rotation: Quat::default()
         };
 
         println!("[INFO] Connected {}", conn.id);

src/net/server/remote_player.rs

···
+use bevy::math::{ Quat, Vec3 };
+
 pub struct RemotePlayer{
   pub id: String,
+  pub position: Vec3,
+  pub rotation: Quat
 }