Merge remote-tracking branch 'origin/dev' into rc

# Conflicts:
#	runtime

Author: emcifuntik

api/AltV.Net.Async/AsyncCore.cs

@@ -36,7 +36,7 @@ public override IEnumerable<string> GetRegisteredServerEvents()
         }
 
         internal readonly AsyncEventHandler<CheckpointAsyncDelegate> CheckpointAsyncEventHandler =
-            new(EventType.CHECKPOINT_EVENT);
+            new(EventType.COLSHAPE_EVENT);
 
         internal readonly AsyncEventHandler<PlayerConnectAsyncDelegate> PlayerConnectAsyncEventHandler =
             new(EventType.PLAYER_CONNECT);
@@ -168,6 +168,9 @@ internal readonly AsyncEventHandler<PlayerChangeVehicleSeatAsyncDelegate>
         internal readonly AsyncEventHandler<ClientDeleteObjectAsyncEventDelegate> ClientDeleteObjectAsyncEventHandler =
             new(EventType.CLIENT_DELETE_OBJECT_EVENT);
 
+        internal readonly AsyncEventHandler<GivePedScriptedTaskAsyncDelegate> GivePedScriptedTaskAsyncEventHandler =
+            new(EventType.GIVE_PED_SCRIPTED_TASK);
+
         public AsyncCore(IntPtr nativePointer, IntPtr resourcePointer, AssemblyLoadContext assemblyLoadContext, ILibrary library, IPoolManager poolManager,
             INativeResourcePool nativeResourcePool) : base(nativePointer, resourcePointer, assemblyLoadContext, library, poolManager, nativeResourcePool)
         {
@@ -822,6 +825,17 @@ public override void OnClientDeleteObjectEvent(IntPtr eventPointer, IPlayer sour
             });
         }
 
+        public override void OnGivePedScriptedTaskEvent(IntPtr eventPointer, IPlayer sourcePlayer, IPed sourcePed, uint taskType)
+        {
+            base.OnGivePedScriptedTaskEvent(eventPointer, sourcePlayer, sourcePed, taskType);
+
+            if (!GivePedScriptedTaskAsyncEventHandler.HasEvents()) return;
+            Task.Run(async () =>
+            {
+                await GivePedScriptedTaskAsyncEventHandler.CallAsync(@delegate => @delegate(sourcePlayer, sourcePed, taskType));
+            });
+        }
+
         public new Function OnClient(string eventName, Function function)
         {
             if (function == null)

api/AltV.Net.Async/Events/Events.cs

@@ -96,4 +96,6 @@ public delegate Task WeaponDamageAsyncDelegate(IPlayer player, IEntity target, u
     public delegate Task UpdateSyncedSceneAsyncEventDelegate(IPlayer source, float startRate, int sceneId);
     public delegate Task ClientRequestObjectAsyncEventDelegate(IPlayer target, uint model, Position position);
     public delegate Task ClientDeleteObjectAsyncEventDelegate(IPlayer target);
+
+    public delegate Task GivePedScriptedTaskAsyncDelegate(IPlayer source, IPed target, uint taskType);
 }

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

@@ -85,4 +85,7 @@ public delegate void PlayerBulletHitModuleDelegate(uint weapon, IntPtr victimPoi
         Position pos);
 
     public delegate void VoiceConnectionModuleDelegate(VoiceConnectionState state);
+
+    public delegate void ServerScriptRPCAnswerModuleDelegate(ushort answerId, IntPtr answer,
+        string answerError);
 }

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

@@ -188,6 +188,7 @@ public unsafe interface ISharedLibrary
         public delegate* unmanaged[Cdecl]<byte> Core_GetEventEnumSize { get; }
         public delegate* unmanaged[Cdecl]<nint, ulong*, nint> Core_GetMarkers { get; }
         public delegate* unmanaged[Cdecl]<nint, nint, nint> Core_GetMetaData { get; }
+        public delegate* unmanaged[Cdecl]<nint, int> Core_GetNetTime { get; }
         public delegate* unmanaged[Cdecl]<nint, ulong*, nint> Core_GetNetworkObjects { get; }
         public delegate* unmanaged[Cdecl]<nint, ulong*, nint> Core_GetPeds { get; }
         public delegate* unmanaged[Cdecl]<nint, ulong*, nint> Core_GetPlayers { get; }
