Merge branch 'rc' into release

.github/workflows/release.yml

@@ -2,7 +2,7 @@ on:
   push:
     tags:
       - '*.*.*'
-      - '*.*.*-*'
+      - '*.*.*-*.*'
 jobs:
   fetch-nethost-linux:
     runs-on: ubuntu-22.04

api/AltV.Net.Async/AltAsync.Vehicle.cs

@@ -22,18 +22,6 @@ public static Task<IVehicle> CreateVehicle(VehicleModel model, Position pos, Rot
         public static Task<IVehicle> CreateVehicle(string model, Position pos, Rotation rot, uint streamingDistance = 0) =>
             CreateVehicle(Alt.Hash(model), pos, rot, streamingDistance);
 
-        [Obsolete("Use AltAsync.CreateVehicle or Alt.CreateVehicle instead")]
-        public static IVehicleBuilder CreateVehicleBuilder(uint model, Position pos, Rotation rot) =>
-            new VehicleBuilder(model, pos, rot);
-
-        [Obsolete("Use AltAsync.CreateVehicle or Alt.CreateVehicle instead")]
-        public static IVehicleBuilder CreateVehicleBuilder(VehicleModel model, Position pos, Rotation rot) =>
-            new VehicleBuilder((uint) model, pos, rot);
-
-        [Obsolete("Use AltAsync.CreateVehicle or Alt.CreateVehicle instead")]
-        public static IVehicleBuilder CreateVehicleBuilder(string model, Position pos, Rotation rot) =>
-            new VehicleBuilder(Alt.Hash(model), pos, rot);
-
         [Obsolete("Use async entities instead")]
         public static Task<IPlayer> GetDriverAsync(this IVehicle vehicle) => AltVAsync.Schedule(() =>
             !vehicle.Exists ? null : vehicle.Driver);

api/AltV.Net.Async/AsyncCore.cs

@@ -724,9 +724,9 @@ await ServerStartedAsyncEventHandler.CallAsync(@delegate =>
             });
         }
 
-        public override void OnPlayerRequestControlEvent(IEntity target, IPlayer player)
+        public override void OnPlayerRequestControlEvent(IntPtr eventPtr, IEntity target, IPlayer player)
         {
-           base.OnPlayerRequestControlEvent(target, player);
+           base.OnPlayerRequestControlEvent(eventPtr, target, player);
 
            if (!PlayerRequestControlAsyncEventHandler.HasEvents()) return;
            Task.Run(async () =>
@@ -869,14 +869,14 @@ public override void OnGivePedScriptedTaskEvent(IntPtr eventPointer, IPlayer sou
         }
 
         public override void OnPlayerConnectDeniedEvent(PlayerConnectDeniedReason reason, string name, string ip, ulong passwordHash,
-            bool isDebug, string branch, uint majorVersion, string cdnUrl, long discordId)
+            bool isDebug, string branch, ushort versionMajor, ushort versionMinor, string cdnUrl, long discordId)
         {
-            base.OnPlayerConnectDeniedEvent(reason, name, ip, passwordHash, isDebug, branch, majorVersion, cdnUrl, discordId);
+            base.OnPlayerConnectDeniedEvent(reason, name, ip, passwordHash, isDebug, branch, versionMajor, versionMinor, cdnUrl, discordId);
 
             if (!PlayerConnectDeniedAsyncEventHandler.HasEvents()) return;
             Task.Run(async () =>
             {
-                await PlayerConnectDeniedAsyncEventHandler.CallAsync(@delegate => @delegate(reason, name, ip, passwordHash, isDebug, branch, majorVersion, cdnUrl, discordId));
+                await PlayerConnectDeniedAsyncEventHandler.CallAsync(@delegate => @delegate(reason, name, ip, passwordHash, isDebug, branch, versionMajor, versionMinor, cdnUrl, discordId));
             });
         }
 
@@ -968,17 +968,35 @@ public override void OnPlayerStopTalkingEvent(IPlayer player)
             });
         }
 
