From 02d65e6b7ce7a0e6bae054bd321c68dda1cb0de3 Mon Sep 17 00:00:00 2001
From: metamuffin <metamuffin@disroot.org>
Date: Tue, 7 Jan 2025 22:56:34 +0100
Subject: static typing for resources

---
 shared/src/packets.rs | 99 +++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 81 insertions(+), 18 deletions(-)

(limited to 'shared/src/packets.rs')

diff --git a/shared/src/packets.rs b/shared/src/packets.rs
index 9cecbe2..1d3155f 100644
--- a/shared/src/packets.rs
+++ b/shared/src/packets.rs
@@ -14,15 +14,31 @@
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
+use crate::resources::{Prefab, PrefabIndex};
 use anyhow::{Result, bail};
 use glam::Vec3A;
 use std::{
     fmt::{Debug, Display},
+    hash::Hash,
     io::{Read, Write},
+    marker::PhantomData,
 };
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
-pub struct Resource(pub [u8; 32]);
+#[derive(Clone, Copy)]
+pub struct Resource<T = ()>(pub [u8; 32], pub PhantomData<T>);
+
+impl<T> PartialEq for Resource<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+impl<T> Eq for Resource<T> {}
+impl<T> Hash for Resource<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Object(pub u128);
 
@@ -35,12 +51,14 @@ pub enum Packet {
     Disconnect,
     RequestResource(Resource),
     RespondResource(Data),
-    Add(Object, Resource),
+    Add(Object, Resource<Prefab>),
     Remove(Object),
     Position(Object, Vec3A, Vec3A),
     Pose(Object, Vec<f32>),
     Parent(Object, Object),
     Sound(Object, Data),
+    PrefabIndex(Resource<PrefabIndex>),
+    PrefabName(Resource, String),
 }
 
 pub trait ReadWrite: Sized {
@@ -84,17 +102,13 @@ impl Packet {
             }
             Packet::Remove(object) => {
                 w.write_all(&[0x04])?;
-                w.write_all(&object.0.to_be_bytes())?;
+                object.write(w)?;
             }
             Packet::Position(object, pos, rot) => {
                 w.write_all(&[0x05])?;
                 w.write_all(&object.0.to_be_bytes())?;
-                w.write_all(&pos.x.to_be_bytes())?;
-                w.write_all(&pos.y.to_be_bytes())?;
-                w.write_all(&pos.z.to_be_bytes())?;
-                w.write_all(&rot.x.to_be_bytes())?;
-                w.write_all(&rot.y.to_be_bytes())?;
-                w.write_all(&rot.z.to_be_bytes())?;
+                pos.write(w)?;
+                rot.write(w)?;
             }
             Packet::Pose(object, vec) => {
                 w.write_all(&[0x06])?;
@@ -111,6 +125,15 @@ impl Packet {
                 w.write_all(&object.0.to_be_bytes())?;
                 data.write(w)?;
             }
+            Packet::PrefabIndex(resource) => {
+                w.write_all(&[0x09])?;
+                resource.write(w)?;
+            }
+            Packet::PrefabName(resource, name) => {
+                w.write_all(&[0x0a])?;
+                resource.write(w)?;
+                name.write(w)?;
+            }
         }
         Ok(())
     }
@@ -154,21 +177,42 @@ fn read_u128(r: &mut dyn Read) -> Result<u128> {
     r.read_exact(&mut buf)?;
     Ok(u128::from_be_bytes(buf))
 }
-impl ReadWrite for Resource {
+impl<T> ReadWrite for Resource<T> {
     fn write(&self, w: &mut dyn Write) -> Result<()> {
         w.write_all(&self.0)?;
         Ok(())
     }
     fn read(r: &mut dyn Read) -> Result<Self> {
-        let mut s = Self([0; 32]);
+        let mut s = Self([0; 32], PhantomData);
         r.read_exact(&mut s.0)?;
         Ok(s)
     }
 }
+impl ReadWrite for Object {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        w.write_all(&self.0.to_be_bytes())?;
+        Ok(())
+    }
+
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut s = [0; 16];
+        r.read_exact(&mut s)?;
+        Ok(Object(u128::from_be_bytes(s)))
+    }
+}
+
 impl ReadWrite for Data {
     fn write(&self, w: &mut dyn Write) -> Result<()> {
-        w.write_all(&(self.0.len() as u32).to_be_bytes())?;
-        w.write_all(&self.0)?;
+        self.0.write(w)
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        Ok(Self(Vec::read(r)?))
+    }
+}
+impl ReadWrite for Vec<u8> {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        w.write_all(&(self.len() as u32).to_be_bytes())?;
+        w.write_all(&self)?;
         Ok(())
     }
     fn read(r: &mut dyn Read) -> Result<Self> {
@@ -177,7 +221,22 @@ impl ReadWrite for Data {
         let size = u32::from_be_bytes(size);
         let mut buf = vec![0; size as usize];
         r.read_exact(&mut buf)?;
-        Ok(Data(buf))
+        Ok(buf)
+    }
+}
+impl ReadWrite for String {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        w.write_all(&(self.len() as u32).to_be_bytes())?;
+        w.write_all(self.as_bytes())?;
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut size = [0; 4];
+        r.read_exact(&mut size)?;
+        let size = u32::from_be_bytes(size);
+        let mut buf = vec![0; size as usize];
+        r.read_exact(&mut buf)?;
+        Ok(String::from_utf8(buf)?)
     }
 }
 fn read_params(r: &mut dyn Read) -> Result<Vec<f32>> {
@@ -214,7 +273,7 @@ impl ReadWrite for u32 {
     }
 }
 
-impl Display for Resource {
+impl<T> Display for Resource<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
@@ -226,8 +285,7 @@ impl Display for Resource {
         )
     }
 }
-
-impl Debug for Resource {
+impl<T> Debug for Resource<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self)
     }
@@ -250,3 +308,8 @@ impl Debug for Data {
         f.debug_tuple("Data").finish_non_exhaustive()
     }
 }
+impl Display for Object {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Object").field(&self.0).finish()
+    }
+}
-- 
cgit v1.2.3-70-g09d2