Code commit

CustomizePlus.GameData/Services/GameEventManager.cs

@@ -0,0 +1,193 @@
+using Dalamud.Hooking;
+using Dalamud.Plugin.Services;
+using Dalamud.Utility.Signatures;
+using FFXIVClientStructs.FFXIV.Client.Game.Character;
+using FFXIVClientStructs.FFXIV.Client.Game.Object;
+using FFXIVClientStructs.FFXIV.Client.Graphics.Scene;
+using FFXIVClientStructs.FFXIV.Client.System.Resource.Handle;
+using Penumbra.GameData;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CustomizePlus.GameData.Services;
+
+public unsafe class GameEventManager : IDisposable
+{
+    private const string Prefix = $"[{nameof(GameEventManager)}]";
+
+    public event CharacterDestructorEvent? CharacterDestructor;
+    public event CopyCharacterEvent? CopyCharacter;
+    public event CreatingCharacterBaseEvent? CreatingCharacterBase;
+    public event CharacterBaseCreatedEvent? CharacterBaseCreated;
+    public event CharacterBaseDestructorEvent? CharacterBaseDestructor;
+
+    public GameEventManager(IGameInteropProvider interop)
+    {
+        interop.InitializeFromAttributes(this);
+
+        _copyCharacterHook =
+            interop.HookFromAddress<CopyCharacterDelegate>((nint)CharacterSetup.MemberFunctionPointers.CopyFromCharacter, CopyCharacterDetour);
+        _characterBaseCreateHook =
+            interop.HookFromAddress<CharacterBaseCreateDelegate>((nint)CharacterBase.MemberFunctionPointers.Create, CharacterBaseCreateDetour);
+        _characterBaseDestructorHook =
+            interop.HookFromAddress<CharacterBaseDestructorEvent>((nint)CharacterBase.MemberFunctionPointers.Destroy,
+                CharacterBaseDestructorDetour);
+        _characterDtorHook.Enable();
+        _copyCharacterHook.Enable();
+        _characterBaseCreateHook.Enable();
+        _characterBaseDestructorHook.Enable();
+    }
+
+    public void Dispose()
+    {
+        _characterDtorHook.Dispose();
+        _copyCharacterHook.Dispose();
+        _characterBaseCreateHook.Dispose();
+        _characterBaseDestructorHook.Dispose();
+    }
+
+    #region Character Destructor
+
+    private delegate void CharacterDestructorDelegate(Character* character);
+
+    [Signature(Sigs.CharacterDestructor, DetourName = nameof(CharacterDestructorDetour))]
+    private readonly Hook<CharacterDestructorDelegate> _characterDtorHook = null!;
+
+    private void CharacterDestructorDetour(Character* character)
+    {
+        if (CharacterDestructor != null)
+            foreach (var subscriber in CharacterDestructor.GetInvocationList())
+            {
+                try
+                {
+                    ((CharacterDestructorEvent)subscriber).Invoke(character);
+                }
+                catch (Exception ex)
+                {
+                    //Penumbra.Log.Error($"{Prefix} Error in {nameof(CharacterDestructor)} event when executing {subscriber.Method.Name}:\n{ex}");
+                    //todo: log
+                }
+            }
+
+        //Penumbra.Log.Verbose($"{Prefix} {nameof(CharacterDestructor)} triggered with 0x{(nint)character:X}.");
+        //todo: log
+        _characterDtorHook.Original(character);
+    }
+
+    public delegate void CharacterDestructorEvent(Character* character);
+
+    #endregion
+
+    #region Copy Character
+
+    private delegate ulong CopyCharacterDelegate(CharacterSetup* target, GameObject* source, uint unk);
+
+    private readonly Hook<CopyCharacterDelegate> _copyCharacterHook;
+
+    private ulong CopyCharacterDetour(CharacterSetup* target, GameObject* source, uint unk)
+    {
+        // TODO: update when CS updated.
+        var character = ((Character**)target)[1];
+        if (CopyCharacter != null)
+            foreach (var subscriber in CopyCharacter.GetInvocationList())
+            {
+                try
+                {
+                    ((CopyCharacterEvent)subscriber).Invoke(character, (Character*)source);
+                }
+                catch (Exception ex)
+                {
+                    /*Penumbra.Log.Error(
+                        $"{Prefix} Error in {nameof(CopyCharacter)} event when executing {subscriber.Method.Name}:\n{ex}");*/
+                    //todo: log
+                }
+            }
+
+        /*Penumbra.Log.Verbose(
+            $"{Prefix} {nameof(CopyCharacter)} triggered with target 0x{(nint)target:X} and source 0x{(nint)source:X}.");*/
+        //todo: log
+        return _copyCharacterHook.Original(target, source, unk);
+    }
+
+    public delegate void CopyCharacterEvent(Character* target, Character* source);
+
+    #endregion
+
+    #region CharacterBaseCreate
+
+    private delegate nint CharacterBaseCreateDelegate(uint a, nint b, nint c, byte d);
+
+    private readonly Hook<CharacterBaseCreateDelegate> _characterBaseCreateHook;
+
+    private nint CharacterBaseCreateDetour(uint a, nint b, nint c, byte d)
+    {
+        if (CreatingCharacterBase != null)
+            foreach (var subscriber in CreatingCharacterBase.GetInvocationList())
+            {
+                try
+                {
+                    ((CreatingCharacterBaseEvent)subscriber).Invoke((nint)(&a), b, c);
+                }
+                catch (Exception ex)
+                {
+                    /*Penumbra.Log.Error(
+                        $"{Prefix} Error in {nameof(CharacterBaseCreateDetour)} event when executing {subscriber.Method.Name}:\n{ex}");*/
+                    //todo: log
+                }
+            }
+
+        var ret = _characterBaseCreateHook.Original(a, b, c, d);
+        if (CharacterBaseCreated != null)
+            foreach (var subscriber in CharacterBaseCreated.GetInvocationList())
+            {
+                try
+                {
+                    ((CharacterBaseCreatedEvent)subscriber).Invoke(a, b, c, ret);
+                }
+                catch (Exception ex)
+                {
+                    /*Penumbra.Log.Error(
+                        $"{Prefix} Error in {nameof(CharacterBaseCreateDetour)} event when executing {subscriber.Method.Name}:\n{ex}");*/
+                    //todo: log
+                }
+            }
+
+        return ret;
+    }
+
+    public delegate void CreatingCharacterBaseEvent(nint modelCharaId, nint customize, nint equipment);
+    public delegate void CharacterBaseCreatedEvent(uint modelCharaId, nint customize, nint equipment, nint drawObject);
+
+    #endregion
+
+    #region CharacterBase Destructor
+
+    public delegate void CharacterBaseDestructorEvent(nint drawBase);
+
+    private readonly Hook<CharacterBaseDestructorEvent> _characterBaseDestructorHook;
+
+    private void CharacterBaseDestructorDetour(nint drawBase)
+    {
+        if (CharacterBaseDestructor != null)
+            foreach (var subscriber in CharacterBaseDestructor.GetInvocationList())
+            {
+                try
+                {
+                    ((CharacterBaseDestructorEvent)subscriber).Invoke(drawBase);
+                }
+                catch (Exception ex)
+                {
+                    /*Penumbra.Log.Error(
+                        $"{Prefix} Error in {nameof(CharacterBaseDestructorDetour)} event when executing {subscriber.Method.Name}:\n{ex}");*/
+                    //todo: log
+                }
+            }
+
+        _characterBaseDestructorHook.Original.Invoke(drawBase);
+    }
+
+    #endregion
+}