Addresses

Source2Mod scans a set of game functions once at startup and hands them out, typed, through ISource2ModAddresses. Each one has a shorthand macro, ADDR_*(), that returns a function pointer ready to call — or to hook.

#include "source2mod/ISource2ModAddresses.h"

if (auto pfnSwitchTeam = ADDR_SWITCH_TEAM())
    pfnSwitchTeam(pController, 3);

The macros read g_pSource2ModAddresses, which SOURCE2MOD_SAVEVARS() fills in Load() (and SOURCE2MOD_GLOBALVARS() declares in your other files). Module inspection, pattern scanning and pointer arithmetic are not here — they are on ISource2ModModule and ISource2ModMemory. Reference: ISource2ModAddresses.

Three ways to reach a game function

The sample plugin shows the first two side by side:

// Way one: Source2Mod resolved it and knows the type.
if (auto pfnSwitchTeam = ADDR_SWITCH_TEAM())
{
    pfnSwitchTeam(pCaller, nNewTeam);
    return;
}

// Way two: any gamedata entry, with the type spelled out by you.
using SwitchTeam_t = void (FASTCALL *)(CCSPlayerController *, unsigned char);

if (auto pfnSwitchTeam = GAMECONFIG_RESOLVE("CCSPlayerController::SwitchTeam").RCast<SwitchTeam_t>())
    pfnSwitchTeam(pCaller, nNewTeam);

// Way three: pCaller->SwitchTeam(nNewTeam) does exactly the above.

Calling past the hooks

An ADDR_* macro hands back the address the signature scan found. That is what you want to hook, but not always what you want to call: once any plugin inline-hooks the function, its first bytes are a jump into the detour, so calling it runs the whole Pre/Post chain.

That is right when you stand in for the game — a plugin dealing damage as if a weapon fired wants the other plugins' rules to apply. It is wrong when you are asking for the function itself — an admin command, a forced round end — where another plugin's rules have no business vetoing what the server was told to do. For that, wrap the call in SOURCE2MOD_ORIGINAL:

SOURCE2MOD_ORIGINAL(ADDR_TAKE_DAMAGE_OLD())(pPawn, &info, &result);

SOURCE2MOD_ORIGINAL(fn) casts KHook::FindOriginal(fn) back to fn's type. It is signature-blind, so it works whatever prototype you hold and however the plugin that hooked the function declared its hook. Unhooked functions come back unchanged, so it is always safe to apply.

HookChain on schema helpers

The schema helpers make the same choice through their last argument, a HookChain (ISource2ModTypes.h):

The default of each helper is what it always did, so existing calls keep their behaviour. CCSGameRules::TerminateRound and CCSPlayerController::TakeDamage default to Bypass (the server was told to end the round or deal the damage); every other helper defaults to Run.

pItemServices->GiveNamedItem("weapon_ak47");                        // hooks run
pController->TakeDamage(pAttacker, 50, DMG_BULLET, HookChain::Run); // opt in to the hooks
pGameRules->TerminateRound(5.0f, nReason);                          // bypasses by default

Helpers that take a HookChain:

When to pick which

• Standing in for the game (a custom weapon dealing damage, a round reward handing out an item): Run. Other plugins' damage rules, item restrictions and so on should apply.
• Doing what the server was told (admin command, forced round end, a gamemode's own rule): Bypass.
• Inside a hook on the same function: Bypass, always — Run would re-enter your own handler. See Recursion.

For your own calls through a vtable index, CALL_VIRTUAL_CHAIN(retType, index, eChain, this, args...) (utils/virtual.h) does the same for virtual functions; ResolveHookChain(fn, eChain) does it for a function pointer.

The ADDR_* macros

Every macro calls the ISource2ModAddresses method of the same name and returns the typedef declared above it in ISource2ModAddresses.h — read that typedef before you call or hook the function, it carries the checked prototype and the platform differences.

Required functions must resolve for Source2Mod to start, so they are never null while it runs. Optional ones are plugin-only hook targets resolved leniently: a pattern that stops matching after a game update leaves them null instead of blocking startup — check before you call or hook them (a hook on a null target is logged and skipped).

Entities and players (required)

Game rules, entity I/O and networking (required)

Optional — may be null

Movement (CCSPlayer_MovementServices::*, all optional):

Jumping (members of the jump components, not of the movement services — all optional):

The gamedata key of each optional function is its function name as listed (CCSPlayer_MovementServices::AirAccelerate, CCSPlayerLegacyJump::OnJump, …).

// Optional target: if the signature broke, KHOOK_INIT() logs it and skips this hook.
KHook::Return<void> OnCheckJumpButtonLegacy(CCSPlayerLegacyJump* pThis, CMoveData* pMove);

KHOOK_MEMBER(m_hCheckJumpButtonLegacy, ADDR_CHECK_JUMP_BUTTON_LEGACY(), &CHooks::OnCheckJumpButtonLegacy, nullptr);