-        public override void OnScriptRPCEvent(IntPtr eventpointer, IPlayer target, string name, IntPtr[] args, ushort answerId)
+        public override void OnScriptRPCEvent(IntPtr eventpointer, IPlayer target, string name, IntPtr[] args, ushort answerId, bool async)
         {
-            base.OnScriptRPCEvent(eventpointer, target, name, args, answerId);
+            if (!UnansweredServerRpcRequest.Contains(answerId))
+            {
+                UnansweredServerRpcRequest.Add(answerId);
+            }
+            base.OnScriptRPCEvent(eventpointer, target, name, args, answerId, true);
+
+            if (UnansweredServerRpcRequest.Contains(answerId))
+            {
+                unsafe
+                {
+                    Library.Shared.Event_ScriptRPCEvent_WillAnswer(eventpointer);
+                }
+            }
 
             if (!ScriptRpcAsyncEventHandler.HasEvents()) return;
             Task.Run(async () =>
             {
                 var mValues = MValueConst.CreateFrom(this, args);
-                var clientScriptRPCEvent = new ScriptRpcEvent(this, eventpointer);
+                var clientScriptRPCEvent = new AsyncScriptRpcEvent(target, answerId);
                 await ScriptRpcAsyncEventHandler.CallAsync(@delegate => @delegate(clientScriptRPCEvent, target, name, mValues.Select(x => x.ToObject()).ToArray(), answerId));
             });
+
+            if (UnansweredServerRpcRequest.Contains(answerId))
+            {
+                target.EmitRPCAnswer(answerId, null, "Answer not handled");
+                UnansweredServerRpcRequest.Remove(answerId);
+            }
         }
 
         public override void OnScriptAnswerRPCEvent(IPlayer target, ushort answerid, IntPtr mValue, string answererror)

api/AltV.Net.Async/AsyncScriptRpcEvent.cs

@@ -0,0 +1,36 @@
+using System;
+using AltV.Net.Elements.Entities;
+using AltV.Net.Shared.Elements.Entities;
+
+namespace AltV.Net.Async;
+
+public class AsyncScriptRpcEvent : IScriptRPCEvent
+{
+    private readonly IPlayer _target;
+    private readonly ushort _answerId;
+
+    public AsyncScriptRpcEvent(IPlayer target, ushort answerId)
+    {
+        _target = target;
+        _answerId = answerId;
+    }
+
+    public IntPtr ScriptRPCNativePointer { get; }
+
+    public bool WillAnswer()
+    {
+        return true;
+    }
+
+    public bool Answer(object answer)
+    {
+        _target.EmitRPCAnswer(_answerId, answer, "");
+        return true;
+    }
+
+    public bool AnswerWithError(string error)
+    {
+        _target.EmitRPCAnswer(_answerId, null, error);
+        return true;
+    }
+}

api/AltV.Net.Async/Elements/Entities/AsyncBaseObject.cs

@@ -95,51 +95,6 @@ public bool GetMetaData<T>(string key, out T result)
             }
         }
 
-        public bool GetMetaData(string key, out int result)
-        {
-            AsyncContext?.RunAll();
-            lock (BaseObject)
-            {
-                if (!AsyncContext.CheckIfExistsOrCachedNullable(BaseObject))
-                {
-                    result = default;
-                    return false;
-                }
-
-                return BaseObject.GetMetaData(key, out result);
-            }
-        }
-
-        public bool GetMetaData(string key, out uint result)
-        {
-            AsyncContext?.RunAll();
-            lock (BaseObject)
-            {
-                if (!AsyncContext.CheckIfExistsOrCachedNullable(BaseObject))
-                {
-                    result = default;
-                    return false;
-                }
-
-                return BaseObject.GetMetaData(key, out result);
-            }
-        }
-
-        public bool GetMetaData(string key, out float result)
-        {
-            AsyncContext?.RunAll();
-            lock (BaseObject)
-            {
-                if (!AsyncContext.CheckIfExistsOrCachedNullable(BaseObject))
-                {
-                    result = default;
-                    return false;
-                }
-
-                return BaseObject.GetMetaData(key, out result);
-            }
-        }
-
         public void SetMetaData(string key, in MValueConst value)
         {
             lock (BaseObject)
@@ -232,9 +187,6 @@ public void OnDestroy()
             BaseObject.OnDestroy();
         }
 
-        [Obsolete("Use Destroy() instead")]
-        public void Remove() => Destroy();
-
         public void Destroy()
         {
             AsyncContext.RunOnMainThreadBlockingNullable(() => BaseObject.Destroy());

api/AltV.Net.Async/Elements/Entities/AsyncConnectionInfo.cs

@@ -96,17 +96,31 @@ public string Branch
             }
         }
     }
-    public uint Build
+
+    public ushort VersionMajor
+    {
+        get
+        {
+            lock (ConnectionInfo)
+            {
+                if (!AsyncContext.CheckIfExistsOrCachedNullable(ConnectionInfo)) return default;
+                return ConnectionInfo.VersionMajor;
+            }
+        }
+    }
+
+    public ushort VersionMinor
     {
         get
         {
             lock (ConnectionInfo)
             {
                 if (!AsyncContext.CheckIfExistsOrCachedNullable(ConnectionInfo)) return default;
-                return ConnectionInfo.Build;
+                return ConnectionInfo.VersionMinor;
             }
         }
     }
+
     public string CdnUrl
     {
         get