Networking API

R2API/Networking/Header.cs

@@ -0,0 +1,36 @@
+using R2API.Networking.Interfaces;
+using UnityEngine.Networking;
+
+namespace R2API.Networking {
+    internal class Header : ISerializableObject {
+        public Header() {
+
+        }
+        internal Header(int typeCode, NetworkDestination dest) {
+            TypeCode = typeCode;
+            Destination = dest;
+        }
+
+        internal int TypeCode {
+            get;
+            private set;
+        }
+        internal NetworkDestination Destination {
+            get;
+            private set;
+        }
+
+        internal void RemoveDestination(NetworkDestination destination) => Destination &= ~destination;
+
+
+        public void Serialize(NetworkWriter writer) {
+            writer.Write(TypeCode);
+            writer.Write((byte)Destination);
+        }
+
+        public void Deserialize(NetworkReader reader) {
+            TypeCode = reader.ReadInt32();
+            Destination = (NetworkDestination)reader.ReadByte();
+        }
+    }
+}

R2API/Networking/Interfaces/INetCommand.cs

@@ -0,0 +1,40 @@
+using UnityEngine.Networking;
+
+namespace R2API.Networking.Interfaces {
+    public interface INetCommand {
+        void OnReceived();
+    }
+
+    public static class NetCommandExtensions {
+        public static void Send(this INetCommand command, NetworkDestination destination) {
+            if (destination.ShouldRun()) {
+                command.OnReceived();
+            }
+
+            if (destination.ShouldSend()) {
+                var header = destination.GetHeader(NetworkingAPI.GetNetworkHash(command.GetType()));
+
+                if (NetworkServer.active) {
+                    for (int i = 0; i < NetworkServer.connections.Count; ++i) {
+                        NetworkConnection conn = NetworkServer.connections[i];
+                        if (conn == null) {
+                            continue;
+                        }
+
+                        using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.CommandIndex, conn, QosType.Reliable)) {
+                            NetworkWriter writer = netWriter;
+                            writer.Write(header);
+                        }
+                    }
+                }
+
+                if (NetworkClient.active) {
+                    using (var netWriter = NetworkingAPI.GetWriter(NetworkingAPI.CommandIndex, ClientScene.readyConnection, QosType.Reliable)) {
+                        NetworkWriter writer = netWriter;
+                        writer.Write(header);
+                    }
+                }
+            }
+        }
+    }
+}

R2API/Networking/Interfaces/INetMessage.cs

@@ -0,0 +1,42 @@
+using UnityEngine.Networking;
+
+namespace R2API.Networking.Interfaces {
+    public interface INetMessage : ISerializableObject {
+        void OnReceived();
+    }
+
+    public static class NetMessageExtensions {
+        public static void Send(this INetMessage message, NetworkDestination destination) {
+            if (destination.ShouldRun()) {
+                message.OnReceived();
+            }
+
+            if (destination.ShouldSend()) {
+                var header = destination.GetHeader(NetworkingAPI.GetNetworkHash(message.GetType()));
+
+                if (NetworkServer.active) {
+                    for (int i = 0; i < NetworkServer.connections.Count; ++i) {
+                        NetworkConnection conn = NetworkServer.connections[i];
+                        if (conn == null) {
+                            continue;
+                        }
+
+                        using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.MessageIndex, conn, QosType.Reliable)) {
+                            NetworkWriter writer = netWriter;
+                            writer.Write(header);
+                            writer.Write(message);
+                        }
+                    }
+                }
+
+                if (NetworkClient.active) {
+                    using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.MessageIndex, ClientScene.readyConnection, QosType.Reliable)) {
+                        NetworkWriter writer = netWriter;
+                        writer.Write(header);
+                        writer.Write(message);
+                    }
+                }
+            }
+        }
+    }
+}

R2API/Networking/Interfaces/INetRequest.cs

