make rpc events shared

Author: Doxoh

api/AltV.Net.CApi/Events/ClientEvents.cs

@@ -86,6 +86,8 @@ public delegate void PlayerBulletHitModuleDelegate(uint weapon, IntPtr victimPoi
 
     public delegate void VoiceConnectionModuleDelegate(VoiceConnectionState state);
 
-    public delegate void ServerScriptRPCAnswerModuleDelegate(ushort answerId, IntPtr answer,
+    public delegate void ScriptRPCModuleDelegate(IntPtr eventPointer, string name, IntPtr args, ulong size, ushort answerId);
+
+    public delegate void ScriptRPCAnswerModuleDelegate(ushort answerId, IntPtr answer,
         string answerError);
 }

api/AltV.Net.CApi/Libraries/ClientLibrary.cs

@@ -137,7 +137,9 @@ internal delegate void PedHealDelegate(IntPtr pedPointer, ushort oldHealth, usho
             internal delegate void PlayerStartTalkingDelegate(IntPtr playerPointer);
 
             internal delegate void PlayerStopTalkingDelegate(IntPtr playerPointer);
-            internal delegate void ClientScriptRPCDelegate(IntPtr eventPointer, IntPtr targetPointer, string name, IntPtr args, ulong size, ushort answerId);
+            internal delegate void ScriptRPCDelegate(IntPtr eventPointer, IntPtr targetPointer, string name, IntPtr args, ulong size, ushort answerId);
+            internal delegate void ScriptRPCAnswerDelegate(IntPtr targetPointer, ushort answerId, IntPtr answer,
+                string answerError);
 
 
             [DllImport(DllName, CallingConvention = NativeCallingConvention)]
@@ -361,8 +363,12 @@ internal static extern void CSharpResourceImpl_SetPlayerStopTalkingDelegate(IntP
                 PlayerStopTalkingDelegate @delegate);
 
             [DllImport(DllName, CallingConvention = NativeCallingConvention)]
-            internal static extern void CSharpResourceImpl_SetClientScriptRPCDelegate(IntPtr resource,
-                ClientScriptRPCDelegate @delegate);
+            internal static extern void CSharpResourceImpl_SetScriptRPCDelegate(IntPtr resource,
+                ScriptRPCDelegate @delegate);
+
+            [DllImport(DllName, CallingConvention = NativeCallingConvention)]
+            internal static extern void CSharpResourceImpl_SetScriptRPCAnswerDelegate(IntPtr resource,
+                ScriptRPCAnswerDelegate @delegate);
         }
     }
 }

api/AltV.Net.CApi/Libraries/ServerLibrary.cs

@@ -246,10 +246,16 @@ public static event VoiceConnectionDelegate OnVoiceConnection
             remove => CoreImpl.VoiceConnectionEventHandler.Remove(value);
         }
 
-        public static event ServerScriptRPCAnswerDelegate OnServerScriptRPCAnswer
+        public static event ScriptRPCAnswerDelegate OnScriptRPCAnswer
         {
-            add => CoreImpl.ServerScriptRPCAnswerHandler.Add(value);
-            remove => CoreImpl.ServerScriptRPCAnswerHandler.Remove(value);
+            add => CoreImpl.ScriptRPCAnswerHandler.Add(value);
+            remove => CoreImpl.ScriptRPCAnswerHandler.Remove(value);
+        }
+
+        public static event ScriptRPCDelegate OnScriptRPC
+        {
+            add => CoreImpl.ScriptRPCHandler.Add(value);
+            remove => CoreImpl.ScriptRPCHandler.Remove(value);
         }
 
         public static void OnServer(string eventName, Function function) => CoreImpl.AddServerEventListener(eventName, function);

api/AltV.Net.CApi/Libraries/SharedLibrary.cs

