/// <summary> /// Copies Crosire's D3D8To9 and hooks the DX9 device creation. /// </summary> /// <param name="dllDirectory">Directory containing Crosire's d3d8to9.</param> public void HookDevice(string dllDirectory) { // Copy crosire's d3d8to9 to game directory and then load it. (Game should use D3D9 now). if (!File.Exists("d3d8.dll")) { File.Copy(dllDirectory + $"\\d3d8.dll", "d3d8.dll", true); } // Load Crosire's D3D8To9 (which in turn loads D3D9 internally) LoadLibraryW("d3d8.dll"); // Get our D3D Interface VTable using (Direct3D direct3D = new Direct3D()) using (Form renderForm = new Form()) using (SharpDX.Direct3D9.Device device = new SharpDX.Direct3D9.Device(direct3D, 0, DeviceType.NullReference, IntPtr.Zero, CreateFlags.HardwareVertexProcessing, new PresentParameters() { BackBufferWidth = 1, BackBufferHeight = 1, DeviceWindowHandle = renderForm.Handle })) { _direct3DVirtualFunctionTable = new VirtualFunctionTable(direct3D.NativePointer, Enum.GetNames(typeof(Interfaces.IDirect3D9)).Length); _direct3DDeviceVirtualFunctionTable = new VirtualFunctionTable(device.NativePointer, Enum.GetNames(typeof(Interfaces.IDirect3DDevice9)).Length); } // Hook D3D9 device creation. _createDeviceHook = _direct3DVirtualFunctionTable.TableEntries[(int)Interfaces.IDirect3D9.CreateDevice].CreateFunctionHook86 <CreateDevice>(CreateDeviceImpl).Activate(); //_resetDeviceHook = _direct3DDeviceVirtualFunctionTable.TableEntries[(int)Interfaces.IDirect3DDevice9.Reset].CreateFunctionHook86<Direct3D9DeviceResetDelegate>(ResetDeviceImpl).Activate(); }
/// <summary> /// Your own user code starts here. /// If this is your first time, do consider reading the notice above. /// It contains some very useful information. /// </summary> public static void Init() { /* * Reloaded Mod Loader Utility: Steam Hook * Architectures supported: X86, X64 * * Hooks the Steam function responsible for checking if the game should be * restarted and just says "no, it shouldn't". */ #if DEBUG Debugger.Launch(); #endif // PS. I know the code below could be written better, but I wrote it FOR CLARITY. // Get directory of executing executable. string steamAPI32 = Path.GetFullPath(SteamAPI32); string steamAPI64 = Path.GetFullPath(SteamAPI64); // X86 if (IntPtr.Size == 4) { if (File.Exists(steamAPI32)) { // Load file and get address of export. IntPtr libraryAddress = Native.LoadLibraryW(steamAPI32); IntPtr restartAppIfNecessaryPtr = Native.GetProcAddress(libraryAddress, FunctionName); // Hook! if (restartAppIfNecessaryPtr != IntPtr.Zero) { restartIfNecessaryHook32 = FunctionHook <SteamAPI_RestartAppIfNecessary> .Create((long)restartAppIfNecessaryPtr, FunctionDelegate).Activate(); } } } // X64 if (IntPtr.Size == 8) { if (File.Exists(steamAPI64)) { // Load file and get address of export. IntPtr libraryAddress = Native.LoadLibraryW(steamAPI64); IntPtr restartAppIfNecessaryPtr = Native.GetProcAddress(libraryAddress, FunctionName); // If the debugger tells you that those two numbers are 0, it's bullshit. // It's a debugger bug, you'll see it right after the next if statement. // Hook! if (restartAppIfNecessaryPtr != IntPtr.Zero) { restartIfNecessaryHook64 = X64FunctionHook <SteamAPI_RestartAppIfNecessary> .Create((long)restartAppIfNecessaryPtr, FunctionDelegate).Activate(); } } } }
/// <summary> /// For class definition, see Class Summary <see cref="MemoryTracer"/>. /// Hooks Sonic Heroes' free & malloc functions and exposes delegates which /// you may use to either alter the parameters of the function or act. /// </summary> public MemoryTracer() { // Hook the game functions. _mallocHook = FunctionHook <Malloc> .Create(0x0067B475, MallocHookImpl).Activate(); _freeHook = FunctionHook <Free> .Create(0x0067B35D, FreeHookImpl).Activate(); MallocFunction = _mallocHook.OriginalFunction; FreeFunction = _freeHook.OriginalFunction; }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, void *, int, void> pSignalMeleeDamageHook = &OnSignalMeleeDamage; signalMeleeDamageHook = HookService.RequestHook <SignalMeleeDamageHook>(pSignalMeleeDamageHook, FunctionsLinux._ZN12CNWSCreature17SignalMeleeDamageEP10CNWSObjecti, HookOrder.Late); delegate * unmanaged <void *, void *, int, void> pSignalRangedDamageHook = &OnSignalRangedDamage; signalRangedDamageHook = HookService.RequestHook <SignalRangedDamageHook>(pSignalRangedDamageHook, FunctionsLinux._ZN12CNWSCreature18SignalRangedDamageEP10CNWSObjecti, HookOrder.Late); return(new IDisposable[] { signalMeleeDamageHook, signalRangedDamageHook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, int, int> pSetListAcceptedHook = &OnSetListAccepted; setListAcceptedHook = HookService.RequestHook <SetListAcceptedHook>(pSetListAcceptedHook, FunctionsLinux._ZN10CNWSBarter15SetListAcceptedEi, HookOrder.Earliest); delegate * unmanaged <void *, uint, uint, int, int> pSendServerToPlayerBarterCloseBarterHook = &OnSendServerToPlayerBarterCloseBarter; sendServerToPlayerBarterCloseBarterHook = HookService.RequestHook <SendServerToPlayerBarterCloseBarterHook>(pSendServerToPlayerBarterCloseBarterHook, FunctionsLinux._ZN11CNWSMessage35SendServerToPlayerBarterCloseBarterEjji, HookOrder.Earliest); return(new IDisposable[] { setListAcceptedHook, sendServerToPlayerBarterCloseBarterHook }); }
/// <summary> /// Your own user code starts here. /// If this is your first time, do consider reading the notice above. /// It contains some very useful information. /// </summary> public static void Init() { /* * Reloaded Mod Loader Sample: File Redirector (New) * Architectures supported: X86, X64 * * This sample mod builds upon the File Monitor sample, providing universal file redirection for modifications * which implement a `Plugins/Redirector/` folder. * * This is the same NtCreateFile hook as seen in the monitor, except that, we instead build * a list of files present within enabled mods' `Plugins/Redirector/` folder and build a dictionary mapping * a path to path. * * In our hooks, we just check if the file path exists in the dictionary, and override it if so. */ // Debugger.Launch(); // This should automatically resolve to ntdll.dll as it is already registered by Windows. // The handle should return from already loaded library in memory, following the standard search strategy. IntPtr ntdllHandle = Reloaded.Process.Native.Native.LoadLibraryW("ntdll"); // Get the addresses of our desired NtCreateFile IntPtr ntCreateFilePointer = Reloaded.Process.Native.Native.GetProcAddress(ntdllHandle, "NtCreateFile"); // Retreieve all enabled mods using utility functions in libReloaded. _currentGameConfig = GameConfig.GetGameConfigFromExecutablePath(ExecutingGameLocation); _enabledMods = GameConfig.GetAllEnabledMods(_currentGameConfig); _enabledMods = GameConfig.TopologicallySortConfigurations(_enabledMods); // Generate a list of new filesystemwatchers which will let us monitor redirector folders in real time. _fileSystemWatcherDictionary = new Dictionary <ModConfig, FileSystemWatcher>(); // Build a dictionary of enabled mods. BuildFileRedirectionDictionary(_enabledMods, _currentGameConfig); // Hook the obtained function pointers. // X86 if (IntPtr.Size == 4) { if (ntCreateFilePointer != IntPtr.Zero) { _ntCreateFileHook = FunctionHook <NtCreateFile> .Create((long)ntCreateFilePointer, NtCreateFileImpl).Activate(); } } // X64 else if (IntPtr.Size == 8) { if (ntCreateFilePointer != IntPtr.Zero) { _ntCreateFileHook64 = X64FunctionHook <NtCreateFile> .Create((long)ntCreateFilePointer, NtCreateFileImpl).Activate(); } } }
public FunctionHook <T> CreateHook <T>(MemoryOffset offset, string name, T hook) where T : Delegate { var address = Memory.ToAddress(offset); var original = Marshal.GetDelegateForFunctionPointer <T>(address); var fh = new FunctionHook <T>(address, name, original, hook); _hooks.Add(fh); return(fh); }
public PresentHook(CppObject swapChain) { _presentHook = new FunctionHook <Present>( VirtualTableAddress.GetVtableAddress(swapChain.NativePointer, (int)VirtualTableIndices.DxgiSwapChain.Present), new Present(OnPresent), this); // This is not the SwapChain we're looking for... swapChain.Dispose(); _presentHook.Activate(); }
/// <summary> /// Your own user code starts here. /// If this is your first time, do consider reading the notice above. /// It contains some very useful information. /// </summary> public static void Init() { /* * Reloaded Mod Loader Sample: File Monitor * Architectures supported: X86, X64 * * Gets our Windows API function pointers by first grabbing a handle to Kernel32 where * the individual functions are located and then calling the GetProcAddress() Windows API * function in order to obtain the address of the exported functions. * * We then hook the functions using the Reloaded Hooking classes, print to console the fileName * parameter and redirect to the original functions. */ // Debugger.Launch(); // This should automatically resolve to kernel32.dll as it is already registered by Windows. // The handle should return from already loaded library in memory, following the standard search strategy. IntPtr kernel32Handle = Reloaded.Process.Native.Native.LoadLibraryW("kernel32"); // Get the addresses of the CreateFileA, CreateFileW, CreateFile functions. IntPtr createFileAPointer = Reloaded.Process.Native.Native.GetProcAddress(kernel32Handle, "CreateFileA"); IntPtr createFileWPointer = Reloaded.Process.Native.Native.GetProcAddress(kernel32Handle, "CreateFileW"); // Hook the obtained function pointers. // X86 if (IntPtr.Size == 4) { if (createFileWPointer != IntPtr.Zero) { _createFileWHook = FunctionHook <CreateFileW> .Create((long)createFileWPointer, CreateFileWImpl).Activate(); } if (createFileAPointer != IntPtr.Zero) { _createFileAHook = FunctionHook <CreateFileA> .Create((long)createFileAPointer, CreateFileAImpl).Activate(); } } // X64 else if (IntPtr.Size == 8) { if (createFileWPointer != IntPtr.Zero) { _createFileWHook64 = X64FunctionHook <CreateFileW> .Create((long)createFileWPointer, CreateFileWImpl).Activate(); } if (createFileAPointer != IntPtr.Zero) { _createFileAHook64 = X64FunctionHook <CreateFileA> .Create((long)createFileAPointer, CreateFileAImpl).Activate(); } } }
public DrawIndexedHook(DeviceContext deviceContext, DepthStencilState depthDisabledState, Shaders shaders) { _deviceContext = deviceContext; _depthDisabledState = depthDisabledState; _shaders = shaders; _modelsInScene = new List <ModelInfo>(); SavedModels = new List <ModelInfo>(); _drawIndexedHook = new FunctionHook <DrawIndexed>( VirtualTableAddress.GetVtableAddress(_deviceContext.NativePointer, (int)VirtualTableIndices.D3D11DeviceContext.DrawIndexed), new DrawIndexed(OnDrawIndexed), this); _drawIndexedHook.Activate(); }
/// <summary> /// Instantiates the DirectX overlay, by first finding the applicable /// version of DirectX for the application and then finding the individual /// details. For more details, see <see cref="DX11Overlay"/> /// /// Note: The delegates you will need to call the original function are members of this class, see <see cref="PresentHook"/> and <see cref="ResizeTargetHook"/> /// Note: This method is blocking and Reloaded mods are required to return in order /// to boot up the games, please do not assign this statically - instead assign it in a background thread! /// </summary> /// <param name="DXGIPresentDelegate"> /// A delegate type to use for DirectX rendering. The delegate type should /// contain an appropriate DirectX <see cref="DXGISwapChain_PresentDelegate"/> /// object for drawing overlays. /// </param> /// <param name="DXGIResizeTargetDelegate"> /// A delegate or function of type of <see cref="DXGISwapChain_ResizeTargetDelegate"/> to call when DXGI Buffer /// commits a resolution change or windowed/fullscreen change. /// </param> /// <param name="hookDelay"> /// Specifies the amount of time to wait until the hook is instantiation begins. /// Some games are known to crash if DirectX is hooked too early. /// </param> /// <remarks>The delegates you will need to call the original function are members of this class, see <see cref="PresentHook"/> and <see cref="ResizeTargetHook"/></remarks> public static async Task <DX11Overlay> CreateDirectXOverlay(DXGISwapChain_PresentDelegate DXGIPresentDelegate, DXGISwapChain_ResizeTargetDelegate DXGIResizeTargetDelegate, int hookDelay) { // Wait the hook delay. await Task.Delay(hookDelay); // Create a new self-object. DX11Overlay dx11Overlay = new DX11Overlay(); // Wait for DirectX Direct3DVersion direct3DVersion = await DXHookCommon.GetDirectXVersion(); // Return nothing if not D3D9 if (direct3DVersion != Direct3DVersion.Direct3D11 && direct3DVersion != Direct3DVersion.Direct3D11_1 && direct3DVersion != Direct3DVersion.Direct3D11_3 && direct3DVersion != Direct3DVersion.Direct3D11_4) { Bindings.PrintError( "libReloaded Hooking: DirectX 11 module not found, the application is either not " + "a DirectX 11 application or uses an unsupported version of DirectX."); return(null); } // Instantiate DX9 hook dx11Overlay.DirectX11Hook = new DX11Hook();; // Obtain Virtual Function Table Entries VirtualFunctionTable.TableEntry presentTableEntry = dx11Overlay.DirectX11Hook.DXGISwapChainFunctions[(int)IDXGISwapChain.Present]; VirtualFunctionTable.TableEntry resizeTableEntry = dx11Overlay.DirectX11Hook.DXGISwapChainFunctions[(int)IDXGISwapChain.ResizeTarget]; // Hook relevant DirectX functions. if (IntPtr.Size == 4) { // X86 dx11Overlay.PresentHook = FunctionHook <DXGISwapChain_PresentDelegate> .Create((long)presentTableEntry.FunctionPointer, DXGIPresentDelegate); dx11Overlay.ResizeTargetHook = FunctionHook <DXGISwapChain_ResizeTargetDelegate> .Create((long)resizeTableEntry.FunctionPointer, DXGIResizeTargetDelegate); } else if (IntPtr.Size == 8) { // X64 dx11Overlay.PresentHook64 = X64FunctionHook <DXGISwapChain_PresentDelegate> .Create((long)presentTableEntry.FunctionPointer, DXGIPresentDelegate); dx11Overlay.ResizeTargetHook64 = X64FunctionHook <DXGISwapChain_ResizeTargetDelegate> .Create((long)resizeTableEntry.FunctionPointer, DXGIResizeTargetDelegate); } // Return our DX9Overlay return(dx11Overlay); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, void *, uint, void> pCreatureExamineHook = &OnCreatureExamine; creatureExamineHook = HookService.RequestHook <CreatureExamineHook>(pCreatureExamineHook, FunctionsLinux._ZN11CNWSMessage41SendServerToPlayerExamineGui_CreatureDataEP10CNWSPlayerj, HookOrder.Earliest); delegate * unmanaged <void *, void *, uint, void> pDoorExamineHook = &OnDoorExamine; doorExamineHook = HookService.RequestHook <DoorExamineHook>(pDoorExamineHook, FunctionsLinux._ZN11CNWSMessage37SendServerToPlayerExamineGui_DoorDataEP10CNWSPlayerj, HookOrder.Earliest); delegate * unmanaged <void *, void *, uint, void> pItemExamineHook = &OnItemExamine; itemExamineHook = HookService.RequestHook <ItemExamineHook>(pItemExamineHook, FunctionsLinux._ZN11CNWSMessage37SendServerToPlayerExamineGui_ItemDataEP10CNWSPlayerj, HookOrder.Earliest); delegate * unmanaged <void *, void *, uint, void> pPlaceableExamineHook = &OnPlaceableExamine; placeableExamineHook = HookService.RequestHook <PlaceableExamineHook>(pPlaceableExamineHook, FunctionsLinux._ZN11CNWSMessage42SendServerToPlayerExamineGui_PlaceableDataEP10CNWSPlayerj, HookOrder.Earliest); return(new IDisposable[] { creatureExamineHook, doorExamineHook, itemExamineHook, placeableExamineHook }); }
/// <summary> /// Instantiates the DirectX overlay, by first finding the applicable /// version of DirectX for the application and then finding the individual /// details. For more details, see <see cref="DX9Overlay"/> /// Note: This method is blocking and Reloaded mods are required to return in order /// to boot up the games, please do not assign this statically - instead assign it in a background thread! /// </summary> /// <param name="renderDelegate"> /// A delegate type to use for DirectX rendering. The delegate type should /// contain an appropriate DirectX <see cref="Direct3D9Device_EndSceneDelegate"/> /// object for drawing overlays. /// </param> /// <param name="resetDelegate"> /// A delegate or function of type of <see cref="Direct3D9Device_ResetDelegate"/> to call when D3D9 fires its Reset function, /// called on resolution change or windowed/fullscreen change - we can reset some things as well. /// </param> /// <param name="hookDelay"> /// Specifies the amount of time to wait until the hook is instantiation begins. /// Some games are known to crash if DirectX is hooked too early. /// </param> public static async Task <DX9Overlay> CreateDirectXOverlay(Direct3D9Device_EndSceneDelegate renderDelegate, Direct3D9Device_ResetDelegate resetDelegate, int hookDelay) { // Wait the hook delay. await Task.Delay(hookDelay); // Create a new self-object. DX9Overlay dx9Overlay = new DX9Overlay(); // Wait for DirectX Direct3DVersion direct3DVersion = await DXHookCommon.GetDirectXVersion(); // Return nothing if not D3D9 if (direct3DVersion != Direct3DVersion.Direct3D9) { Bindings.PrintError( "libReloaded Hooking: DirectX 9 module not found, the application is either not" + "a DirectX 9 application or uses an unsupported version of DirectX."); return(null); } // Instantiate DX9 hook dx9Overlay.DirectX9Hook = new DX9Hook(); // Obtain Virtual Function Table Entries VirtualFunctionTable.TableEntry endSceneTableEntry = dx9Overlay.DirectX9Hook.DirectXFunctions[(int)Direct3DDevice9.EndScene]; VirtualFunctionTable.TableEntry resetTableEntry = dx9Overlay.DirectX9Hook.DirectXFunctions[(int)Direct3DDevice9.Reset]; // Hook relevant DirectX functions. if (IntPtr.Size == 4) { // X86 dx9Overlay.EndSceneHook = FunctionHook <Direct3D9Device_EndSceneDelegate> .Create((long)endSceneTableEntry.FunctionPointer, renderDelegate); dx9Overlay.ResetHook = FunctionHook <Direct3D9Device_ResetDelegate> .Create((long)resetTableEntry.FunctionPointer, resetDelegate); } else if (IntPtr.Size == 8) { // X64 dx9Overlay.EndSceneHook64 = X64FunctionHook <Direct3D9Device_EndSceneDelegate> .Create((long)endSceneTableEntry.FunctionPointer, renderDelegate); dx9Overlay.ResetHook64 = X64FunctionHook <Direct3D9Device_ResetDelegate> .Create((long)resetTableEntry.FunctionPointer, resetDelegate); } // Return our DX9Overlay return(dx9Overlay); }
/// <summary> /// Your own user code starts here. /// If this is your first time, do consider reading the notice above. /// It contains some very useful information. /// </summary> public static void Init() { /* * Reloaded Mod Loader Sample: File Monitor (New) * Architectures supported: X86, X64 * * Retrieves our Windows API function pointer by first grabbing a handle to Ntdll where * the individual function is located then calls the GetProcAddress() Windows API function * in order to obtain the address of the exported function. * * We then hook the function using the Reloaded hooking classes, print to console the filename * and redirect to the original function. */ // Debugger.Launch(); // This should automatically resolve to ntdll.dll as it is already registered by Windows. // The handle should return from already loaded library in memory, following the standard search strategy. IntPtr ntdllHandle = Reloaded.Process.Native.Native.LoadLibraryW("ntdll"); // Get the addresses of our desired NtCreateFile IntPtr ntCreateFilePointer = Reloaded.Process.Native.Native.GetProcAddress(ntdllHandle, "NtCreateFile"); // Hook the obtained function pointers. // X86 if (IntPtr.Size == 4) { if (ntCreateFilePointer != IntPtr.Zero) { _ntCreateFileHook = FunctionHook <NtCreateFile> .Create((long)ntCreateFilePointer, NtCreateFileImpl).Activate(); } } // X64 else if (IntPtr.Size == 8) { if (ntCreateFilePointer != IntPtr.Zero) { _ntCreateFileHook64 = X64FunctionHook <NtCreateFile> .Create((long)ntCreateFilePointer, NtCreateFileImpl).Activate(); } } }
/// <summary> /// Your own user code starts here. /// If this is your first time, do consider reading the notice above. /// It contains some very useful information. /// </summary> public static unsafe void Init() { #if DEBUG Debugger.Launch(); #endif // Get graphics settings _graphicsSettings = Settings.GraphicsSettings.ParseConfig(ModDirectory); Settings.GraphicsSettings.WriteConfig(_graphicsSettings, ModDirectory); // Will add comments if they are not present. // Hooks _rwCameraSetViewWindowHook = FunctionHook <RWAspect.RwCameraSetViewWindow> .Create(0x0064AC80, RwCameraSetViewWindowImpl).Activate(); _cameraBuildPerspClipPlanesHook = FunctionHook <RWAspect.CameraBuildPerspClipPlanes> .Create(0x0064AF80, CameraBuildPerspClipPlanesImpl).Activate(); _readConfigFromIniHook = FunctionHook <ReadConfigfromINI> .Create(0x00629CE0, ReadConfigFromIniImpl).Activate(); // Patches PatchHardcodedResolutions(); PatchWindowStyle(); if (_graphicsSettings.StupidlyFastLoadTimes) { GameProcess.WriteMemory((IntPtr)0x0078A578, (double)9999999999F); } if (_graphicsSettings.EnableAspectHack) { _someTitlecardCreateHook = FunctionHook <TObjCamera_Init> .Create(0x0061D3B0, TObjCameraInitHook).Activate(); } if (_graphicsSettings.Disable2PFrameskip) { GameProcess.WriteMemory((IntPtr)0x402D07, new byte[] { 0x90 }); } if (_graphicsSettings.D3D9Settings.Enable) { _dx9Device = new Device(_graphicsSettings.D3D9Settings, ModDirectory); } }
/* Entry Point */ public static unsafe void Init() { #if DEBUG Debugger.Launch(); #endif // Setup controllers. var controllerManager = new ControllerManager(); playerOneController = new ReloadedController(Player.PlayerOne, controllerManager); playerTwoController = new ReloadedController(Player.PlayerTwo, controllerManager); playerThreeController = new ReloadedController(Player.PlayerThree, controllerManager); playerFourController = new ReloadedController(Player.PlayerFour, controllerManager); // Hook get controls function. psPADServerHook = FunctionHook <psPADServerPC> .Create(0x444F30, PSPADServerImpl).Activate(); // Copy the old function to a new place and create a function from it. byte[] periMakeRepeatBytes = GameProcess.ReadMemory((IntPtr)0x00434FF0, 0xDD); IntPtr functionPtr = MemoryBufferManager.Add(periMakeRepeatBytes); periMakeRepeatFunction = FunctionWrapper.CreateWrapperFunction <sGamePeri__MakeRepeatCount>((long)functionPtr); periMakeRepeatCountHook = FunctionHook <sGamePeri__MakeRepeatCount> .Create(0x00434FF0, MakeRepeatCountImpl).Activate(); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, void *, int, int> pHook = &OnCanUseItem; Hook = HookService.RequestHook <CanUseItemHook>(pHook, FunctionsLinux._ZN12CNWSCreature10CanUseItemEP8CNWSItemi, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, uint, uint, uint, int> pHook = &OnRequestBuy; Hook = HookService.RequestHook <RequestBuyHook>(pHook, FunctionsLinux._ZN12CNWSCreature10RequestBuyEjjj, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, uint, uint, void> pHook = &OnPayToIdentifyItem; Hook = HookService.RequestHook <PayToIdentifyItemHook>(pHook, FunctionsLinux._ZN12CNWSCreature17PayToIdentifyItemEjj, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, ushort, void *, void *, void> pHook = &OnSendFeedbackMessage; Hook = HookService.RequestHook <SendFeedbackMessageHook>(pHook, FunctionsLinux._ZN12CNWSCreature19SendFeedbackMessageEtP16CNWCCMessageDataP10CNWSPlayer, HookOrder.Earliest); return(new IDisposable[] { Hook }); }
public Factory(HookService hookService) { reloadAllHook = hookService.RequestHook <ReloadAllHook>(OnReloadAll, FunctionsLinux._ZN8CNWRules9ReloadAllEv, HookOrder.Latest); LoadRules(); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, void *, void *, int, int> pHook = &OnEffectApplied; Hook = HookService.RequestHook <OnEffectAppliedHook>(pHook, FunctionsLinux._ZN21CNWSEffectListHandler15OnEffectAppliedEP10CNWSObjectP11CGameEffecti, HookOrder.Earliest); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, void *, byte, int> pHook = &OnHandlePlayerToServerLevelUpMessage; Hook = HookService.RequestHook <HandlePlayerToServerLevelUpMessageHook>(pHook, FunctionsLinux._ZN11CNWSMessage34HandlePlayerToServerLevelUpMessageEP10CNWSPlayerh, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, byte, void> pHook = &OnSetDetectMode; Hook = HookService.RequestHook <SetDetectModeHook>(pHook, FunctionsLinux._ZN12CNWSCreature13SetDetectModeEh, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, void *, int, int> pHook = &OnDoListenDetection; Hook = HookService.RequestHook <DoListenDetectionHook>(pHook, FunctionsLinux._ZN12CNWSCreature17DoListenDetectionEPS_i, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, byte, byte, byte, void> pHook = &OnClearMemorizedSpellSlot; Hook = HookService.RequestHook <ClearMemorizedSpellSlotHook>(pHook, FunctionsLinux._ZN17CNWSCreatureStats23ClearMemorizedSpellSlotEhhh, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override unsafe IDisposable[] RequestHooks() { delegate * unmanaged <void *, void *, int> pHook = &OnSendServerToPlayerCharList; Hook = HookService.RequestHook <SendServerToPlayerCharListHook>(pHook, FunctionsLinux._ZN11CNWSMessage26SendServerToPlayerCharListEP10CNWSPlayer, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, byte, byte, uint, Vector3, uint, uint, int, int> pHook = &OnUseSkill; Hook = HookService.RequestHook <UseSkillHook>(pHook, FunctionsLinux._ZN12CNWSCreature8UseSkillEhhj6Vectorjji, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, uint, int> pHook = &OnLearnScroll; Hook = HookService.RequestHook <LearnScrollHook>(pHook, FunctionsLinux._ZN12CNWSCreature11LearnScrollEj, HookOrder.Early); return(new IDisposable[] { Hook }); }
protected override IDisposable[] RequestHooks() { delegate * unmanaged <void *, uint, int, int, int, int, Vector3, uint, int, int, int, byte, int, int, int, byte, int> pHook = &OnAddCastSpellActions; Hook = HookService.RequestHook <AddCastSpellActionsHook>(pHook, FunctionsLinux._ZN12CNWSCreature19AddCastSpellActionsEjiiii6Vectorjiiihiiih, HookOrder.Early); return(new IDisposable[] { Hook }); }