From 50883aea217adfc31df9dc3191967cdc45f6d511 Mon Sep 17 00:00:00 2001
From: Sarah Bradley <git@sarahduck.ca>
Date: Sun, 19 May 2024 16:52:35 -0700
Subject: Simplified RPC stuff

---
 Net.cs | 69 +++++++++++++++++++++++++++++++++---------------------------------
 1 file changed, 34 insertions(+), 35 deletions(-)

diff --git a/Net.cs b/Net.cs
index 36ff97d..58e829b 100644
--- a/Net.cs
+++ b/Net.cs
@@ -1,60 +1,59 @@
-using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace SarahEngine;
 
-public interface INetworkable<T>
+public static class NetExtensions
 {
-    void ToBytes(Span<byte> span);
-    static abstract T FromBytes(ReadOnlySpan<byte> span);
-    static int SizeOf {get;}
-}
-
-public struct NetInt(int i) : INetworkable<NetInt>
-{
-    public int Value = i;
-    public static int SizeOf => sizeof(int);
-    public readonly void ToBytes(Span<byte> span) => BinaryPrimitives.WriteInt32LittleEndian(span, Value);
-    public static NetInt FromBytes(ReadOnlySpan<byte> span) => BinaryPrimitives.ReadInt32LittleEndian(span);
-
-    public static implicit operator NetInt(int i) => new(i);
-    public static implicit operator int(NetInt i) => i.Value;
-}
-
-public struct NetSingle(float f) : INetworkable<NetSingle>
-{
-    public float Value = f;
-    public static int SizeOf => sizeof(float);
-    public readonly void ToBytes(Span<byte> span) => BinaryPrimitives.WriteSingleLittleEndian(span, Value);
-    public static NetSingle FromBytes(ReadOnlySpan<byte> span) => new(BinaryPrimitives.ReadSingleLittleEndian(span));
+    public static T FromBytes<T>(this Span<byte> span) where T : unmanaged => MemoryMarshal.Read<T>(span);
 
-    public static implicit operator NetSingle(float f) => new(f);
-    public static implicit operator float(NetSingle f) => f.Value;
+    public static void ToBytes<T>(this T value, Span<byte> span) where T : unmanaged => MemoryMarshal.Write(span, value);
 }
 
 public abstract class RPCBase
 {
-    static readonly List<RPCBase> AllRPCs = new();
     protected abstract void FromBytes(Span<byte> span);
 }
 
-public class RPC<T>(Action<T> method) : RPCBase where T : struct, INetworkable<T>
+public class RPC<T>(Action<T> method) : RPCBase where T : unmanaged
 {
     readonly Action<T> Method = method;
+    readonly byte[] bytes = new byte[Unsafe.SizeOf<T>()];
 
     public void SendRPC(T param)
     {
-        //blah blah blah, networking
+        param.ToBytes(bytes);
+        //Network it, baby
     }
 
-    protected override void FromBytes(Span<byte> span) => Method?.Invoke(T.FromBytes(span));
+    protected override void FromBytes(Span<byte> span)
+    {
+        T result = span.FromBytes<T>();
+        Method.Invoke(result);
+    }
 }
 
-public class TestingRPC
+public class RPC<T1, T2>(Action<T1, T2> method) : RPCBase
+    where T1 : unmanaged
+    where T2 : unmanaged
 {
-    static void DoStuff(NetInt testInt) {}
-    RPC<NetInt> Taco = new(DoStuff);
+    readonly Action<T1, T2> Method = method;
+    readonly byte[] bytes = new byte[Unsafe.SizeOf<T1>()+Unsafe.SizeOf<T2>()];
+
+    public void SendRPC(T1 param1, T2 param2)
+    {
+        Span<byte> span = bytes;
+        param1.ToBytes(span);
+        span = span[Unsafe.SizeOf<T1>()..];
+        param2.ToBytes(span);
+        //Network it, baby
+    }
 
-    public void OtherTest(int blah) {
-        Taco.SendRPC(blah);
+    protected override void FromBytes(Span<byte> span)
+    {
+        T1 result1 = span.FromBytes<T1>();
+        span = span[Unsafe.SizeOf<T1>()..];
+        T2 result2 = span.FromBytes<T2>();
+        Method.Invoke(result1, result2);
     }
 }
\ No newline at end of file
-- 
cgit