@@ -0,0 +1,52 @@
+using UnityEngine.Networking;
+
+namespace R2API.Networking.Interfaces {
+    public interface INetRequest<TRequest, TReply> : ISerializableObject
+        where TRequest : INetRequest<TRequest, TReply>
+        where TReply : INetRequestReply<TRequest, TReply> {
+        TReply OnRequestReceived();
+    }
+
+    public interface INetRequestReply<TRequest, TReply> : ISerializableObject
+        where TRequest : INetRequest<TRequest, TReply>
+        where TReply : INetRequestReply<TRequest, TReply> {
+        void OnReplyReceived();
+    }
+
+    public static class NetRequestExtensions {
+        public static void Send<TRequest, TReply>(this TRequest request, NetworkDestination destination)
+            where TRequest : INetRequest<TRequest, TReply>
+            where TReply : INetRequestReply<TRequest, TReply> {
+            if (destination.ShouldRun()) {
+                request.OnRequestReceived().OnReplyReceived();
+            }
+
+            if (destination.ShouldSend()) {
+                var header = destination.GetHeader(NetworkingAPI.GetNetworkHash(request.GetType()));
+
+                if (NetworkServer.active) {
+                    for (var i = 0; i < NetworkServer.connections.Count; ++i) {
+                        NetworkConnection conn = NetworkServer.connections[i];
+                        if (conn == null) {
+                            continue;
+                        }
+
+                        using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.RequestIndex, conn, QosType.Reliable)) {
+                            NetworkWriter writer = netWriter;
+                            writer.Write(header);
+                            writer.Write(request);
+                        }
+                    }
+                }
+
+                if (NetworkClient.active) {
+                    using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.RequestIndex, ClientScene.readyConnection, QosType.Reliable)) {
+                        NetworkWriter writer = netWriter;
+                        writer.Write(header);
+                        writer.Write(request);
+                    }
+                }
+            }
+        }
+    }
+}

R2API/Networking/Interfaces/ISerializableObject.cs

@@ -0,0 +1,23 @@
+using UnityEngine.Networking;
+
+namespace R2API.Networking.Interfaces {
+    public interface ISerializableObject {
+        void Serialize(NetworkWriter writer);
+        void Deserialize(NetworkReader reader);
+    }
+
+    public static class SerializableObjectExtensions {
+        public static void Write<TObject>(this NetworkWriter writer, TObject target) where TObject : ISerializableObject => target.Serialize(writer);
+
+        public static TObject Read<TObject>(this NetworkReader reader, TObject destination) where TObject : ISerializableObject {
+            destination.Deserialize(reader);
+            return destination;
+        }
+
+        public static TObject Read<TObject>(this NetworkReader reader) where TObject : ISerializableObject, new() {
+            var obj = new TObject();
+            obj.Deserialize(reader);
+            return obj;
+        }
+    }
+}

R2API/Networking/Interfaces/ISerializer.cs

@@ -0,0 +1,17 @@
+using UnityEngine.Networking;
+
+namespace R2API.Networking.Interfaces {
+    public interface ISerializer<TObject> {
+        void Serialize(NetworkWriter writer, TObject target);
+        void Deserialize(NetworkReader reader, TObject target);
+    }
+
+    public static class SerializerExtensions {
+        public static void Write<TObject>(this NetworkWriter writer, TObject target, ISerializer<TObject> serializer) => serializer.Serialize(writer, target);
+
+        public static TObject Read<TObject>(this NetworkReader reader, ref TObject destination, ISerializer<TObject> serializer) {
+            serializer.Deserialize(reader, destination);
+            return destination;
+        }
+    }
+}

R2API/Networking/Messages/BuffMessage.cs

@@ -0,0 +1,35 @@
+using R2API.Networking.Interfaces;
+using RoR2;
+using UnityEngine.Networking;
+
+namespace R2API.Networking.Messages {
+    internal struct BuffMessage : INetMessage {
+        public void Serialize(NetworkWriter writer) {
+            writer.Write(_body.gameObject);
+            writer.WriteBuffIndex(_buff);
+            writer.Write(_stacks);
+            writer.Write(_duration);
+        }
+
+        public void Deserialize(NetworkReader reader) {
+            _body = reader.ReadGameObject().GetComponent<CharacterBody>();
+            _buff = reader.ReadBuffIndex();
+            _stacks = reader.ReadInt32();
+            _duration = reader.ReadSingle();
+        }
+
+        public void OnReceived() => _body.ApplyBuff(_buff, _stacks, _duration);
+
+        internal BuffMessage(CharacterBody body, BuffIndex buff, int stacks, float duration) {
+            _body = body;
+            _buff = buff;
+            _stacks = stacks;
+            _duration = duration;
+        }
+
+        private CharacterBody _body;
+        private BuffIndex _buff;
+        private int _stacks;
+        private float _duration;
+    }
+}