@@ -405,7 +406,7 @@ public unsafe interface ISharedLibrary
 
     public unsafe class SharedLibrary : ISharedLibrary
     {
-        public readonly uint Methods = 1715;
+        public readonly uint Methods = 1722;
         public delegate* unmanaged[Cdecl]<nint, uint> Audio_GetID { get; }
         public delegate* unmanaged[Cdecl]<nint, uint> AudioAttachedOutput_GetID { get; }
         public delegate* unmanaged[Cdecl]<nint, uint> AudioFilter_GetID { get; }
@@ -584,6 +585,7 @@ public unsafe class SharedLibrary : ISharedLibrary
         public delegate* unmanaged[Cdecl]<byte> Core_GetEventEnumSize { get; }
         public delegate* unmanaged[Cdecl]<nint, ulong*, nint> Core_GetMarkers { get; }
         public delegate* unmanaged[Cdecl]<nint, nint, nint> Core_GetMetaData { get; }
+        public delegate* unmanaged[Cdecl]<nint, int> Core_GetNetTime { get; }
         public delegate* unmanaged[Cdecl]<nint, ulong*, nint> Core_GetNetworkObjects { get; }
         public delegate* unmanaged[Cdecl]<nint, ulong*, nint> Core_GetPeds { get; }
         public delegate* unmanaged[Cdecl]<nint, ulong*, nint> Core_GetPlayers { get; }
@@ -1153,6 +1155,8 @@ public unsafe class SharedLibrary : ISharedLibrary
         private static nint Core_GetMarkersFallback(nint _core, ulong* _size) => throw new Exceptions.OutdatedSdkException("Core_GetMarkers", "Core_GetMarkers SDK method is outdated. Please update your module nuget");
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate nint Core_GetMetaDataDelegate(nint _core, nint _key);
         private static nint Core_GetMetaDataFallback(nint _core, nint _key) => throw new Exceptions.OutdatedSdkException("Core_GetMetaData", "Core_GetMetaData SDK method is outdated. Please update your module nuget");
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate int Core_GetNetTimeDelegate(nint _server);
+        private static int Core_GetNetTimeFallback(nint _server) => throw new Exceptions.OutdatedSdkException("Core_GetNetTime", "Core_GetNetTime SDK method is outdated. Please update your module nuget");
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate nint Core_GetNetworkObjectsDelegate(nint _core, ulong* _size);
         private static nint Core_GetNetworkObjectsFallback(nint _core, ulong* _size) => throw new Exceptions.OutdatedSdkException("Core_GetNetworkObjects", "Core_GetNetworkObjects SDK method is outdated. Please update your module nuget");
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate nint Core_GetPedsDelegate(nint _core, ulong* _size);
@@ -1588,7 +1592,7 @@ private IntPtr GetUnmanagedPtr<T>(IDictionary<ulong, IntPtr> funcTable, ulong ha
         public SharedLibrary(Dictionary<ulong, IntPtr> funcTable)
         {
             if (!funcTable.TryGetValue(0, out var capiHash)) Outdated = true;
-            else if (capiHash == IntPtr.Zero || *(ulong*)capiHash != 10494575567167650847UL) Outdated = true;
+            else if (capiHash == IntPtr.Zero || *(ulong*)capiHash != 10439883327927219649UL) Outdated = true;
             Audio_GetID = (delegate* unmanaged[Cdecl]<nint, uint>) GetUnmanagedPtr<Audio_GetIDDelegate>(funcTable, 4464042055475980737UL, Audio_GetIDFallback);
             AudioAttachedOutput_GetID = (delegate* unmanaged[Cdecl]<nint, uint>) GetUnmanagedPtr<AudioAttachedOutput_GetIDDelegate>(funcTable, 17725794901805112189UL, AudioAttachedOutput_GetIDFallback);
             AudioFilter_GetID = (delegate* unmanaged[Cdecl]<nint, uint>) GetUnmanagedPtr<AudioFilter_GetIDDelegate>(funcTable, 8824535635529306325UL, AudioFilter_GetIDFallback);
@@ -1767,6 +1771,7 @@ public SharedLibrary(Dictionary<ulong, IntPtr> funcTable)
             Core_GetEventEnumSize = (delegate* unmanaged[Cdecl]<byte>) GetUnmanagedPtr<Core_GetEventEnumSizeDelegate>(funcTable, 6921054663232355759UL, Core_GetEventEnumSizeFallback);
             Core_GetMarkers = (delegate* unmanaged[Cdecl]<nint, ulong*, nint>) GetUnmanagedPtr<Core_GetMarkersDelegate>(funcTable, 7482854450085275693UL, Core_GetMarkersFallback);
             Core_GetMetaData = (delegate* unmanaged[Cdecl]<nint, nint, nint>) GetUnmanagedPtr<Core_GetMetaDataDelegate>(funcTable, 2139798095052897524UL, Core_GetMetaDataFallback);
+            Core_GetNetTime = (delegate* unmanaged[Cdecl]<nint, int>) GetUnmanagedPtr<Core_GetNetTimeDelegate>(funcTable, 15652019729912249391UL, Core_GetNetTimeFallback);
             Core_GetNetworkObjects = (delegate* unmanaged[Cdecl]<nint, ulong*, nint>) GetUnmanagedPtr<Core_GetNetworkObjectsDelegate>(funcTable, 8454955647873390265UL, Core_GetNetworkObjectsFallback);
             Core_GetPeds = (delegate* unmanaged[Cdecl]<nint, ulong*, nint>) GetUnmanagedPtr<Core_GetPedsDelegate>(funcTable, 5411021830103603795UL, Core_GetPedsFallback);
             Core_GetPlayers = (delegate* unmanaged[Cdecl]<nint, ulong*, nint>) GetUnmanagedPtr<Core_GetPlayersDelegate>(funcTable, 6799731000550763773UL, Core_GetPlayersFallback);

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

@@ -24,16 +24,15 @@ internal delegate void CheckpointDelegate(IntPtr checkpointPointer, IntPtr entit
                 BaseObjectType baseObjectType,
                 byte state);
 
-            internal delegate void PlayerConnectDelegate(IntPtr playerPointer, ushort playerId, string reason);
+            internal delegate void PlayerConnectDelegate(IntPtr playerPointer, string reason);
 
             internal delegate void PlayerConnectDeniedDelegate(PlayerConnectDeniedReason reason, string name, string ip,
                 ulong passwordHash, byte isDebug, string branch, uint majorVersion, string cdnUrl, long discordId);
 
             internal delegate void ResourceEventDelegate(IntPtr resourcePointer);
 
             internal delegate void PlayerDamageDelegate(IntPtr playerPointer, IntPtr attackerEntityPointer,
-                BaseObjectType attackerBaseObjectType,
-                ushort attackerEntityId, uint weapon, ushort healthDamage, ushort armourDamage);
+                BaseObjectType attackerBaseObjectType, uint weapon, ushort healthDamage, ushort armourDamage);
 
             internal delegate void PlayerDeathDelegate(IntPtr playerPointer, IntPtr killerEntityPointer,
                 BaseObjectType killerBaseObjectType, uint weapon);
@@ -123,6 +122,23 @@ internal delegate void VehicleHornDelegate(IntPtr eventPointer, IntPtr targetPoi
 
             internal delegate void UpdateSyncedSceneDelegate(IntPtr source, float startRate, int sceneId);
 
+            internal delegate void GivePedScriptedTaskDelegate(IntPtr eventPointer, IntPtr source, IntPtr target, uint taskType);
+
+
+            internal delegate void PedDamageDelegate(IntPtr pedPointer, IntPtr attackerEntityPointer,
+                BaseObjectType attackerBaseObjectType, uint weapon, ushort healthDamage, ushort armourDamage);
+
+            internal delegate void PedDeathDelegate(IntPtr pedPointer, IntPtr killerEntityPointer,
+                BaseObjectType killerBaseObjectType, uint weapon);
+
+            internal delegate void PedHealDelegate(IntPtr pedPointer, ushort oldHealth, ushort newHealth,
+                ushort oldArmour, ushort newArmour);
+
+            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);
+
 
             [DllImport(DllName, CallingConvention = NativeCallingConvention)]
             internal static extern void CSharpResourceImpl_SetMainDelegate(IntPtr resource,
@@ -319,6 +335,34 @@ internal static extern void CSharpResourceImpl_SetStopSyncedSceneDelegate(IntPtr
             [DllImport(DllName, CallingConvention = NativeCallingConvention)]
             internal static extern void CSharpResourceImpl_SetUpdateSyncedSceneDelegate(IntPtr resource,
                 UpdateSyncedSceneDelegate @delegate);
+
+            [DllImport(DllName, CallingConvention = NativeCallingConvention)]
+            internal static extern void CSharpResourceImpl_SetGivePedScriptedTaskDelegate(IntPtr resource,
+                GivePedScriptedTaskDelegate @delegate);
+
+            [DllImport(DllName, CallingConvention = NativeCallingConvention)]
+            internal static extern void CSharpResourceImpl_SetPedDamageDelegate(IntPtr resource,
+                PedDamageDelegate @delegate);
+
+            [DllImport(DllName, CallingConvention = NativeCallingConvention)]
+            internal static extern void CSharpResourceImpl_SetPedDeathDelegate(IntPtr resource,
+                PedDeathDelegate @delegate);
+
+            [DllImport(DllName, CallingConvention = NativeCallingConvention)]
+            internal static extern void CSharpResourceImpl_SetPedHealDelegate(IntPtr resource,
+                PedHealDelegate @delegate);
+
+            [DllImport(DllName, CallingConvention = NativeCallingConvention)]
+            internal static extern void CSharpResourceImpl_SetPlayerStartTalkingDelegate(IntPtr resource,
+                PlayerStartTalkingDelegate @delegate);
+
+            [DllImport(DllName, CallingConvention = NativeCallingConvention)]
+            internal static extern void CSharpResourceImpl_SetPlayerStopTalkingDelegate(IntPtr resource,
+                PlayerStopTalkingDelegate @delegate);
+
+            [DllImport(DllName, CallingConvention = NativeCallingConvention)]
+            internal static extern void CSharpResourceImpl_SetClientScriptRPCDelegate(IntPtr resource,
+                ClientScriptRPCDelegate @delegate);
         }
     }
 }

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

@@ -18,9 +18,9 @@ public partial class Alt
         public static IRmlDocument CreateRmlDocument(string url) => Core.CreateRmlDocument(url);
         public static IAudio CreateAudio(string source, float volume, bool isRadio = false, string basePath = "") => Core.CreateAudio(source, volume, isRadio, basePath);
         public static IAudioFilter CreateAudioFilter(uint hash) => Core.CreateAudioFilter(hash);
-        public static IAudioFrontendOutput CreateFrontendOutput(uint categoryHash) => Core.CreateFrontendOutput(categoryHash);
-        public static IAudioWorldOutput CreateWorldOutput(uint categoryHash, Position pos) => Core.CreateWorldOutput(categoryHash, pos);
-        public static IAudioAttachedOutput CreateAttachedOutput(uint categoryHash, IWorldObject worldObject) => Core.CreateAttachedOutput(categoryHash, worldObject);
+        public static IAudioOutputFrontend CreateAudioOutputFrontend(uint categoryHash) => Core.CreateAudioOutputFrontend(categoryHash);
+        public static IAudioOutputWorld CreateAudioOutputWorld(uint categoryHash, Position pos) => Core.CreateAudioOutputWorld(categoryHash, pos);
+        public static IAudioOutputAttached CreateAudioOutputAttached(uint categoryHash, IWorldObject worldObject) => Core.CreateAudioOutputAttached(categoryHash, worldObject);
         public static ILocalObject CreateLocalObject(uint modelHash, Position position, Rotation rotation, bool noOffset = false, bool dynamic = false, bool useStreaming = false, uint streamingDistance = 0) => Core.CreateLocalObject(modelHash, position, rotation, noOffset, dynamic, useStreaming, streamingDistance);
         public static IHttpClient CreateHttpClient() => Core.CreateHttpClient();
         public static IWebSocketClient CreateWebSocketClient(string url) => Core.CreateWebSocketClient(url);

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

@@ -246,6 +246,12 @@ public static event VoiceConnectionDelegate OnVoiceConnection
             remove => CoreImpl.VoiceConnectionEventHandler.Remove(value);
         }
 
+        public static event ServerScriptRPCAnswerDelegate OnServerScriptRPCAnswer
+        {
+            add => CoreImpl.ServerScriptRPCAnswerHandler.Add(value);
+            remove => CoreImpl.ServerScriptRPCAnswerHandler.Remove(value);
+        }
+
         public static void OnServer(string eventName, Function function) => CoreImpl.AddServerEventListener(eventName, function);
 
         public static void OnServer<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string eventName, Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> function) => CoreImpl.AddServerEventListener(eventName, Function.Create(Core, function));

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

@@ -74,6 +74,7 @@ public static partial class Alt
         public static string GetHeadshotBase64(byte id) => Core.GetHeadshotBase64(id);
         public static Task<string> TakeScreenshot() => Core.TakeScreenshot();
         public static Task<string> TakeScreenshotGameOnly() => Core.TakeScreenshotGameOnly();
+        public static void RegisterFont(string path) => Core.RegisterFont(path);
 
         public static MapZoomData GetMapZoomData(uint id) => Core.GetMapZoomData(id);
         public static MapZoomData GetMapZoomData(string alias) => Core.GetMapZoomData(alias);