ISource2ModHookContexts

Every point hands its handler a context: the hooked object, the arguments, and result where the function returns something. What the handler returns is the usual Action:

• Ignore -- nothing changed.
• Override -- pre: the original still runs but the function returns ctx.result; post: the function returns ctx.result instead of what the original produced.
• Supersede -- pre only: the original does not run, the function returns ctx.result. Stops the remaining pre handlers.

Arguments passed by pointer (the damage info, the move data, the weapon) can be changed in place and the original sees the change; arguments passed by value (a speed, a flag) cannot -- HookPoint::Function (FunctionContext) can. Handlers run in registration order, pre before the original and post after it; in post, result holds what the original returned.

The game-function points are one detour per function, placed by the core from its gamedata the first time a plugin asks for it and kept until shutdown (a detour taken out and put back would miss calls while KHook inserts it again). When Valve changes one -- an argument added, the order swapped between platforms, as GroundAccelerate's is -- the core's gamedata and its one call site change, and the plugins keep running.

Header source2mod/ISource2ModHookContexts.h

TakeDamageContext

CBaseEntity::TakeDamageOld(info, result) -> int64

Fields

CanAcquireContext

CCSPlayer_ItemServices::CanAcquire(item, method, unk) -> AcquireResult

Fields

CanMoveContext

CCSPlayerPawnBase::CanMove() -> bool; false while frozen, defusing, ...

Fields

CanUseContext

CCSPlayer_WeaponServices::CanUse(weapon) -> bool

Fields

PostThinkContext

CCSPlayerPawn::PostThink()

Fields

ProcessUsercmdsContext

CCSPlayerController::ProcessUserCmd(cmds, count, paused, margin) -> void*. The commands are CUserCmd (a protobuf-backed type), left untyped here.

Fields

SimulateUserCommandsContext

CBasePlayerController::OnSimulateUserCommands()

Fields

RunCommandContext

CPlayer_MovementServices::RunCommand(cmd), on CCSPlayer_MovementServices' vtable; the command is a CUserCmd.

Fields

AcceptInputContext

CEntityIdentity::AcceptInput(name, activator, caller, value, ...) -> bool

Fields

TouchContext

CBaseEntity::Touch(other), on CBaseEntity's own vtable -- an entity class that overrides Touch is not seen here.

Fields

DropWeaponContext

CCSPlayer_WeaponServices::DropWeapon(weapon, target, velocity)

Fields

MovementContext

The CCSPlayer_MovementServices functions that take the move data alone: AirMove, CheckFalling, CheckParameters, Duck, Friction, PlayerMove, ProcessMovement, WalkMove, WaterMove (void), and CanUnduck, CheckWater, LadderMove, MoveInit (bool, in result).

Fields

AirAccelerateContext

CCSPlayer_MovementServices::AirAccelerate(move, wishDirection, wishSpeed, acceleration)

Fields

GroundAccelerateContext

CCSPlayer_MovementServices::GroundAccelerate(move, wishDirection, frameTime, wishSpeed, acceleration). The engine's argument order differs between Linux and Windows; here it is always this one.

Fields

CategorizePositionContext

CCSPlayer_MovementServices::CategorizePosition(move, stayOnGround)

Fields

CheckVelocityContext

CCSPlayer_MovementServices::CheckVelocity(move, unk)

Fields

FullWalkMoveContext

CCSPlayer_MovementServices::FullWalkMove(move, onGround)

Fields

SetupMoveContext

CCSPlayer_MovementServices::SetupMove(cmd, move); the command is a CUserCmd.

Fields

TryPlayerMoveContext

CCSPlayer_MovementServices::TryPlayerMove(move, firstDest, firstTrace, isSurfing)

Fields

LegacyJumpContext

CCSPlayerLegacyJump::OnJump / CheckJumpButton(move)

Fields

ModernJumpContext

CCSPlayerModernJump::OnJump / CheckJumpButton(move)

Fields

PlayerChatContext