@@ -72,7 +72,8 @@ public static bool GetBaseObjectById(BaseObjectType type, uint id, [MaybeNullWhe
         public static void EmitServerUnreliable(string eventName, params object[] args) => Core.TriggerServerEventUnreliable(eventName, args);
         public static void EmitClient(string eventName, params object[] args) => Core.TriggerLocalEvent(eventName, args);
 
-        public static ushort EmitRPCEvent(string name, params object[] args) => Core.TriggerServerRPCEvent(name, args);
+        public static ushort EmitRPC(string name, params object[] args) => Core.TriggerServerRPCEvent(name, args);
+        public static void EmitRPCAnswer(ushort answerId, object answer, string error) => Core.TriggerServerRPCAnswer(answerId, answer, error);
 
         public static bool HasResource(string name) => Core.HasResource(name);
         public static INativeResource GetResource(string name) => Core.GetResource(name);

api/AltV.Net.CApi/Native/AltV.Resource.cs

@@ -8,6 +8,7 @@
 using AltV.Net.Data;
 using AltV.Net.Elements.Args;
 using AltV.Net.Elements.Entities;
+using AltV.Net.Shared.Elements.Entities;
 using AltV.Net.Shared.Events;
 
 namespace AltV.Net.Client
@@ -155,8 +156,11 @@ public virtual IEnumerable<string> GetRegisteredServerEvents()
         internal readonly IEventHandler<VoiceConnectionDelegate> VoiceConnectionEventHandler =
             new HashSetEventHandler<VoiceConnectionDelegate>(EventType.VOICE_CONNECTION_EVENT);
 
-        internal readonly IEventHandler<ServerScriptRPCAnswerDelegate> ServerScriptRPCAnswerHandler =
-            new HashSetEventHandler<ServerScriptRPCAnswerDelegate>(EventType.SERVER_SCRIPT_RPC_ANSWER_EVENT);
+        internal readonly IEventHandler<ScriptRPCDelegate> ScriptRPCHandler =
+            new HashSetEventHandler<ScriptRPCDelegate>(EventType.SCRIPT_RPC_EVENT);
+
+        internal readonly IEventHandler<ScriptRPCAnswerDelegate> ScriptRPCAnswerHandler =
+            new HashSetEventHandler<ScriptRPCAnswerDelegate>(EventType.SCRIPT_RPC_ANSWER_EVENT);
 
 
         public void OnServerEvent(string name, IntPtr[] args)
@@ -693,10 +697,17 @@ public void OnAudioEvent(IntPtr audioPtr, string name, IntPtr[] args)
             }
         }
 
-        public void OnServerScriptRPCAnswer(ushort answerid, IntPtr answer, string answerError)
+        public void OnScriptRPCAnswer(ushort answerid, IntPtr answer, string answerError)
         {
             var mValue = new MValueConst(this, answer);
-            ServerScriptRPCAnswerHandler.GetEvents().ForEachCatching(fn => fn(answerid, mValue, answerError), $"event {nameof(OnServerScriptRPCAnswer)}");
+            ScriptRPCAnswerHandler.GetEvents().ForEachCatching(fn => fn(answerid, mValue, answerError), $"event {nameof(OnScriptRPCAnswer)}");
+        }
+
+        public void OnScriptRPC(IntPtr eventpointer, string name, IntPtr[] args, ushort answerid)
+        {
+            var mValues = MValueConst.CreateFrom(this, args);
+            var clientScriptRPCEvent = new ScriptRpcEvent(this, eventpointer);
+            ScriptRPCHandler.GetEvents().ForEachCatching(fn => fn(clientScriptRPCEvent, name, mValues.Select(x => x.ToObject()).ToArray(), answerid), $"event {nameof(OnScriptRPC)}");
         }
     }
 }

api/AltV.Net.Client/Alt.Events.cs

@@ -813,6 +813,32 @@ public ushort TriggerServerRPCEvent(IntPtr eventNamePtr, IntPtr[] args)
             }
         }
 
+        public void TriggerServerRPCAnswer(ushort answerId, object answer, string error)
+        {
+            CreateMValue(out var mValue, answer);
+            TriggerServerRPCAnswer(answerId, mValue, error);
+            mValue.Dispose();
+        }
+
+        public void TriggerServerRPCAnswer(ushort answerId, MValueConst answer, string error)
+        {
+            unsafe
+            {
+                var errorPtr = AltNative.StringUtils.StringToHGlobalUtf8(error);
+                Library.Client.Core_TriggerServerRPCAnswer(NativePointer, answerId, answer.nativePointer, errorPtr);
+                Marshal.FreeHGlobal(errorPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ushort TriggerServerRPCAnswerEvent(IntPtr eventNamePtr, IntPtr[] args)
+        {
+            unsafe
+            {
+                return Library.Client.Core_TriggerServerRPCEvent(NativePointer, eventNamePtr, args, args.Length);
+            }
+        }
+
         public void TriggerServerEventUnreliable(string eventName, MValueConst[] args)
         {
             var eventNamePtr = AltNative.StringUtils.StringToHGlobalUtf8(eventName);

api/AltV.Net.Client/Alt.cs

@@ -5,6 +5,7 @@
 using AltV.Net.Data;
 using AltV.Net.Elements.Args;
 using AltV.Net.Elements.Entities;
+using AltV.Net.Shared.Elements.Entities;
 
 namespace AltV.Net.Client.Events
 {
@@ -63,7 +64,8 @@ public delegate bool WeaponDamageDelegate(IEntity target, uint weapon, ushort da
     public delegate void PlayerBulletHitDelegate(uint weapon, IEntity victim, Position position);
     public delegate void VoiceConnectionDelegate(VoiceConnectionState state);
 
-    public delegate void ServerScriptRPCAnswerDelegate(ushort answerId, object answer, string answerError);
+    public delegate void ScriptRPCDelegate(IScriptRPCEvent scriptRpcEvent, string name, object[] args, ushort answerId);
+    public delegate void ScriptRPCAnswerDelegate(ushort answerId, object answer, string answerError);