added give ped scripted task event (#803)

Author: KiwisKiwi

api/AltV.Net.Async/AsyncCore.cs

@@ -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, int 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, int taskType);
 }

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

@@ -123,6 +123,7 @@ 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, int taskType);
 
             [DllImport(DllName, CallingConvention = NativeCallingConvention)]
             internal static extern void CSharpResourceImpl_SetMainDelegate(IntPtr resource,
@@ -319,6 +320,10 @@ 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);
         }
     }
 }

api/AltV.Net/Alt.Events.cs

@@ -340,5 +340,10 @@ public static event ClientDeleteObjectDelegate OnClientDeleteObject
             remove => CoreImpl.ClientDeleteObjectHandler.Remove(value);
         }
 
+        public static event GivePedScriptedTaskDelegate OnGivePedScriptedTask
+        {
+            add => CoreImpl.GivePedScriptedTaskHandler.Add(value);
+            remove => CoreImpl.GivePedScriptedTaskHandler.Remove(value);
+        }
     }
 }

api/AltV.Net/CSharpResourceImpl.cs

@@ -224,6 +224,11 @@ internal void SetDelegates(AltNative.Resource.MainDelegate onStart)
             handles.AddFirst(GCHandle.Alloc(onUpdateSyncedSceneDelegate));
             AltNative.Resource.CSharpResourceImpl_SetUpdateSyncedSceneDelegate(NativePointer, onUpdateSyncedSceneDelegate);
 
+            AltNative.Resource.GivePedScriptedTaskDelegate onGivePedScriptedTaskDelegate =
+                ModuleWrapper.OnGivePedScriptedTask;
+            handles.AddFirst(GCHandle.Alloc(onGivePedScriptedTaskDelegate));
+            AltNative.Resource.CSharpResourceImpl_SetGivePedScriptedTaskDelegate(NativePointer, onGivePedScriptedTaskDelegate);
+
         }
 
         public void Dispose()

api/AltV.Net/Core.Events.cs

@@ -154,6 +154,9 @@ public partial class Core
         internal readonly IEventHandler<ClientDeleteObjectDelegate> ClientDeleteObjectHandler =
             new HashSetEventHandler<ClientDeleteObjectDelegate>(EventType.CLIENT_DELETE_OBJECT_EVENT);
 
+        internal readonly IEventHandler<GivePedScriptedTaskDelegate> GivePedScriptedTaskHandler =
+            new HashSetEventHandler<GivePedScriptedTaskDelegate>(EventType.GIVE_PED_SCRIPTED_TASK);
+
         public void OnCheckpoint(IntPtr checkpointPointer, IntPtr entityPointer, BaseObjectType baseObjectType,
             bool state)
         {
@@ -2377,5 +2380,57 @@ public virtual void OnClientDeleteObjectEvent(IntPtr eventPointer, IPlayer sourc
                 }
             }
         }
+
+        public virtual void OnGivePedScriptedTask(IntPtr eventPointer, IntPtr source, IntPtr target, int taskType)
+        {
+            var sourcePlayer = PoolManager.Player.Get(source);
+            var targetPed = PoolManager.Ped.Get(target);
+
+            if (sourcePlayer == null)
+            {
+                Console.WriteLine("OnGivePedScriptedTask Invalid source " + source);
+                return;
+            }
+
+            if (targetPed == null)
+            {
+                Console.WriteLine("OnGivePedScriptedTask Invalid target " + target);
+                return;
+            }
+
+            OnGivePedScriptedTaskEvent(eventPointer, sourcePlayer, targetPed, taskType);
+        }
+
+        public virtual void OnGivePedScriptedTaskEvent(IntPtr eventPointer, IPlayer source, IPed target, int taskType)
+        {
+            if (!GivePedScriptedTaskHandler.HasEvents()) return;
+            var cancel = false;
+            foreach (var @delegate in GivePedScriptedTaskHandler.GetEvents())
+            {
+                try
+                {
+                    if (!@delegate(source, target, taskType))
+                    {
+                        cancel = true;
+                    }
+                }
+                catch (TargetInvocationException exception)
+                {
+                    Alt.Log("exception at event:" + "OnGivePedScriptedTaskEvent" + ":" + exception.InnerException);
+                }
+                catch (Exception exception)
+                {
+                    Alt.Log("exception at event:" + "OnGivePedScriptedTaskEvent" + ":" + exception);
+                }
+            }
+
+            if (cancel)
+            {
+                unsafe
+                {
+                    Alt.Core.Library.Shared.Event_Cancel(eventPointer);
+                }
+            }
+        }
     }
 }

api/AltV.Net/Events/Events.cs

@@ -105,4 +105,6 @@ public delegate WeaponDamageResponse WeaponDamageDelegate(IPlayer player, IEntit
     public delegate void UpdateSyncedSceneDelegate(IPlayer source, float startRate, int sceneId);
     public delegate bool ClientRequestObjectDelegate(IPlayer target, uint model, Position position);
     public delegate bool ClientDeleteObjectDelegate(IPlayer target);
+
+    public delegate bool GivePedScriptedTaskDelegate(IPlayer source, IPed target, int taskType);
 }

api/AltV.Net/ModuleWrapper.cs

@@ -483,5 +483,10 @@ public static void OnRequestSyncedScene(IntPtr eventPointer, IntPtr source)
         {
             _core.OnClientDeleteObject(eventPointer, source);
         }
+
+        public static void OnGivePedScriptedTask(IntPtr eventPointer, IntPtr source, IntPtr target, int taskType)
+        {
+            _core.OnGivePedScriptedTask(eventPointer, source, target, taskType);
+        }
     }
 }