Index > Features

Features

daochook

daochook offers an enhanced player experience by providing a feature-rich platform to work from. Below you can find an overview of the projects main features. Please note, because daochook offers a very in-depth Lua addon interface, the feature-set of the project is endless and ever-expanding by users sharing addons!

Custom Injector / Launcher

daochook ships with its own command line injector/launcher. This allows the project to ensure it is properly launched, injected and ran as expected. The launcher is designed to be easy to use and understand by anyone. The launcher also supports two forms of injecting into the game client.

By injecting into a new process. (Launched by the injector itself.)
By injecting into an existing process.

You may use another injector/launcher if you wish, however that launcher must properly invoke daochook’s installation export function. If you are working on a custom injector for daochook and need help with this, please contact atom0s on the Discord server.

Click to read more...

Injected Hook

daochook operates by being directly injected into the game client (game.dll) process. This gives the project several advantages over standard external third-party tools. By being directly injected, daochook can directly access the games memory, functions, and other data. It can also easily hook and/or patch the game client in various ways. daochook makes use of this by hooking onto several game functions to greatly enhance the client and expose information to addons. (See more information below!)

Hooked Game Functions

daochook takes advantage of being injected by hooking onto several major game functions including:

(Chat) Command Handler - The game function responsible for handling all command input within the client. (Typed, macros, built-in system, menus, etc.)
(Chat) Message Handler - The game function responsible for outputting messages to the chat/combat log window(s).
(Packets) Incoming Packet Handler - The game function responsible for handling incoming packets from the server.
(Packets) Outgoing Packet Handler - The game function responsible for handling outgoing packets from the client.

By hooking onto these functions, daochook is able to do multiple things including:

Read: See any time the function(s) are called and log/view the parameters they were called with.
Block: Prevent the game client from ever seeing the call was made.
Modify: Alter the parameters to change how the call will actually be invoked by the game client.
Inject: Manually invoke the original function to easily inject custom data.

Click to read more...

For example, let’s look closer at the (Chat) Command Handler function. This function is responsible for handling all command input within the client. This function is called whenever the user types something into chat, uses a slash command (ie. /wave), presses a macro, clicks a button that will cause a command to be parsed/interpreted, etc.

The function looks like this:

1void handle_cmd(const char* command, int32_t mode)
2{
3    // ...
4}

The game client also has a secondary input mode pointer that is used with command input that is not passed as a normal argument, it is instead a global variable.

Any time a command is to be handled by the client it will pass through this function. Once hooked, daochook has the ability to fully take control of the function call. Each time the function is called, daochook will first attempt to ‘handle’ it. This means that the command will go through a ‘process’ chain to see if anything can make use of it before it eventually gets sent to the client to be handled as normal.

The order in which things happen looks like this:

Game calls original command handler function.
daochook intercepts the call, forwards it to its own internal handler.
daochook checks for any built-in commands it will handle first. (ie. /addon)
1. If daochook handles the command, it is blocked from being seen by the client.
2. If daochook does not handle the command, the chain continues.
daochook forwards the command to its internal addon manager.
The addon manager sends the command to all loaded addons that have a valid command event handler registered.
1. If an addon handles the command, it is blocked from being seen by the client.
2. If no addon handles the command, the chain continues.
If nothing has handled the command, it is sent to the client as normal.

During this chain, both daochook and/or an addon have the chance to alter any of the parameters of the original call. For example, if the command being handled is /wave and instead you want to do /shrug, you can easily do this with an addon.

This can also be used to modify incoming and outgoing packets, or out-right block packets from being sent or received!

Direct3D Hook

Along with hooking various game functions, daochook also hooks onto the games Direct3D device. This allows the hook to render its own things into the game scene, either in 2D or 3D. The main purpose for this however, is to allow the use of ImGui to render custom in-game UI elements from addons. By hooking the Direct3D interface, it is also possible to alter how the scene renders, helping clean up visibility in various conditions.

Toggling The Game Fog Rendering

The games fog can be toggled on and off with a simple slash command.

Altering The Game Ambient Light Rendering

The games ambient lighting can be toggled on and off, and overridden with a custom color allowing you to see easier in the dark or if your system has a hard time displaying darker areas.

Toggling The Z-Buffer Rendering

The game z-buffer can be toggled on and off with a simple slash command, making it possible to see through walls. (Note: This does not allow you to target or cast through walls! Collision and obstruction still works as normal.)

Custom UI via ImGui

daochook implements and [fully] exposes ImGui to Lua for addons to make use of. You can easily create your own custom UI elements that can interact with the game directly, display useful / important game information, and much much more!

You can find more information about ImGui here: https://github.com/ocornut/imgui

Addons, Powered By Lua!

daochook includes a powerful custom addon system, backed by Lua. (LuaJIT to be more specific, via MoonJIT)

Addons are sandboxed/isolated Lua scripts that can be used to greatly enhance the game play experience of the game. Addons can do a wide varity of things and are able to directly communicate with the game client in multiple ways.

You can access all of the hooked functions directly to allow your addon to easily inject commands, chat messages, packets and more.

Addons also have full access to ImGui, allowing you to create your own feature-rich UI’s.

With the use of LuaJIT, addons also have access to C style structure definitions, casting, and function calling, allowing addons to even further extend their usefulness by directly interacting with game data and functions.

For example, here is a simple addon that will handle the command /derp. Anytime this command is used, it will instead use /wave.

 1addon.name    = 'example';
 2addon.author  = 'atom0s';
 3addon.desc    = 'A simple example addon.';
 4addon.link    = 'https://atom0s.com';
 5addon.version = '1.0';
 6
 7require 'common';
 8require 'daoc';
 9
10hook.events.register('command', 'command_cb', function (e)
11    -- Parse the command into arguments..
12    local args = e.modified_command:args();
13
14    -- Command: /derp
15    if (#args >= 1 and (args[1]:ieq('derp') and e.imode == daoc.chat.input_mode.slash) or args[1]:ieq('/derp')) then
16        -- Mark the command as handled, prevents the game from seeing it..
17        e.blocked = true;
18
19        -- Inject a new command into the handler..
20        daoc.chat.exec(daoc.chat.command_mode.typed, daoc.chat.input_mode.normal, '/wave');
21        return;
22    end
23end);

For full information on addons, please check the developer documentation section of this site!

Window Modifications

daochook modifies the game window such that the icon is shown and overridden with the projects own icon. The window title is also automatically updated to your current characters name to make finding the proper game window when multiboxing much easier. It also allows third-party programs to interact with the game windows much easier as you can just use the window name to find the proper process if you are using certain older tools.

Custom Window Title Override

Custom Window Icon Override

Overridding the window icon and taskbar icons..

Overridding the ALT+Tab window icon..

Custom `user.dat` Override Fix

Long time players will know the bug dealing with the user.dat file and all the headaches it can cause. Crashing while multiboxing can lead to tons of undesired downtime due to having to micro-manage numerous accounts after a crash. daochook includes a custom patch/fix for this problem. When enabled, daochook will override the path that the game attempts to look for your user.dat file, making it individual per-account. This means that each account can easily have its own settings without interferring with another client.

These custom overrides are stored in: <daochook_path>\config\daoc\<account_name>\user.dat

You can easily copy your existing user.dat file(s) into the proper folders based on your account names or allow the client to create a new one for each account you log into with this setting turned on.

No longer do you need to juggle accounts after one crashes to avoid losing all your characters settings!