R2API/Networking/Messages/DamageMessage.cs

@@ -0,0 +1,49 @@
+using R2API.Networking.Interfaces;
+using RoR2;
+using UnityEngine.Networking;
+
+namespace R2API.Networking.Messages {
+    internal struct DamageMessage : INetMessage {
+        public void Serialize(NetworkWriter writer) {
+            writer.Write(_damage);
+            writer.Write(HurtBoxReference.FromHurtBox(_target));
+
+            byte flags = 0b0000;
+            flags |= _callHitWorld ? (byte)0b0001 : (byte)0b0000;
+            flags <<= 1;
+            flags |= _callHitEnemy ? (byte)0b0001 : (byte)0b0000;
+            flags <<= 1;
+            flags |= _callDamage ? (byte)0b0001 : (byte)0b0000;
+            writer.Write(flags);
+        }
+
+        public void Deserialize(NetworkReader reader) {
+            _damage = reader.ReadDamageInfo();
+            _target = reader.ReadHurtBoxReference().ResolveHurtBox();
+
+            byte flags = reader.ReadByte();
+            const byte mask = 0b0001;
+            _callDamage = (flags & mask) > 0;
+            flags >>= 1;
+            _callHitEnemy = (flags & mask) > 0;
+            flags >>= 1;
+            _callHitWorld = (flags & mask) > 0;
+        }
+
+        public void OnReceived() => _damage.DealDamage(_target, _callDamage, _callHitEnemy, _callHitWorld);
+
+        internal DamageMessage(DamageInfo damage, HurtBox target, bool callDamage, bool callHitEnemy, bool callHitWorld) {
+            _damage = damage;
+            _target = target;
+            _callDamage = callDamage;
+            _callHitEnemy = callHitEnemy;
+            _callHitWorld = callHitWorld;
+        }
+
+        private DamageInfo _damage;
+        private HurtBox _target;
+        private bool _callDamage;
+        private bool _callHitEnemy;
+        private bool _callHitWorld;
+    }
+}

R2API/Networking/Messages/DotMessage.cs

@@ -0,0 +1,40 @@
+using R2API.Networking.Interfaces;
+using RoR2;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace R2API.Networking.Messages {
+    internal struct DotMessage : INetMessage {
+        public void Serialize(NetworkWriter writer) {
+            writer.Write(_victim);
+            writer.Write(_attacker);
+            writer.WritePackedIndex32((int)_dotIndex);
+            writer.Write(_duration);
+            writer.Write(_damageMultiplier);
+        }
+
+        public void Deserialize(NetworkReader reader) {
+            _victim = reader.ReadGameObject();
+            _attacker = reader.ReadGameObject();
+            _dotIndex = (DotController.DotIndex)reader.ReadPackedIndex32();
+            _duration = reader.ReadSingle();
+            _damageMultiplier = reader.ReadSingle();
+        }
+
+        public void OnReceived() => DotController.InflictDot(_victim, _attacker, _dotIndex, _duration, _damageMultiplier);
+
+        internal DotMessage(GameObject victimObject, GameObject attackerObject, DotController.DotIndex dotIndex, float duration, float damageMultiplier) {
+            _victim = victimObject;
+            _attacker = attackerObject;
+            _dotIndex = dotIndex;
+            _duration = duration;
+            _damageMultiplier = damageMultiplier;
+        }
+
+        private GameObject _victim;
+        private GameObject _attacker;
+        private DotController.DotIndex _dotIndex;
+        private float _duration;
+        private float _damageMultiplier;
+    }
+}

R2API/Networking/Messages/ExampleMessage.cs

@@ -0,0 +1,22 @@
+using R2API.Networking.Interfaces;
+using UnityEngine.Networking;
+
+namespace R2API.Networking.Messages {
+    internal struct ExampleMessage : INetMessage {
+        internal int Integer;
+        internal string Str;
+
+        public void Serialize(NetworkWriter writer) {
+            writer.Write(Integer);
+            writer.Write(Str);
+        }
+
+        public void Deserialize(NetworkReader reader) {
+            Integer = reader.ReadInt32();
+            Str = reader.ReadString();
+        }
+
+        public void OnReceived() =>
+            R2API.Logger.LogWarning("int : " + Integer + " str : " + Str);
+    }
+}