Host_Say(controller, args, teamOnly, ...): a say / say_team line the game is about to print and send. Lines a silent chat trigger hid for a Source2Mod command never get here; "!command" lines do (they stay in chat). Pre: Supersede drops the line (no chat, no player_say event). Source2Mod does not fire a player_chat game event (CounterStrikeSharp does, from its own Host_Say hook): this point is the way to see chat.

Fields

EntityUseInfo

CBaseEntity::Use's argument (activator, caller, USE_TYPE, value).

Fields

SpawnContext

CBaseEntity::Spawn(keyValues) -- the entity's keyvalues are applied here.

Fields

UseContext

CBaseEntity::Use(info) -- a player's +use, a map's Use input. Changing *info in pre changes what the entity gets.

Fields

EntityOtherContext

CBaseEntity::StartTouch / EndTouch / Blocked(other)

Fields

ThinkContext

CBaseEntity::Think() -- the entity's think function, every time it runs.

Fields

KilledContext

CBaseEntity::Event_Killed(damage) -> bool -- health reached 0 and m_lifeState is already "dying". Supersede skips the class's death handling (a player's ragdoll and death, a breakable's gibs).

Fields

WeaponPickupContext

CCSPlayer_WeaponServices::PickupWeapon(weapon) -> 0 refused, 1 taken, 2 taken as ammo -- touching or +using a weapon (SDKHooks' WeaponEquip / WeaponCanUse). Every player: HookTarget::All() works.

Fields

WeaponSwitchContext

CCSPlayer_WeaponServices::SwitchToWeapon(weapon, viewModelIndex) -> bool (SDKHooks' WeaponSwitch). Every player: HookTarget::All() works.

Fields

GameFrameContext

ISource2Server::GameFrame -- every tick.

Fields

StartupServerContext

INetworkServerService::StartupServer -- a new map's server is up.

Fields

ClientConnectContext

ISource2GameClients::ClientConnect. Pre only means anything: answer { Action::Supersede, false } (or set ctx.result = false and Supersede) to turn the client away, with the reason in ctx.rejectReason. The first handler that refuses ends it. Not called for bots.

Fields

Return

using Return = bool;

ClientConnectedContext

ISource2GameClients::OnClientConnected -- bots too (fakePlayer).

Fields

ClientPutInServerContext

ISource2GameClients::ClientPutInServer.

Fields

ClientDisconnectContext

ISource2GameClients::ClientDisconnect: pre while the client is still in game, post once it is gone.

Fields

ClientSlotContext

ClientVoice, ClientSettingsChanged: which client.

Fields

EmptyContext

GameServerSteamAPIActivated / Deactivated: nothing to pass.

LoadEventsFromFileContext

IGameEventManager2::LoadEventsFromFile -- a resource file of game events.

Fields

Enums

AcquireResult

enum AcquireResult : std::uint32_t

What CCSPlayer_ItemServices::CanAcquire answers.

AcquireMethod

enum AcquireMethod : std::uint32_t

How an item is being acquired in CCSPlayer_ItemServices::CanAcquire.

Macros

SOURCE2MOD_HOOK_CALL_ORIGINAL

#define SOURCE2MOD_HOOK_CALL_ORIGINAL(RET) \
    using Return = RET;                                                   
    RET CallOriginal() const { return callOriginal_(callOriginalData_); } 
    RET (*callOriginal_)(const void*) = nullptr;                          
    const void* callOriginalData_ = nullptr;

Every context ends with CallOriginal(): the game's function, run now with the arguments the game passed, past every hook on it -- SourceHook's SH_CALL. What it returns is what the game would have answered.

In a pre handler the function really runs (with all its side effects), so a handler that calls it should answer Supersede with ctx.result set to the value, or the game runs it a second time after the handlers:

const AcquireResult game = ctx.CallOriginal(); ctx.result = game == AcquireResult::Allowed && Blocked(ctx) ? AcquireResult::NotAllowedByMode : game; return Action::Supersede;

A changed pointed-to object (the damage info, the move data) counts; a scalar field changed in the context does not, the call takes what the game passed. In a post handler ctx.result already holds the game's answer.

The two members after it belong to the core; the movement contexts shared by void and bool functions answer false for the void ones.