Namespaces
namespace	Args
	The argument types a command handler's parameter list is written in.

namespace	ChatColors

namespace	CommandSyntax

namespace	InstalledPlugins

namespace	Internal

namespace	Log

namespace	MenuCursor

namespace	PluginDependencies

namespace	Schema

namespace	Theme

namespace	Validation

Classes
struct	AchievementEarned

struct	AchievementEarnedLocal

struct	AchievementEvent

struct	AchievementInfoLoaded

struct	AchievementWriteFailed

struct	AddBulletHitMarker

struct	AddonDecision

struct	AddPlayerSonarIcon

class	Address

struct	AmmoPickup

struct	AmmoRefill

struct	AnnouncePhaseEnd

class	ArgBinder
	The one thing command dispatch needs a running server for. More...

struct	ArgDesc

struct	ArgError
	A binding failure, as the key and tokens the reply is built from. More...

struct	ArgTrait
	What one handler parameter type means to the framework. More...

struct	ArgTrait< Args::Opt< T > >

struct	ArgTrait< T >

struct	ArgUnpack

struct	ArgUnpack< Args::Opt< T > >

struct	Authorized
	A caller/target pair that cleared Policy::Authorize. More...

struct	BaseSubobject

struct	BeginNewMatch

struct	Bindings

struct	BombAbortdefuse

struct	BombAbortplant

struct	BombBeep

struct	BombBegindefuse

struct	BombBeginplant

struct	BombDefused

struct	BombDropped

struct	BombExploded

struct	BombPickup

struct	BombPlanted

struct	BonusUpdated

struct	BotTakeover

struct	BoundArgFor

struct	BoundArgFor< std::tuple< A... > >

struct	BreakBreakable

struct	BreakProp

struct	BrokenBreakable

struct	BulletDamage

struct	BulletImpact
	One bullet landing, fired once per impact (so a shotgun blast produces several). More...

struct	ButtonPress
	A `Button` press inside a custom HUD layout. More...

class	ButtonPresses
	The FilterMessage hook for every plugin: custom HUD button presses, raised on the frame after they arrive. Game thread only. More...

struct	ButtonPressMessage
	The button id a custom HUD Button press carries, read out of a user message's `msg_data`. More...

struct	ButtonRow

struct	BuymenuClose

struct	BuymenuOpen

struct	BuytimeEnded

class	CallbackList

class	CallbackRegistry

struct	Caller
	Who invoked the command, and how to answer them. More...

struct	CartUpdated

class	CenterHtml
	Re-sends a center-HTML panel until stopped, since CS2 drops center HTML on death, a team switch and HUD updates. `render` runs on every send, so live values stay current. More...

struct	CenterHtmlHeader

class	CenterHtmlMenu
	Menus drawn as center HTML and driven with W/S/A/D/E/R. It needs no client addon, so `runtime.Menus` falls back to it for a player another surface cannot draw for. More...

struct	CenterHtmlView

struct	CharBuf
	A value for a fixed engine character array (`char m_name[N]`). More...

class	ChatInput
	Per-player pending-prompt registry for menu free-text input. More...

struct	ChatMessage

struct	ChoiceIndex

struct	ChoiceRow

struct	ChoiceState

struct	ChoppersIncomingWarning

class	ClientConVars
	Asks a connected client what one of its own convars is set to. More...

struct	ClientDisconnect

struct	ClientLoadoutChanged

struct	ClientsideLessonClosed

struct	ClientsideReloadCustomEcon

class	Clock
	The engine's simulation clock, read straight from IVEngineServer2::GetServerGlobals(). More...

struct	Color
	An RGBA color in the engine's byte order, as `m_clrRender` and glow colors hold it. More...

struct	CommandArgList

class	CommandBuilder
	Fluent command registration, returned by CommandManager::Add. More...

struct	CommandDefinition
	One command as the builder assembled it. More...

struct	CommandHandlerArgs
	The parameter list of a handler, after the leading Caller. More...

struct	CommandHandlerArgs< F >

struct	CommandHandlerArgs< R(*)(Caller, A...) noexcept >

struct	CommandHandlerArgs< R(*)(Caller, A...)>

struct	CommandHandlerArgs< R(C::*)(Caller, A...) const >

struct	CommandHandlerArgs< R(C::*)(Caller, A...) const noexcept >

struct	CommandHandlerArgs< R(C::*)(Caller, A...) noexcept >

struct	CommandHandlerArgs< R(C::*)(Caller, A...)>

struct	CommandHandlerArgs< R(Caller, A...)>

class	CommandManager
	Typed commands for chat and the server console. More...

class	CommandNames

class	CommandRouter
	The registered commands, their usage lines, and the dispatch that runs one. More...

struct	ConfirmMenu

struct	ConnectedClient

struct	ConnectRequest

class	Controller
	A player's identity behind a slot: name, money, team, scoreboard row. It survives death and respawn; the body is Pawn(). Its own CBaseEntity fields, such as Health, mean nothing for gameplay. More...

class	ConVar

struct	ConVarChange

class	ConVarOverrides

class	ConVarRawScope

class	ConVars

class	Cooldown
	A per-key cooldown, such as one notice per player per minute. More...

struct	CsGameDisconnected

struct	CsIntermission

struct	CsMatchEndRestart

struct	CsPreRestart

struct	CsPrevNextSpectator

struct	CsRoundFinalBeep

struct	CsRoundStartBeep

struct	CsWinPanelMatch

struct	CsWinPanelRound

struct	CursorRows

class	Damage
	Every entity's damage, from `CBaseEntity::TakeDamageOld`, and a way to deal it. More...

struct	DamageHit

struct	DamageInfo

class	Database
	Async database access over Postgres, MariaDB and SQLite. More...

struct	DatabaseConfig
	Connection parameters for every supported backend. More...

class	DecayingScore
	A score that loses half its weight every half-life - the building block for evidence that should fade with age rather than expire on a window edge. More...

struct	DecoyDetonate

struct	DecoyFiring

struct	DecoyStarted

struct	DefuserDropped

struct	DefuserPickup

struct	DemoSkip

struct	DemoStart

struct	DemoStop

struct	Dialect
	The DDL spellings the three drivers disagree on, one per migration placeholder. More...

struct	DifficultyChanged

struct	DmBonusWeaponStart

struct	DoorBreak

struct	DoorClose

struct	DoorClosed

struct	DoorMoving

struct	DoorOpen

class	DownloadQueue

struct	DroneAboveRoof

struct	DroneCargoDetached

struct	DroneDispatched

struct	DronegunAttack

struct	DropRateModified

struct	DurationMenu

struct	DurationUnitLabels

struct	DynamicShadowLightChanged

struct	DzItemInteraction

struct	EmitSoundParams

class	EnabledCondition

struct	EnableRestartVoting

struct	EndmatchCmmStartRevealItems

struct	EndmatchMapvoteSelectingMap

class	EngineArgBinder

class	EngineClient

struct	EngineDamageInfo

struct	EngineDamageResult

class	EngineHooks
	The engine hooks, installed once for the whole process. More...

struct	EngineInterfaces

class	EngineMovementServices

class	EngineNavPhysics

class	EnginePawn

class	EngineWeaponServices

struct	EnterBombzone

struct	EnterBuyzone

struct	EnterRescueZone

class	Entity
	A live entity, valid for this frame only. More...

struct	EntityKilled

struct	EntityRef

class	EntitySystem
	`runtime.Entities`: finds and creates entities. Everything it returns is valid for this frame only; see Entity. More...

struct	EntityVisible

struct	Error
	One failure: a code to branch on, text for the log, and an optional translation key. More...

class	Event
	A multicast signal with a fixed handler signature: the one way to subscribe in VoltMod. More...

struct	EventLifecycle
	Starting and stopping an Event source, driven by whether anything is listening. More...

struct	EventTicketModified

struct	ExitBombzone

struct	ExitBuyzone

struct	ExitRescueZone

struct	FailedCheck

struct	FinaleStart

struct	FirstbombsIncomingWarning

struct	FlareIgniteNpc

struct	FlashbangDetonate

class	Flow

class	Fn

class	Fn< Ret(Args...)>

struct	FoundBase

struct	GameDataDocument

struct	GameDataEntry

struct	GameDataLocation

struct	GameDataRecord

class	GameDataScanner

class	GameDataTable

struct	GameEnd

class	GameEvents
	Creates, fires and listens to game events. More...

struct	GameInit

struct	GameinstructorDraw

struct	GameinstructorNodraw

struct	GameMessage

struct	GameNewmap

struct	GamePhaseChanged

struct	GameStart

class	GameThreadQueue
	Callbacks worker threads hand to the game thread: Push from any thread, RunAll on the game thread. More...

struct	GameuiHidden

struct	GcConnected

struct	GgKilledEnemy

struct	GlowConfig

class	GlowVision
	Players as team-colored outlines through walls, for one client or one team alone. More...

struct	GrenadeBounce

struct	GrenadeThrown

struct	GuardianWaveRestart

struct	HeaderNameLess

struct	HegrenadeDetonate

struct	HelicopterGrenadePuntMiss

struct	HiddenPlayer

struct	HideDeathpanel

struct	HltvCameraman

struct	HltvChangedMode

struct	HltvChase

struct	HltvChat

struct	HltvFixed

struct	HltvMessage

struct	HltvRankCamera

struct	HltvRankEntity

struct	HltvReplay

struct	HltvReplayStatus

struct	HltvStatus

struct	HltvTitle

struct	HltvVersioninfo

class	HookResult
	A hook before-handler's verdict. More...

class	HookResult< void >

class	Host

struct	HostageCallForHelp

struct	HostageFollows

struct	HostageHurt

struct	HostageKilled

struct	HostageRescued

struct	HostageRescuedAll

struct	HostageStopsFollowing

struct	HostnameChanged

class	HttpClient
	Runs HTTP requests off the game thread and their completions on it. More...

struct	HttpRequest

struct	HttpResult

struct	Image

struct	InfernoExpire

struct	InfernoExtinguish

struct	InfernoStartburn

struct	InputHistorySample

struct	InputRow

struct	InspectWeapon

struct	InstalledScan

struct	InstructorCloseLesson

struct	InstructorServerHintCreate

struct	InstructorServerHintStop

struct	InstructorStartLesson

struct	Interfaces
	Centralized holder for all HL2SDK interface pointers. More...

struct	InventoryUpdated

struct	IPermissions
	The server's permission source, published by one plugin (admin-system) through `runtime.Exchange`. More...

struct	IPluginAddons

struct	IPluginContext

struct	IPluginEvents

struct	IPluginGameData

struct	IPluginLanguages

struct	IPluginServices

struct	ItemEquip

struct	ItemPickup

struct	ItemPickupFailed

struct	ItemPickupSlerp

struct	ItemPurchase

struct	ItemRemove

struct	ItemSchemaInitialized

struct	JointeamFailed

class	Json
	System.Text.Json-style helpers for mapping C++ types to and from JSON. More...

class	KeyValues
	Spawn keyvalues such as "origin", "spawnflags" or "effect_name". More...

class	KHookForwarder
	The loader's KHook, which every module's hooks go through. More...

struct	Labeled

class	LanguageTable

class	LayoutPath
	A layout resource the client will accept, checked before anything is spawned. More...

class	LazyHook
	An engine hook that exists only while one of its events has handlers. More...

struct	LeakReport

struct	LoadConfigOptions
	Paths and translation behavior for LoadConfig. More...

struct	LoadedPlugin

struct	LoaderHandoff

struct	LoadList

class	LoadReport

struct	LocalPlayerControllerTeam

struct	LocalPlayerPawnChanged

struct	LocalPlayerTeam

struct	LootCrateOpened

struct	LootCrateVisible

class	Map

class	MappedFile

struct	MapShutdown

struct	MapTransition

struct	MatchEndConditions

struct	MaterialDefaultComplete

struct	MbInputLockCancel

struct	MbInputLockSuccess

class	MemberBinder

struct	MemoryRegion

struct	Menu

class	MenuBuilder

struct	MenuButton

class	MenuFreeze
	Holding players still while a menu is open, for every menu surface. More...

struct	MenuHeader

struct	MenuItem

struct	MenuOptions

class	MenuRouter
	`runtime.Menus`: the surface menus start on, chosen once per session. More...

struct	MenuRow

class	MenuStack
	One player's open menus, and the row behaviour every surface shares. More...

class	MenuSurface

struct	MenuTab

class	Messages
	Send chat, center print, center HTML, and alert messages. More...

struct	Migration

struct	MigrationOptions

struct	MigrationResult

struct	ModuleScan

class	ModuleSymbols

struct	MolotovDetonate

class	Movement
	Each player's command from CCSPlayer_MovementServices::RunCommand. More...

class	MovementFreeze
	Holds one pawn still and gives its move type back to that pawn only, so a player who respawns while held never inherits the dead body's. Keep one per player. More...

class	MultiAddonManager

class	MultiRecipientFilter
	Routes a user message or filtered sound to a chosen set of player slots. Starts empty; callers add each recipient (e.g. every connected slot for a broadcast). More...

struct	NavBlocked

struct	NavGenerate

class	NetChannels
	Per-client network-channel access: latency and the client's replicated userinfo cvars. More...

struct	NextlevelChanged

class	Offset

class	Offset< void >

struct	OpenCrateInstr

class	Options
	Owns a plugin's settings and republishes them whole on every Load. More...

struct	OtherDeath

class	PanoramaMenu
	Run menu sessions on a plugin's PanoramaMenuLayout. More...

class	PanoramaMenuLayout
	The screen built from the `menu` Panorama block, as PanoramaMenu draws on it. More...

struct	PanoramaMenuSettings
	The "menu" section of a plugin with a Panorama menu screen. More...

struct	ParachuteDeploy

struct	ParachutePickup

struct	PatternByte

class	Pawn
	A player's body: health, armor, movement, aim, weapons. The engine replaces it on every spawn; the Controller is the identity that stays. More...

class	PendingCommit
	One held-back row commit per player: what a stepped row was left showing, applied once the stepping stops. More...

class	PendingConVarQueries
	Bookkeeping for ClientConVars: per-slot, cookie-keyed queries awaiting an answer. More...

struct	PendingConVarQuery
	One outstanding client convar query, identified by the cookie sent to the client. More...

class	PerSlot
	Per-player-slot value store that never leaks state across occupants. More...

struct	PhysgunPickup

class	Player
	One connected player, owned by PlayerManager for the length of the connection. More...

struct	PlayerActivate

struct	PlayerAvengedTeammate

struct	PlayerBlind

struct	PlayerChangename

struct	PlayerChat

class	PlayerCommands
	The RunCommand hook for every plugin: each command is decoded once, and only while a plugin listens. Game thread only. More...

struct	PlayerConnect

struct	PlayerConnectFull

struct	PlayerDeath

struct	PlayerDecal

struct	PlayerDisconnect

struct	PlayerFalldamage

struct	PlayerFootstep

struct	PlayerFullUpdate

struct	PlayerGivenC4

struct	PlayerHintmessage

struct	PlayerHurt

struct	PlayerInfo

struct	PlayerInput
	Protobuf-free snapshot of the CUserCmd handed to CPlayer_MovementServices::RunCommand, decoded once per command by Movement. More...

struct	PlayerJump

class	PlayerLanguages

class	PlayerManager
	The roster: every connected player, and the signals for the connection lifecycle. More...

struct	PlayerPicker

struct	PlayerPing

struct	PlayerPingStop

struct	PlayerRadio

struct	PlayerRef
	A storable reference to a player: the slot plus the SteamID that occupied it. More...

struct	PlayerResetVote

struct	PlayerScore

class	PlayerScreens
	One layout's player screens, each created the first time something draws for that slot. More...

struct	PlayerShoot

struct	PlayerSound

struct	PlayerSpawn

struct	PlayerSpawned

struct	PlayerStatsUpdated

struct	PlayerTeam

struct	PlayerView

class	Plugin
	Everything a plugin owns for one load cycle. More...

class	PluginContext

struct	PluginDescriptor

struct	PluginDocument

class	PluginLoader
	Finds the installed plugins and loads the ones their dependencies allow. More...

struct	PluginManifest

class	PluginRegistry
	The loaded plugins and the engine events raised on them, one per process. More...

class	Policy
	The one permission and targeting gate, plus the plugin's reply callback. More...

class	Precache

struct	PropSpec

class	PublishedInterfaces

struct	RagdollDissolved

struct	ReadGameTitledata

struct	RefusedPlugin

struct	Reply
	What a command handler answers with. More...

struct	RepostXboxAchievements

struct	ResetGameTitledata

struct	RoundAnnounceFinal

struct	RoundAnnounceLastRoundHalf

struct	RoundAnnounceMatchPoint

struct	RoundAnnounceMatchStart

struct	RoundAnnounceWarmup

struct	RoundEnd

struct	RoundEndUploadStats

struct	RoundFreezeEnd

struct	RoundMvp

struct	RoundOfficiallyEnded

struct	RoundPoststart

struct	RoundPrestart

class	Rounds
	`runtime.Rounds`: the running round's timer, and ending the round with the engine's own win panel and `round_end`, even with `mp_ignore_round_win_conditions` on. Team scores are not changed. More...

struct	RoundStart

struct	RoundStartPostNav

struct	RoundStartPreEntity

struct	RoundTimeWarning

class	Runtime
	Framework services for one load and unload cycle. More...

struct	ScanRange

struct	ScanResult

class	Scheduler
	One-shot delays and repeating timers, run on the game thread. More...

class	SchemaCheck

class	Screen
	A spawned Panorama layout created by ScreenManager. More...

class	ScreenEntity
	The `custom_hud_layout` entity behind a Screen: spawning, removal, and every write. More...

class	ScreenManager
	Create Screen objects and report their button presses. More...

struct	ScriptFunctionBinding

struct	ScriptTarget

struct	SeasoncoinLevelup

class	ServerAssets

class	ServerCommand
	RAII server console command: registers a tier1 ConCommand on construction and unregisters on destruction. More...

struct	ServerCvar

struct	ServerMessage

struct	ServerPreShutdown

struct	ServerShutdown

struct	ServerSpawn

class	ServiceExchange
	Typed view of the host's table of interfaces plugins publish to each other. More...

struct	SetInstructorGroupEnabled

struct	Sfuievent

class	SharedLibrary

struct	SharedState

struct	ShowDeathpanel

struct	ShowSurvivalRespawnStatus

struct	SilencerDetach

struct	SilencerOff

struct	SilencerOn

class	SingleRecipientFilter
	Routes a user message to a single player slot. More...

class	SlotEvents
	"The occupant of this slot changed" - raised by PlayerManager, consumed below it. More...

struct	SmokeBeaconParadrop

struct	SmokegrenadeDetonate

struct	SmokegrenadeExpired

struct	SpecModeUpdated

struct	SpecTargetUpdated

struct	SslModeName

struct	StandardPluginSettings
	The "plugin" section of settings.jsonc. LoadConfig applies the locale. More...

struct	StartHalftime

struct	StartSoundEventInfo

struct	StartVote

class	StatusService
	Build text and JSON diagnostics from named providers. More...

class	SteamId
	Static utilities for converting between SteamID formats (64-bit, SteamID2, SteamID3). More...

struct	StorePricesheetUpdated

struct	StringHash

class	Strings
	Collection of static string manipulation utilities. More...

struct	SubmenuRow

class	Subscription
	Owns one registration and releases it on destruction. More...

class	Subscriptions
	Holds the subscriptions an object makes and releases them together, newest first. More...

struct	SubtickMove

class	SummaryRows

struct	SurvivalAnnouncePhase

struct	SurvivalNoRespawnsFinal

struct	SurvivalNoRespawnsWarning

struct	SurvivalParadropBreak

struct	SurvivalParadropSpawn

struct	SurvivalTeammateRespawn

struct	SwitchTeam

struct	TagrenadeDetonate

struct	TargetFailure

struct	TargetQuery

struct	TargetRules

struct	TeamchangePending

struct	TeamInfo

struct	TeamIntroEnd

struct	TeamIntroStart

struct	TeamplayBroadcastAudio

struct	TeamplayRoundStart

struct	TeamScore

class	Teleport
	Report player pawn moves through CBaseEntity::Teleport. More...

struct	TextMessage

class	TextMessages
	Outgoing TextMsg user messages, the game's own lines included. More...

struct	TextRow

class	Time

struct	ToggleRow

struct	TournamentReward

class	Trace
	`runtime.Trace`: line and box traces against the physics world. Game-thread only. More...

struct	TraceHit

struct	TraceOptions

class	Translations
	Localization system. Loads one JSON file per language; nested objects flatten into dotted keys (`category.punish`). Use Get(key, slot) for per-player text. More...

struct	TrialTimeExpired

struct	TypeInfoKinds

struct	UgcFileDownloadFinished

struct	UgcFileDownloadStart

struct	UgcMapDownloadError

struct	UgcMapInfoReceived

struct	UgcMapUnsubscribed

struct	UnsafeServices
	Opt-in access to raw engine interfaces and typed gamedata bindings. More...

struct	UpdateMatchmakingStats

struct	UserDataDownloaded

struct	VipEscaped

struct	VipKilled

class	VirtualFn

class	VirtualFn< Ret(Object *, Args...)>

struct	VirtualSlot

class	Visibility
	Which clients receive which entities, filtered after CheckTransmit. More...

class	VoltCommand

class	Vote
	The game's yes/no vote panel (F1/F2), with the ballots counted here. More...

struct	VoteCast

struct	VoteCastNo

struct	VoteCastYes

struct	VoteChanged

struct	VoteEnded

struct	VoteFailed

struct	VoteOptions

struct	VotePassed

struct	VoteRequest

struct	VoteStarted

struct	VoteTally

struct	WaitingRequest

struct	WarmupEnd

class	WeaponDrop
	A player's own weapon drops, from `CCSPlayer_WeaponServices::DropWeapon`. More...

struct	WeaponDropRequest

struct	WeaponFire

struct	WeaponFireOnEmpty

struct	WeaponhudSelection

struct	WeaponReload

struct	WeaponZoom

struct	WeaponZoomRifle

class	WorkshopDownloads

class	WriteCache
	What each player, or everyone, was last sent on one screen, so an unchanged write is skipped. More...

struct	WriteGameTitledata

struct	WriteProfileData

Concepts
concept	NamesArgKind

concept	CommandArg

concept	CommandSignature

concept	HasOneCallOperator

concept	ConVarValue

concept	RawConVarValue

concept	MenuRowSpec

Typedefs
using	BoundArg = typename BoundArgFor< Args::All >::Type

template<class T >
using	Result = std::expected< T, Error >

using	Status = std::expected< void, Error >

template<class Value >
using	StringMap = std::unordered_map< std::string, Value, StringHash, std::equal_to<> >

using	Tokens = std::map< std::string, std::string >

template<class TFirst , class TSecond >
using	PairCooldown = Cooldown< std::pair< TFirst, TSecond >, std::map< std::pair< TFirst, TSecond >, int64_t > >

using	PostgresConnection = sqlpp::postgresql::connection

using	MariaDbConnection = sqlpp::mysql::connection

using	SqliteConnection = sqlpp::sqlite3::connection

using	AnyConnection = std::variant< std::monostate, PostgresConnection, MariaDbConnection, SqliteConnection >

using	HasDefault = std::true_type

using	Required = std::false_type

using	GameDataLookup = std::function< GameDataLocation(GameDataSection sections, std::string_view name)>

using	Vector = ::Vector

using	QAngle = ::QAngle

using	OriginalSlotLookup = std::function< const void (void *vtable, int index)>

using	HttpHeaders = std::map< std::string, std::string, HeaderNameLess >

using	HttpCompletion = std::function< void(const HttpResult &)>

using	PostgresSslMode = sqlpp::postgresql::connection_config::sslmode_t

using	ByteHistogram = std::array< size_t, 256 >

using	ScriptBindingLookup = std::function< Result< ScriptTarget >(void *classTable, std::string_view name)>

using	ProtoMessage = google::protobuf::Message

using	ProtoFieldDescriptor = google::protobuf::FieldDescriptor

using	EmitSoundFilterFn = StartSoundEventInfo(*)(IRecipientFilter &filter, CEntityIndex sourceIndex, const EmitSoundParams &params)

using	PostEvent = void(IGameEventSystem::)(CSplitScreenSlot, bool, int, const uint64 , INetworkMessageInternal , const CNetMessage , unsigned long, NetChannelBufType_t)

using	HandleVector = CUtlVector< CEntityHandle >

using	InterfaceFactory = void ()(const char name, int returnCode)

using	HostStartFn = bool()(const LoaderHandoff start, char *error, size_t errorSize)

using	HostStopFn = void(*)()

using	PluginsByName = std::map< std::string, const PluginManifest *, std::less<> >

using	RefusalsByName = std::map< std::string, Error, std::less<> >

using	StringTable = CUtlVector< CUtlString >

Enumerations
enum class	ArgKind : uint8_t { Target , Targets , Duration , SteamId , PlayerOrSteamId , Int , U64 , Word , Rest }
	Which binder runs for one declared argument. More...

enum class	CommandAccess : uint8_t { Players , Anywhere , ServerOnly }

enum class	LogLevel : uint8_t { Info , Warn , Error }

enum class	ErrorCode : uint8_t { NotFound , NotReady , Invalid , Denied , Immune , Unsupported , Engine , Failed }
	Why an operation did not produce a value. More...

enum class	HookAction : uint8_t { Allow = 0 , Replace , Block }

enum class	Driver { Postgres , MariaDb , Sqlite }

enum class	GameDataSection : uint32_t { Function = 1u << 0 , Global = 1u << 1 , VTable = 1u << 2 , Offset = 1u << 3 }

enum class	Team : uint8_t { None = 0 , Spectator = 1 , T = 2 , CT = 3 }

enum class	HitGroup : int { Invalid = -1 , Generic = 0 , Head = 1 , Chest = 2 , Stomach = 3 , LeftArm = 4 , RightArm = 5 , LeftLeg = 6 , RightLeg = 7 , Neck = 8 }

enum class	ObserverMode : uint8_t { None = 0 , Fixed = 1 , InEye = 2 , Chase = 3 , Roaming = 4 }

enum class	RoundEndReason : uint32_t { CounterTerroristsWin = 8 , TerroristsWin = 9 , Draw = 10 }

enum class	TraceLayers { Sight , Solid , Surfaces }

enum class	ClientConVarStatus { Answered = 0 , NotFound , NotAConVar , Protected }
	How the client answered a convar query (CCLCMsg_RespondCvarValue::status_code). More...

enum class	VoteEndReason { AllVoted , TimeUp , Cancelled }

enum class	HttpMethod { Get , Post , Put , Patch , Delete }

enum class	ChoiceApply { AfterStep , OnActivate }

enum class	MenuRowKind { Text , Button , Submenu , Toggle , Choice , Input }

enum class	MenuButtonKind { Cancel , Back , Close , PreviousPage , NextPage , Tab , Row , StepDown , StepUp }

enum class	MessageKind { Chat , Center , CenterHtml , Alert }

enum class	Origin : uint8_t { Chat , Console }

enum class	TargetError { NoMatch , Immune , Ambiguous , MultiNotAllowed , DeadNotAllowed , BotNotAllowed }

enum class	TargetKind { All , Me , NotMe , Team , Dead , Alive , Bots , Humans , Random , RandomTeam , Slot , SteamId , Name }

enum class	ConVarType : int16_t { Invalid = -1 , Bool , Int16 , UInt16 , Int32 , UInt32 , Int64 , UInt64 , Float32 , Float64 , String , Color , Vector2 , Vector3 , Vector4 , QAngle , VectorWS }

enum class	AddonAction { Unchanged , Send , TrimToFirst , Kick , KeepMounted }

enum class	WriteKind { Text , Class }

Functions
template<class TConfig >
TConfig	LoadConfig (Runtime &runtime, TConfig config={}, const LoadConfigOptions &options={})
	Load the plugin's settings, then its translations, and return `config`.

template<std::size_t... I>
consteval bool	ArgKindsMatchOrder (std::index_sequence< I... >)

template<class... A>
consteval bool	OptionalsTrail ()

template<class... A>
consteval bool	RestIsLast ()

template<class... A>
std::vector< ArgDesc >	DescribeArgs ()

Result< std::string >	ReadAllText (std::string_view path)
	Read `path` (resolved via ResolvePath) into a string.

Status	WriteAllText (std::string_view path, std::string_view text)
	Write `text` to `path` (resolved via ResolvePath), creating its directory.

void	SetBaseDir (const std::filesystem::path &baseDir)
	Set the base directory for path resolution (the host's `csgo` directory). Must be called during initialization before any file loading.

std::filesystem::path	ResolvePath (std::string_view relativePath)
	a relative path against the base directory. If the path is already absolute, returns it as-is.

std::string	PluginDir (std::string_view plugin)
	"addons/voltmod/plugins/<plugin>". Pure string building, so safe at static init.

std::string	PluginFile (std::string_view plugin, std::string_view relative)
	"addons/voltmod/plugins/<plugin>/<relative>".

std::size_t	RandomIndex (std::size_t count)

constexpr bool	IsValidSlot (int slot)

template<class E >
constexpr std::string_view	Name (E value) noexcept

template<class E >
constexpr std::optional< E >	Parse (std::string_view name) noexcept

template<class E >
constexpr std::size_t	EnumIndex (E value) noexcept

template<class E >
constexpr auto	EnumValues () noexcept

std::optional< int64_t >	ParseInt64 (std::string_view text)

std::optional< uint64_t >	ParseUInt64 (std::string_view text)

int	ParseDuration (std::string_view text)

MigrationResult	RunMigrations (Database &db, std::string_view dir, const MigrationOptions &options={})

template<class Conn , class Statement >
int64_t	Insert (Conn &conn, const Statement &insert, std::string_view table, std::string_view key="id")

template<class Conn , class Update , class Statement >
void	Upsert (Conn &conn, const Update &update, const Statement &insert)

std::optional< Driver >	ParseDriver (std::string_view name)

std::string	DriverName (Driver driver)

std::optional< int >	ParseMigrationVersion (std::string_view filename)

Dialect	DialectFor (Driver driver)

Result< std::string >	ResolveDialect (std::string_view sql, Driver driver)

std::vector< std::string >	SplitStatements (std::string_view sql)

template<class T >
std::string	ConVarText (const T &value)

template<>
std::string	ConVarText< bool > (const bool &value)

template<>
std::string	ConVarText< int > (const int &value)

template<>
std::string	ConVarText< float > (const float &value)

template<>
std::string	ConVarText< std::string > (const std::string &value)

const void *	ReadOriginalSlot (void **vtable, int index)

constexpr GameDataSection	operator\| (GameDataSection left, GameDataSection right)

Vector	AngleToForward (const QAngle &angles)

template<typename T >
T *	MemberPtr (void *base, std::ptrdiff_t offset) noexcept

template<typename T >
T	ReadAt (void *base, std::ptrdiff_t offset) noexcept

template<typename T >
void	WriteAt (void *base, std::ptrdiff_t offset, const T &value) noexcept

constexpr bool	IsPlaying (Team team)

constexpr Team	Opposite (Team team)

constexpr int	PageCount (int items, int perPage)

constexpr int	WrapIndex (int value, int count)

bool	IsRowActionable (const MenuItem &item, int slot)

void	AppendPlayerRows (MenuBuilder &builder, PlayerManager &players, const PlayerPicker &spec)

std::shared_ptr< Menu >	BuildPlayerPicker (PlayerManager &players, PlayerPicker spec)

std::shared_ptr< Menu >	BuildDurationMenu (DurationMenu spec)

std::shared_ptr< Menu >	BuildConfirmMenu (ConfirmMenu spec)

template<class Iface , class Ret , class... Args, class Before , class After = std::nullptr_t>
Subscription	HookInterface (Ret(Iface::method)(Args...), Iface instance, Before &&before, After &&after=nullptr)
	Hook one virtual method of an engine interface for a subscription's lifetime.

template<class Object , class Ret , class... Args, class Before , class After = std::nullptr_t>
Result< Subscription >	HookVirtual (std::string_view name, const VirtualFn< Ret(Object *, Args...)> &function, Before &&before, After &&after=nullptr)
	Hook a gamedata-bound virtual function on objects sharing its class vtable.

template<class Object , class Ret , class... Args, class Before , class After = std::nullptr_t>
Result< Subscription >	HookFunction (std::string_view name, const Fn< Ret(Object *, Args...)> &function, Before &&before, After &&after=nullptr)
	Hook a signature-bound function at its entry.

template<class Iface , class Ret , class... Args, class... Passed>
Ret	CallOriginal (Ret(Iface::method)(Args...), Iface instance, Passed &&... args)

static ArgError	TargetKey (const TargetFailure &failure, const std::string &token)

static std::expected< Args::Target, ArgError >	BindTarget (ArgBinder &binder, const std::string &token, Player *caller)

static std::expected< Args::Targets, ArgError >	BindTargets (ArgBinder &binder, const std::string &token, Player *caller)

static std::expected< Args::PlayerOrSteamId, ArgError >	BindPlayerOrSteamId (ArgBinder &binder, const std::string &token, Player *caller)

static std::expected< Args::Duration, ArgError >	BindDuration (const std::string &token)

static std::expected< Args::SteamId, ArgError >	BindSteamId (const std::string &token)

static std::expected< Args::Int, ArgError >	BindInt (const std::string &token)

static std::expected< Args::U64, ArgError >	BindU64 (const std::string &token)

template<class T >
static std::optional< ArgError >	Store (std::expected< T, ArgError > parsed, std::vector< BoundArg > &bound)

std::expected< std::vector< BoundArg >, ArgError >	BindArgs (const CommandDefinition &def, std::span< const std::string > tokens, Player *caller, ArgBinder &binder)

static std::string	FailureLine (const Error &error, const Translations &translations, int slot)

static std::string	UsagePlaceholderKey (ArgKind kind)

TargetQuery	ParseTargetToken (std::string_view token)

std::expected< std::vector< int >, TargetFailure >	FilterPlayers (std::span< const PlayerView > players, const TargetQuery &query, const TargetRules &rules, int callerSlot, const std::function< std::size_t(std::size_t)> &randomIndex)

std::string_view	GameBuild ()

static std::string	ReplaceAll (const std::string &str, const std::string &from, const std::string &to)

static void	FlattenInto (const glz::generic &node, const std::string &prefix, StringMap< std::string > &out)

static const StringMap< std::string > &	KitDefaults ()

static bool	IsValidTableName (const std::string &name)

static std::string	HistoryTableDdl (const std::string &table)

template<class Conn >
static void	ApplyMigration (Conn &conn, const std::string &table, const Migration &migration, const std::vector< std::string > &statements)

static std::optional< PostgresSslMode >	ParseSslMode (std::string_view name)

static sqlpp::postgresql::connection_config	PostgresSettings (const DatabaseConfig &config)

static sqlpp::mysql::connection_config	MariaDbSettings (const DatabaseConfig &config)

static sqlpp::sqlite3::connection_config	SqliteSettings (const DatabaseConfig &config)

Result< Driver >	CheckConfig (const DatabaseConfig &config)

bool	IsOpen (const AnyConnection &connection)

void	OpenConnection (AnyConnection &connection, Driver driver, const DatabaseConfig &config)

template Result< ConVar< std::string > >	ConVars::Find< std::string > (std::string_view)

template<class T >
bool	ConVarTypeMatches (ConVarType type)

template bool	ConVarTypeMatches< bool > (ConVarType)

template bool	ConVarTypeMatches< int > (ConVarType)

template bool	ConVarTypeMatches< float > (ConVarType)

template bool	ConVarTypeMatches< std::string > (ConVarType)

template<>
std::string	ConVarText< bool > (const bool &value)

template<>
std::string	ConVarText< int > (const int &value)

template<>
std::string	ConVarText< float > (const float &value)

template<>
std::string	ConVarText< std::string > (const std::string &value)

std::vector< PatternByte >	ParsePattern (const std::string &pattern)

void	CountBytes (const uint8_t *base, size_t size, ByteHistogram &counts)

size_t	AnchorOf (const std::vector< PatternByte > &pattern, const ByteHistogram &frequencies)

static bool	Matches (const uint8_t *at, const std::vector< PatternByte > &pattern)

const uint8_t *	FindFirst (const uint8_t *base, size_t size, const std::vector< PatternByte > &pattern, size_t anchor)

bool	FindModuleAndRanges (std::string_view fileName, Image &module, std::vector< ScanRange > &ranges)

static std::string_view	BaseName (std::string_view path)

static int	DlIterateCallback (struct dl_phdr_info info, size_t, void data)

static std::string_view	BaseName (std::string_view path)

static bool	SameFileName (std::string_view left, std::string_view right)

constexpr uintptr_t	Rel32Site (uintptr_t matchAddress, int ripOffset) noexcept

constexpr uintptr_t	Rel32Target (uintptr_t site, int32_t displacement, int ripSize=Rel32Size) noexcept

constexpr bool	Rel32ReadInBounds (uintptr_t moduleBase, size_t moduleSize, uintptr_t matchAddress, int ripOffset) noexcept

static const ScriptFunctionBinding *	FindBinding (const ScriptClassDesc_t *description, std::string_view name)

static int	VirtualIndex (const void *function)

Result< ScriptTarget >	FindScriptBinding (void *classTable, std::string_view name)

static const ByteHistogram &	FrequenciesOf (const Image &module, const std::vector< ScanRange > &ranges)

std::string	PlatformModuleName (std::string_view moduleName)

bool	FindImage (std::string_view moduleName, Image &module)

ScanResult	FindPatternEx (std::string_view moduleName, const std::string &pattern)

uintptr_t	ResolveRelativeAddress (const Image &module, uintptr_t matchAddress, int ripOffset, int ripSize)

static std::optional< MemoryRegion >	QueryRegion (const void *address)

bool	IsExecutableAddress (const void *address)

bool	IsReadableAddress (const void *address, size_t bytes)

void *	FindVirtualTable (std::string_view moduleName, std::string_view className)

static uintptr_t	ReadWord (uintptr_t address)

static uint32_t	ReadU32 (uintptr_t address)

static std::vector< uintptr_t >	FindWords (std::span< const ScanRange > ranges, uintptr_t value)

std::string	LengthPrefixedName (std::string_view className)

void *	FindVirtualTableByTypeName (std::span< const ScanRange > ranges, std::string_view className)

bool	IsInstanceOf (const void object, const void table)

static bool	LooksLikeTypeInfo (uintptr_t address)

static bool	NameIs (uintptr_t address, std::string_view wanted)

static bool	HasSingleBase (uintptr_t typeInfo, const TypeInfoKinds &kinds)

static uint32_t	BaseCount (uintptr_t typeInfo, const TypeInfoKinds &kinds)

static void	CollectBases (uintptr_t typeInfo, std::string_view wanted, FoundBase at, const TypeInfoKinds &kinds, int depth, std::vector< FoundBase > &found)

Result< int >	FindBaseOffsetByTypeInfo (const void *typeInfo, std::string_view baseName, const TypeInfoKinds &kinds)

void *	FindVirtualTableByTypeInfo (std::span< const ScanRange > ranges, const void *typeInfo, intptr_t offsetToTop)

void *	FindVirtualTableIn (const Image &module, std::string_view className)

Result< BaseSubobject >	FindBaseIn (const Image &module, std::string_view className, std::string_view baseName)

static uint64_t	FindSymbolValue (const MappedFile &elf, const std::string &symbol)

static bool	RangesOf (const Image &module, std::vector< ScanRange > &ranges)

static const TypeInfoKinds &	ExportedTypeInfoKinds ()

static const uint8_t *	FindValue (const uint8_t begin, const uint8_t end, const void *needle, size_t len, size_t stride)

template<typename T >
static T	ReadAt (const uint8_t *address)

static const uint8_t *	End (const ScanRange &range)

static const uint8_t *	AtRva (const PeRtti &rtti, int64_t rva, size_t bytes)

static std::array< std::string, 2 >	ClassAndStructNames (std::string_view name)

static uint32_t	FindTypeDescriptor (const PeRtti &rtti, std::string_view className)

static bool	TypeDescriptorMatches (const PeRtti &rtti, int32_t rva, std::span< const std::string > names)

static const uint8_t *	FindLocator (const PeRtti &rtti, uint32_t typeDescriptor, uint32_t offset)

static void *	TableAfter (const PeRtti &rtti, const uint8_t *locator)

static std::pair< uint32_t, const uint8_t * >	PrimaryLocator (const PeRtti &rtti, std::string_view className)

void *	FindVirtualTableInRtti (const PeRtti &rtti, std::string_view className)

Result< BaseSubobject >	FindBaseInRtti (const PeRtti &rtti, std::string_view className, std::string_view baseName)

static ScanRange	FindSection (const Image &module, std::string_view name)

static PeRtti	RttiOf (const Image &module)

bool	PostUserMessage (Interfaces &interfaces, INetworkMessageInternal &cached, std::string_view partialName, IRecipientFilter &filter, const std::function< bool(CNetMessage )> &fill)

const ProtoFieldDescriptor *	ProtoField (const ProtoMessage &message, std::string_view name)

const void *	FilterClient (const Bindings &bindings, const INetworkMessageProcessingPreFilter &filter)

int	ClientSlot (const Bindings &bindings, const void *client)

Log::Handler	MakeConsoleHandler (std::string prefix)
	The default handler: tier0 `ConColorMsg`/`Msg`, one colour per level.

static bool	TokenizeOneCommand (std::string_view command, CCommand &args)

static void	FireInput (const Bindings &bindings, CEntityInstance entity, std::string_view input, variant_t &value, CEntityInstance activator)

static Schema::CGameSceneNode	SceneNode (const Entity &entity)

static bool	IsModelEntity (CEntityInstance *entity)

static Schema::CCSGameRules	GameRules (EntitySystem &entities)

static Status	NoGameRules ()

static uint64_t	MaskOf (TraceLayers layers)

static CTraceFilter	MakeFilter (const TraceOptions &options)

static EntityRef	RefOf (const CEntityInstance *entity)

static TraceHit	ToHit (const CGameTrace &trace)

static EngineNavPhysics *	NavPhysics (void *&table)

static void	SetWeapon (IGameEvent &event, std::string_view weapon)

static Result< Subscription >	HookTeleport (const Bindings &bindings, EntitySystem &entities, Event< int > &before)

static HookResult< void >	FilterTextMessage (Event< TextMessage & > &before, INetworkMessageInternal kind, const CNetMessage data)

static void	AddIndex (HiddenPlayer &player, int index)

static void	AddHandleVector (EntitySystem &entities, HiddenPlayer &player, const void *vector)

static CEntityInstance *	ObserverTarget (EntitySystem &entities, int recipientSlot)

static void	CollectHiddenPlayer (EntitySystem &entities, int slot, bool pawnHidden, bool controllerHidden, HiddenPlayer &out)

static ProtoMessage *	AsProto (CNetMessage *message)

static const ProtoFieldDescriptor *	VoteField (ProtoMessage *message, std::string_view name)

static void	SetInt (ProtoMessage *message, std::string_view name, int32_t value)

static void	SetBool (ProtoMessage *message, std::string_view name, bool value)

static void	SetString (ProtoMessage *message, std::string_view name, const std::string &value)

static std::string_view	Text (const char *text)

static HookResult< void >	RunCommand (PluginRegistry &registry, std::string_view name, const CCommand &arguments, int slot)

static HookResult< bool >	AdmitClient (PluginRegistry &registry, int slot, uint64_t xuid, std::string_view name, CBufferString *rejectReason)

static std::string_view	ClientAddress (IVEngineServer2 *server, CPlayerSlot slot)

static Result< Subscription >	HookSessionManifest (PluginRegistry &registry)

template<class Iface >
static Status	Find (Iface &target, InterfaceFactory factory, const char version)

template<class Iface >
static void	FindOptional (Iface &target, InterfaceFactory factory, const char version)

Result< EngineInterfaces >	ResolveEngineInterfaces (const LoaderHandoff &start)

template<class TEntry >
const auto &	PlatformColumn (const TEntry &entry)

void	WriteGameDataRecord (const GameDataRecord &resolved)

static std::unexpected< Error >	Unbound (std::string reason)

static uint64_t	Rva (const Image &module, const void *address)

static Result< ScanResult >	Scan (std::string_view moduleName, const std::string &pattern)

template<class TEntry >
static Result< int >	ColumnValue (const TEntry &entry, std::string_view what)

static const void *	OriginalSlot (void *table, int index, const OriginalSlotLookup &originalOf)

static std::unexpected< Error >	Unbound (std::string reason)

static Result< uint64_t >	ReadVarint (std::string_view bytes, size_t &at)

static Status	SkipField (std::string_view bytes, size_t &at, uint32_t wireType)

static int	OwnerSlot (void *movementServices)

Status	ValidateDescriptor (const PluginDescriptor *descriptor, std::string_view hostVersion)

static void	RefuseUnsatisfied (const PluginsByName &plugins, RefusalsByName &refused)

static void	WarnLeaks (std::string_view name, const LeakReport &leaks)

static std::filesystem::path	LibraryPath (std::string_view name)

static InstalledScan	Installed ()

static void	RaiseCommand (CallbackList< IPluginEvents::PlayerCommandFn > &listeners, int slot, const PlayerInput &input)

static std::string	LastError ()

static void *	OpenLibrary (const std::filesystem::path &path)

static void *	FindExport (void handle, const char name)

static void	CloseLibrary (void *handle)

static std::vector< std::string_view >	SplitAddonList (std::string_view field)

std::vector< uint64_t >	ParseAddonList (std::string_view field)

std::vector< uint64_t >	AppendToAddonList (std::string &field, const std::vector< uint64_t > &ids)

void	RemoveFromAddonList (std::string &field, const std::vector< uint64_t > &ids)

static CUtlString *	AddonList (const Bindings &bindings, CNetworkGameServerBase &server)

static HttpResult	ToResult (cpr::Response &&response)

static HttpResult	Perform (const HttpRequest &request, const std::atomic_bool &stopped)

static bool	SameKey (std::string_view left, std::string_view right)

static std::string_view	NextWord (std::string_view &line)

std::vector< std::string >	GameSearchPaths (std::string_view gameinfo)
	The `Game` values under `SearchPaths` in a `gameinfo.gi`, in file order.

template<class Fn >
static Fn	SwapSlot (void *object, int index, Fn replacement)

static std::filesystem::path	GameDir ()

static std::string	ReadFile (const std::filesystem::path &path)

static InterfaceFactory	LoadNextServer ()

static InterfaceFactory	FindNextFactory ()

static void	StartHost ()

static bool	OnConnect (void *config, InterfaceFactory engineFactory)

static InitReturnVal_t	OnInit (void *server)

static void	StopHost ()

static void	OnShutdown (void *server)

static void	OnDisconnect (void *config)

static void	Patch (const char name, void object)

void *	OpenModule (const std::filesystem::path &path)

std::filesystem::path	OwnPath ()

InterfaceFactory	FactoryAt (const void *address)

static HMODULE	ModuleAt (const void *address)

static CursorRows	CursorRowsFor (Menu *menu, int slot)

std::string	RenderHeader (const CenterHtmlHeader &header)

static std::string	FooterChunk (std::string_view keyColor, std::string_view keyText, const std::string &label)

std::string	RenderFooter (bool isSubmenu, bool isPaginated, bool selectedRowSteps, int slot, Translations &translations)

static std::string	RowText (const MenuRow &row)

static std::string	RenderItems (const CenterHtmlView &view, int pageStart, int pageEnd, MenuRow &selected)

std::string	RenderMenuHtml (const Menu *menu, const CenterHtmlView &view, Translations &translations)

std::string	RenderCaptureOverlay (const std::string &menuTitle, std::string_view prompt)

static std::function< MenuRow(int)>	DescribeRow (std::string label, MenuRowKind kind, EnabledCondition enabled, std::function< void(int slot, MenuRow &row)> live={})

static std::function< void(int, MenuSurface &)>	WhenEnabled (EnabledCondition enabled, std::function< void(int, MenuSurface &)> action)

static bool	IsSelectable (const CursorRows &rows, int index)

static PendingCommit::Timer	TimerOn (Scheduler &scheduler)

static std::string	EnsureColorPrefix (std::string_view message)

static std::string	Render (std::string_view message, MessageKind kind)

static int	HudDestination (MessageKind kind)

static Subscription	ListenForCommands (IPluginEvents &events, Movement &movement)

static Subscription	ListenForPresses (IPluginEvents &events, ScreenManager &screens)

static Error	NotSourceXml (std::string_view layout)

static void	SetStr (CUtlString &out, std::string_view text)

Variables
template<class T >
constexpr bool	IsOptionalArg = false

constexpr int	MaxPlayers = 64

constexpr int	EveryoneSlot = -1

template<class E >
constexpr std::size_t	EnumCount = magic_enum::enum_count<E>()

template<class Conn >
constexpr bool	IsPostgres = std::same_as<std::remove_cvref_t<Conn>, PostgresConnection>

template<class Conn >
constexpr bool	IsMariaDb = std::same_as<std::remove_cvref_t<Conn>, MariaDbConnection>

template<class Conn >
constexpr bool	IsSqlite = std::same_as<std::remove_cvref_t<Conn>, SqliteConnection>

constexpr uint32_t	DamageGeneric = 0

constexpr uint32_t	DamageCrush = 1u << 0

constexpr uint32_t	DamageBullet = 1u << 1

constexpr uint32_t	DamageSlash = 1u << 2

constexpr uint32_t	DamageBurn = 1u << 3

constexpr uint32_t	DamageFall = 1u << 5

constexpr uint32_t	DamageBlast = 1u << 6

constexpr uint32_t	DamageClub = 1u << 7

constexpr uint32_t	DamageShock = 1u << 8

constexpr uint32_t	DamageHeadshot = 1u << 19

constexpr const char *	PluginEntryName = "VoltMod_Plugin"

static std::filesystem::path	g_baseDir

static constexpr size_t	MaxQueuedJobs = 4096

static constexpr auto	ReconnectBackoff = std::chrono::seconds(5)

static constexpr SslModeName	SslModes []

static constexpr PostgresSslMode	TlsModes []

static constexpr std::string_view	InMemory = ":memory:"

constexpr int	Rel32Size = 4

static constexpr size_t	TypeInfoBase = 2 * sizeof(void*)

static constexpr size_t	TypeInfoFlags = 2 * sizeof(void*)

static constexpr size_t	TypeInfoCount = TypeInfoFlags + sizeof(uint32_t)

static constexpr size_t	TypeInfoBaseList = 3 * sizeof(void*)

static constexpr size_t	BaseEntrySize = 2 * sizeof(void*)

static constexpr uintptr_t	VirtualBaseFlag = 1

static constexpr uint32_t	MaxBases = 64

static constexpr int	MaxDepth = 32

static constexpr size_t	TypeDescriptorName = 0x10

static constexpr size_t	LocatorOffset = 0x04

static constexpr size_t	LocatorTypeDescriptor = 0x0C

static constexpr size_t	LocatorHierarchy = 0x10

static constexpr size_t	LocatorSelf = 0x14

static constexpr size_t	LocatorSize = 0x18

static constexpr size_t	HierarchyBaseCount = 0x08

static constexpr size_t	HierarchyBaseList = 0x0C

static constexpr size_t	HierarchySize = 0x10

static constexpr size_t	BaseMemberOffset = 0x08

static constexpr size_t	BaseVirtualOffset = 0x0C

static constexpr size_t	BaseSize = 0x18

static constexpr uint32_t	MaxBases = 1024

static constexpr float	MinScale = 0.05f

static constexpr float	MaxScale = 3.0f

static constexpr std::string_view	ControllerClass = "cs_player_controller"

static constexpr int	SolidNone = 0

static constexpr int	SolidVPhysics = 6

static constexpr uint64_t	SightMask = CONTENTS_SOLID \| CONTENTS_BLOCK_LOS

static constexpr uint64_t	SurfacesMask = CONTENTS_SOLID \| CONTENTS_WINDOW \| CONTENTS_PASS_BULLETS \| CONTENTS_SKY

static constexpr int	PropSpawnFlags = 256

static constexpr int	GlowRangeUnits = 5000

static constexpr int	GlowTeamAny = -1

static constexpr int	GlowStateAlwaysOn = 3

static constexpr int	GlowRenderAmt = 1

static constexpr int	MaxIndicesPerPlayer = 24

static constexpr std::string_view	ControllerClass = "vote_controller"

static constexpr int	YesNoIssueIndex = 2

static constexpr int	NoIssue = -1

static constexpr int	AllTeams = -1

static constexpr int	YesOption = 0

static constexpr int	NoOption = 1

static constexpr std::string_view	VoteStartMessage = "CCSUsrMsg_VoteStart"

static constexpr std::string_view	VotePassMessage = "CCSUsrMsg_VotePass"

static constexpr std::string_view	VoteFailedMessage = "CCSUsrMsg_VoteFailed"

static constexpr std::string_view	CommandUsage

constexpr std::string_view	PlatformName = "linux"

static constexpr std::string_view	GameDataPath = "addons/voltmod/gamedata/gamedata.jsonc"

static Host	g_host

static constexpr std::string_view	UserMessageName = "CSVCMsg_UserMessage"

static constexpr int32_t	CustomHudClickType = 390

static constexpr int64_t	WarningIntervalSeconds = 10

static constexpr uint32_t	WireVarint = 0

static constexpr uint32_t	WireFixed64 = 1

static constexpr uint32_t	WireLengthDelimited = 2

static constexpr uint32_t	WireFixed32 = 5

static constexpr int	MaxVarintBytes = 10

constexpr const char *	HostStartName = "VoltMod_HostStart"

constexpr const char *	HostStopName = "VoltMod_HostStop"

static constexpr std::string_view	ManifestName = "plugin.json"

static constexpr std::string_view	LibrarySuffix = ".so"

static constexpr std::string_view	EntitySystemOffset = "GameEntitySystem"

static constexpr double	DownloadTimeoutSeconds = 30.0

static constexpr int	MaxDownloadAttempts = 3

static constexpr double	ForgetAfterSeconds = 12.0 * 60.0 * 60.0

static constexpr size_t	MaxWorkers = 4

static constexpr size_t	MaxWaiting = 64

static constexpr std::string_view	Blank = " \t\r"

static KHookForwarder	g_dispatcher

static std::string	g_gameDir

static LoaderHandoff	g_start {.HookDispatcher = &g_dispatcher}

static HostStopFn	g_stopHost = nullptr

static bool(*	g_connect )(void *config, InterfaceFactory engineFactory) = nullptr

static void(*	g_disconnect )(void *config) = nullptr

static InitReturnVal_t(*	g_init )(void *server) = nullptr

static void(*	g_shutdown )(void *server) = nullptr

constexpr std::string_view	PlatformDir = VOLTMOD_BIN_DIR

constexpr std::string_view	HostFile = VOLTMOD_HOST_FILE

constexpr std::string_view	ServerFile = "libserver.so"

constexpr int	CenterHtmlRowsPerPage = 5

static constexpr std::string_view	kBreadcrumbSeparator = " › "

static constexpr std::string_view	SourceExtension = ".xml"

static constexpr int32_t	ClassAbsent = 0

static constexpr int32_t	ClassPresent = 1

static constexpr int	StringTableCap = 1024

static constexpr int	StringTableHeadroom = 64

static constexpr char	KeySeparator = '\x1f'

Typedef Documentation

◆ AnyConnection

using VoltMod::AnyConnection = typedef std::variant<std::monostate, PostgresConnection, MariaDbConnection, SqliteConnection>

A connection of whichever driver is configured; monostate while closed.

Definition at line 24 of file Connection.hpp.

◆ BoundArg

using VoltMod::BoundArg = typedef typename BoundArgFor<Args::All>::Type

One bound argument. std::monostate is an optional argument the caller omitted.

Definition at line 177 of file Args.hpp.

◆ ByteHistogram

using VoltMod::ByteHistogram = typedef std::array<size_t, 256>

How often each byte value occurs in the memory being searched.

Definition at line 29 of file BytePattern.hpp.

◆ EmitSoundFilterFn

using VoltMod::EmitSoundFilterFn = typedef StartSoundEventInfo (*)(IRecipientFilter& filter, CEntityIndex sourceIndex, const EmitSoundParams& params)

Definition at line 54 of file Entity.cpp.

◆ GameDataLookup

using VoltMod::GameDataLookup = typedef std::function<GameDataLocation(GameDataSection sections, std::string_view name)>

Reads what gamedata holds for name, when sections admits the section holding it.

Injected so Bindings::Bind is unit-tested against a plain lambda; the app passes the host's lookup.

Definition at line 15 of file GameDataLookup.hpp.

◆ HandleVector

using VoltMod::HandleVector = typedef CUtlVector<CEntityHandle>

Definition at line 20 of file Visibility.cpp.

◆ HasDefault

using VoltMod::HasDefault = typedef std::true_type

HasDefault argument of VOLTMOD_COLUMN: the insert may leave this column out.

Definition at line 10 of file Table.hpp.

◆ HostStartFn

using VoltMod::HostStartFn = typedef bool (*)(const LoaderHandoff* start, char* error, size_t errorSize)

Start the host. On false, it wrote why into error, which holds errorSize bytes.

Definition at line 22 of file LoaderHandoff.hpp.

◆ HostStopFn

using VoltMod::HostStopFn = typedef void (*)()

Unload every plugin and remove the host's hooks.

Definition at line 24 of file LoaderHandoff.hpp.

◆ HttpCompletion

using VoltMod::HttpCompletion = typedef std::function<void(const HttpResult&)>

Definition at line 21 of file HttpResult.hpp.

◆ HttpHeaders

using VoltMod::HttpHeaders = typedef std::map<std::string, std::string, HeaderNameLess>

Header name -> value; Content-Type and content-type are one entry.

Definition at line 39 of file HttpClient.hpp.

◆ InterfaceFactory

using VoltMod::InterfaceFactory = typedef void* (*)(const char* name, int* returnCode)

A module's exported CreateInterface.

Definition at line 10 of file LoaderHandoff.hpp.

◆ MariaDbConnection

using VoltMod::MariaDbConnection = typedef sqlpp::mysql::connection

Definition at line 20 of file Connection.hpp.

◆ OriginalSlotLookup

using VoltMod::OriginalSlotLookup = typedef std::function<const void*(void** vtable, int index)>

Reads the value that vtable's index held before a hook patched it, or nullptr. An empty lookup reads the current slot. The injected lookup keeps vtable searches SDK-free; the default implementation is ReadOriginalSlot in Detours.hpp.

Definition at line 13 of file OriginalSlotLookup.hpp.

◆ PairCooldown

template<class TFirst , class TSecond >

using VoltMod::PairCooldown = typedef Cooldown<std::pair<TFirst, TSecond>, std::map<std::pair<TFirst, TSecond>, int64_t> >

std::pair has no std::hash, so pair keys use an ordered map.

Definition at line 76 of file Cooldown.hpp.

◆ PluginsByName

using VoltMod::PluginsByName = typedef std::map<std::string, const PluginManifest*, std::less<> >

Definition at line 15 of file PluginDependencies.cpp.

◆ PostEvent

using VoltMod::PostEvent = typedef void (IGameEventSystem::*)(CSplitScreenSlot, bool, int, const uint64*, INetworkMessageInternal*, const CNetMessage*, unsigned long, NetChannelBufType_t)

Definition at line 11 of file TextMessages.cpp.

◆ PostgresConnection

using VoltMod::PostgresConnection = typedef sqlpp::postgresql::connection

Definition at line 19 of file Connection.hpp.

◆ PostgresSslMode

using VoltMod::PostgresSslMode = typedef sqlpp::postgresql::connection_config::sslmode_t

Definition at line 15 of file OpenConnection.cpp.

◆ ProtoFieldDescriptor

using VoltMod::ProtoFieldDescriptor = typedef google::protobuf::FieldDescriptor

Definition at line 20 of file ProtoReflect.hpp.

◆ ProtoMessage

using VoltMod::ProtoMessage = typedef google::protobuf::Message

Definition at line 19 of file ProtoReflect.hpp.

◆ QAngle

using VoltMod::QAngle = typedef ::QAngle

The engine's angles in degrees: (pitch, yaw, roll), positive pitch looks down.

Definition at line 14 of file Math.hpp.

◆ RefusalsByName

using VoltMod::RefusalsByName = typedef std::map<std::string, Error, std::less<> >

Definition at line 16 of file PluginDependencies.cpp.

◆ Required

using VoltMod::Required = typedef std::false_type

HasDefault argument of VOLTMOD_COLUMN: every insert must supply this column.

Definition at line 13 of file Table.hpp.

◆ Result

template<class T >

using VoltMod::Result = typedef std::expected<T, Error>

A T or an Error. Check with if (result), read *result / result.error().

Definition at line 64 of file Result.hpp.

◆ ScriptBindingLookup

using VoltMod::ScriptBindingLookup = typedef std::function<Result<ScriptTarget>(void* classTable, std::string_view name)>

Finds VScript binding name on the class with vtable classTable or on its bases. Injected so the resolver stays SDK-free.

Definition at line 19 of file ScriptBindings.hpp.

◆ SqliteConnection

using VoltMod::SqliteConnection = typedef sqlpp::sqlite3::connection

Definition at line 21 of file Connection.hpp.

◆ Status

using VoltMod::Status = typedef std::expected<void, Error>

A Result with nothing to return. return {}; succeeds.

Definition at line 67 of file Result.hpp.

◆ StringMap

template<class Value >

using VoltMod::StringMap = typedef std::unordered_map<std::string, Value, StringHash, std::equal_to<> >

A string-keyed map that finds a std::string_view key without building a string.

Definition at line 21 of file StringMap.hpp.

◆ StringTable

using VoltMod::StringTable = typedef CUtlVector<CUtlString>

Definition at line 16 of file ScreenEntity.cpp.

◆ Tokens

using VoltMod::Tokens = typedef std::map<std::string, std::string>

{token} -> replacement, for Strings::SubstituteTokens and the text built on it.

Definition at line 14 of file Strings.hpp.

◆ Vector

using VoltMod::Vector = typedef ::Vector

The engine's Vector. Its default constructor leaves the value uninitialised; write Vector{0.0f, 0.0f, 0.0f} for a zero.

Definition at line 11 of file Math.hpp.

Enumeration Type Documentation

◆ AddonAction

enum class VoltMod::AddonAction

strong

What the hook does to one outgoing join message.

Enumerator
Unchanged	send the message as it is
Send	point the client at AddonDecision::Id and wait for its reconnect
TrimToFirst	the message names several addons; keep only AddonDecision::Id
Kick	the client refused AddonDecision::Id too often
KeepMounted	a map change names no addon; name AddonDecision::Id so the client keeps it

Definition at line 14 of file DownloadQueue.hpp.

◆ ArgKind

enum class VoltMod::ArgKind : uint8_t

strong

Which binder runs for one declared argument.

Derived from the handler's parameter list; plugins never write one. The enumerator name is also the suffix of the argument's usage-placeholder key (ArgKind::Target -> cmd.usage.target), so adding a kind adds one translation key and no switch.

Declaration order is the order of Args::All and of BoundArg's alternatives; a static_assert below holds the three together.

Enumerator
Target
Targets
Duration
SteamId
PlayerOrSteamId
Int
U64
Word
Rest

Definition at line 29 of file Args.hpp.

◆ ChoiceApply

enum class VoltMod::ChoiceApply

strong

When a ChoiceRow runs its Commit.

Enumerator
AfterStep	About 400 ms after the last step, so a burst of presses applies once.
OnActivate	Only on E or a click; stepping just changes what the row shows.

Definition at line 64 of file MenuBuilder.hpp.

◆ ClientConVarStatus

enum class VoltMod::ClientConVarStatus

strong

How the client answered a convar query (CCLCMsg_RespondCvarValue::status_code).

Enumerator
Answered	The client reported the convar's current value.
NotFound	The client has no convar by that name.
NotAConVar	The name exists on the client but is a command, not a convar.
Protected	The convar is marked protected; the client withholds its value.

Definition at line 19 of file ClientConVars.hpp.

◆ CommandAccess

enum class VoltMod::CommandAccess : uint8_t

strong

Who may run a command, and so where it can be typed.

Enumerator
Players	Players, from chat. The default.
Anywhere	Players from chat or their own console, and the server from its console, rcon and cfg files.
ServerOnly	The server only, from its console, rcon and cfg files. Players are ignored.

Definition at line 75 of file CommandBuilder.hpp.

◆ ConVarType

enum class VoltMod::ConVarType : int16_t

strong

SDK-free mirror of EConVarType used by handle validation and console parsing. ConVar.cpp verifies every value against the SDK with static_asserts.

Enumerator
Invalid
Bool
Int16
UInt16
Int32
UInt32
Int64
UInt64
Float32
Float64
String
Color
Vector2
Vector3
Vector4
QAngle
VectorWS

Definition at line 13 of file ConVarTypes.hpp.

◆ Driver

enum class VoltMod::Driver

strong

Database backend selected at runtime by DatabaseConfig::driver.

Enumerator
Postgres
MariaDb
Sqlite

Definition at line 13 of file Driver.hpp.

◆ ErrorCode

enum class VoltMod::ErrorCode : uint8_t

strong

Why an operation did not produce a value.

Coarse on purpose: the code is what a caller branches on, Error::Detail is what a log line says. Adding a code is an API change for every switch over it, so prefer a better Detail.

Enumerator
NotFound	The named thing does not exist (no such player, convar, row).
NotReady	It exists but the subsystem behind it is not usable yet.
Invalid	The caller's input does not parse or does not satisfy a precondition.
Denied	The caller lacks the permission the operation requires.
Immune	The target outranks the caller; a Denied that names the target, not the verb.
Unsupported	The build, the game version, or the gamedata does not offer this at all.
Engine	The engine or SDK refused, returned nothing, or is not where it was expected.
Failed	Anything else; the default so a value-initialized Error is never a false success.

Definition at line 21 of file Result.hpp.

◆ GameDataSection

enum class VoltMod::GameDataSection : uint32_t

strong

The sections of gamedata.jsonc, as flags: an address binds from a function or a global.

Enumerator
Function
Global
VTable
Offset

Definition at line 10 of file GameDataLocation.hpp.

◆ HitGroup

enum class VoltMod::HitGroup : int

strong

The body part a bullet hit. Damage with no bullet, such as fire, the bomb or a fall, is Invalid.

Enumerator
Invalid
Generic
Head
Chest
Stomach
LeftArm
RightArm
LeftLeg
RightLeg
Neck

Definition at line 8 of file HitGroup.hpp.

◆ HookAction

enum class VoltMod::HookAction : uint8_t

strong

What a before-handler decides should happen to the call it intercepted.

Enumerator
Allow	Let the engine's own handler run and keep its return value.
Replace	Let it run, but return this value instead of its own.
Block	Skip it entirely and return this value.

Definition at line 11 of file HookResult.hpp.

◆ HttpMethod

enum class VoltMod::HttpMethod

strong

Enumerator
Get
Post
Put
Patch
Delete

Definition at line 15 of file HttpClient.hpp.

◆ LogLevel

enum class VoltMod::LogLevel : uint8_t

strong

Enumerator
Info
Warn
Error

Definition at line 12 of file Log.hpp.

◆ MenuButtonKind

enum class VoltMod::MenuButtonKind

strong

What a pressed button on the menu stands for.

Enumerator
Cancel
Back
Close
PreviousPage
NextPage
Tab
Row
StepDown
StepUp

Definition at line 18 of file PanoramaMenuLayout.hpp.

◆ MenuRowKind

enum class VoltMod::MenuRowKind

strong

Row type used by renderers.

Enumerator
Text	Not selectable; a caption or a summary line.
Button	Runs something.
Submenu	Opens another menu.
Toggle	Carries an on/off value.
Choice	Carries one of several values, stepped left and right.
Input	Carries a value the player types in chat.

Definition at line 26 of file MenuModel.hpp.

◆ MessageKind

enum class VoltMod::MessageKind

strong

Where a message renders on the client.

Enumerator
Chat	Chat box line (color escapes honored).
Center	Plain center-screen print.
CenterHtml	Center HTML panel (same channel the menu system renders into).
Alert	Top-center alert bar.

Definition at line 15 of file Messages.hpp.

◆ ObserverMode

enum class VoltMod::ObserverMode : uint8_t

strong

How a dead or spectating player's camera follows; Pawn.cpp checks the values against the SDK.

Enumerator
None
Fixed
InEye
Chase
Roaming

Definition at line 9 of file ObserverMode.hpp.

◆ Origin

enum class VoltMod::Origin : uint8_t

strong

Which surface an invocation arrived on. The usage line's prefix and whether a permission is checked at all both follow from it.

Enumerator
Chat
Console

Definition at line 22 of file CommandRouter.hpp.

◆ RoundEndReason

enum class VoltMod::RoundEndReason : uint32_t

strong

Why a round ended, as the engine's CSRoundEndReason numbers it; round_end reports the same.

Enumerator
CounterTerroristsWin
TerroristsWin
Draw

Definition at line 14 of file Rounds.hpp.

◆ TargetError

enum class VoltMod::TargetError

strong

Enumerator
NoMatch
Immune	matches existed, but the policy blocked all of them
Ambiguous	a name fragment matched more than one player
MultiNotAllowed	a multi-selector was used where the command takes a single target
DeadNotAllowed
BotNotAllowed

Definition at line 23 of file Targeting.hpp.

◆ TargetKind

enum class VoltMod::TargetKind

strong

Enumerator
All
Me
NotMe
Team	uses TargetQuery::Team
Dead
Alive
Bots
Humans
Random
RandomTeam	uses TargetQuery::Team
Slot
SteamId
Name

Definition at line 40 of file Targeting.hpp.

◆ Team

enum class VoltMod::Team : uint8_t

strong

Engine team indices, as m_iTeamNum holds them. SDK-free so command parsing can share them.

Enumerator
None
Spectator
T
CT

Definition at line 9 of file Team.hpp.

◆ TraceLayers

enum class VoltMod::TraceLayers

strong

Which interaction layers a trace stops at.

Enumerator
Sight	what hides one player from another
Solid	what a player body collides with, players included
Surfaces	every drawn surface and the sky; no player clips or players

Definition at line 14 of file Trace.hpp.

◆ VoteEndReason

enum class VoltMod::VoteEndReason

strong

Why a vote stopped taking ballots.

Enumerator
AllVoted	every eligible player cast a ballot
TimeUp
Cancelled	an admin (or a peer feature) called it off

Definition at line 23 of file Vote.hpp.

◆ WriteKind

enum class VoltMod::WriteKind

strong

Keeps a text and a class of the same name on the same element apart.

Enumerator
Text
Class

Definition at line 14 of file WriteCache.hpp.

Function Documentation

◆ AddHandleVector()

static void VoltMod::AddHandleVector	(	EntitySystem &	entities,
		HiddenPlayer &	player,
		const void *	vector
	)

static

Definition at line 40 of file Visibility.cpp.

References AddIndex(), MaxIndicesPerPlayer, and ReadFile().

Referenced by CollectHiddenPlayer().

◆ AddIndex()

static void VoltMod::AddIndex	(	HiddenPlayer &	player,
		int	index
	)

static

Definition at line 32 of file Visibility.cpp.

References MaxIndicesPerPlayer, and ReadFile().

Referenced by AddHandleVector(), and CollectHiddenPlayer().

◆ AddonList()

static CUtlString * VoltMod::AddonList	(	const Bindings &	bindings,
		CNetworkGameServerBase &	server
	)

static

The server's addon list, or nullptr when the offset misses the string GetAddonName returns.

Definition at line 148 of file WorkshopDownloads.cpp.

References VoltMod::Log::Error(), and ReadFile().

◆ AdmitClient()

static HookResult< bool > VoltMod::AdmitClient	(	PluginRegistry &	registry,
		int	slot,
		uint64_t	xuid,
		std::string_view	name,
		CBufferString *	rejectReason
	)

static

Ask the plugins about a joining client, and refuse it with the first reason one gives.

Definition at line 44 of file EngineHooks.cpp.

References VoltMod::HookResult< Ret >::Block(), and ReadFile().

Referenced by VoltMod::EngineHooks::EngineHooks().

◆ AnchorOf()

size_t VoltMod::AnchorOf	(	const std::vector< PatternByte > &	pattern,
		const ByteHistogram &	frequencies
	)

Index of the pattern byte to search for, or pattern.size() when it is all wildcards.

Which byte is searched for is what decides a scan's cost, because the rest of the pattern is only compared where that byte lands. The first byte - the obvious anchor - is close to the worst one for x86-64: nearly every signature opens with a REX prefix (0x48), which saturates the image. Measured over CS2's server.dll, anchoring on the rarest byte instead scans ~16x faster.

Definition at line 47 of file BytePattern.cpp.

References ReadFile().

Referenced by FindPatternEx().

◆ AngleToForward()

Vector VoltMod::AngleToForward ( const QAngle & angles )

The unit vector angles aim along; roll does not change it.

Definition at line 7 of file Math.cpp.

References ReadFile().

Referenced by VoltMod::Trace::FromEyes().

◆ AppendPlayerRows()

void VoltMod::AppendPlayerRows	(	MenuBuilder &	builder,
		PlayerManager &	players,
		const PlayerPicker &	spec
	)

Appends one row per connected player to builder.

Definition at line 9 of file PlayerRows.cpp.

References VoltMod::ButtonRow::Label, VoltMod::SubmenuRow::Label, and ReadFile().

Referenced by BuildPlayerPicker().

◆ AppendToAddonList()

std::vector< uint64_t > VoltMod::AppendToAddonList	(	std::string &	field,
		const std::vector< uint64_t > &	ids
	)

Append each of ids that field lacks. Returns the ids appended.

Definition at line 239 of file DownloadQueue.cpp.

References ParseAddonList(), and ReadFile().

◆ ApplyMigration()

template<class Conn >

static void VoltMod::ApplyMigration	(	Conn &	conn,
		const std::string &	table,
		const Migration &	migration,
		const std::vector< std::string > &	statements
	)

static

Definition at line 45 of file Migrator.cpp.

References VoltMod::Time::Now(), and ReadFile().

Referenced by RunMigrations().

◆ ArgKindsMatchOrder()

template<std::size_t... I>

consteval bool VoltMod::ArgKindsMatchOrder ( std::index_sequence< I... > )

Whether every type in Args::All sits at the index its own ArgKind names.

Definition at line 181 of file Args.hpp.

References ReadFile().

◆ AsProto()

static ProtoMessage * VoltMod::AsProto ( CNetMessage * message )

static

Definition at line 41 of file Vote.cpp.

References ReadFile().

◆ AtRva()

static const uint8_t * VoltMod::AtRva	(	const PeRtti &	rtti,
		int64_t	rva,
		size_t	bytes
	)

static

Definition at line 62 of file VtableLookup.windows.cpp.

References ReadFile().

Referenced by FindBaseInRtti(), and TypeDescriptorMatches().

◆ BaseCount()

static uint32_t VoltMod::BaseCount	(	uintptr_t	typeInfo,
		const TypeInfoKinds &	kinds
	)

static

Definition at line 160 of file VtableLookup.cpp.

References BaseEntrySize, IsReadableAddress(), LooksLikeTypeInfo(), MaxBases, ReadFile(), ReadU32(), ReadWord(), TypeInfoBaseList, TypeInfoCount, and TypeInfoFlags.

Referenced by CollectBases().

◆ BaseName() [1/2]

static std::string_view VoltMod::BaseName ( std::string_view path )

static

Definition at line 13 of file Image.linux.cpp.

References ReadFile().

Referenced by DlIterateCallback().

◆ BaseName() [2/2]

static std::string_view VoltMod::BaseName ( std::string_view path )

static

Definition at line 15 of file Image.windows.cpp.

References ReadFile().

◆ BindArgs()

std::expected< std::vector< BoundArg >, ArgError > VoltMod::BindArgs	(	const CommandDefinition &	def,
		std::span< const std::string >	tokens,
		Player *	caller,
		ArgBinder &	binder
	)

Bind tokens against def's argument descriptor.

Arity is the caller's job: this assumes tokens already satisfies def's required count, so a short list can only mean a trailing optional argument. Takes nothing from the router, which is why it is a free function - the descriptor and the binder are the whole input.

Definition at line 133 of file ArgBinding.cpp.

References BindDuration(), BindInt(), BindPlayerOrSteamId(), BindSteamId(), BindTarget(), BindTargets(), BindU64(), Duration, Int, VoltMod::Strings::Join(), PlayerOrSteamId, ReadFile(), Rest, Store(), Target, Targets, U64, VoltMod::Args::Word::Value, VoltMod::Args::Rest::Value, and Word.

Referenced by VoltMod::CommandRouter::Dispatch().

◆ BindDuration()

static std::expected< Args::Duration, ArgError > VoltMod::BindDuration ( const std::string & token )

static

Definition at line 78 of file ArgBinding.cpp.

References VoltMod::Strings::IsNumeric(), VoltMod::ArgError::Key, ParseDuration(), ReadFile(), and VoltMod::Args::Duration::Value.

Referenced by BindArgs().

◆ BindInt()

static std::expected< Args::Int, ArgError > VoltMod::BindInt ( const std::string & token )

static

Definition at line 101 of file ArgBinding.cpp.

References VoltMod::ArgError::Key, ParseInt64(), ReadFile(), and VoltMod::Args::Int::Value.

Referenced by BindArgs().

◆ BindPlayerOrSteamId()

static std::expected< Args::PlayerOrSteamId, ArgError > VoltMod::BindPlayerOrSteamId	(	ArgBinder &	binder,
		const std::string &	token,
		Player *	caller
	)

static

One token to a player if anybody online answers to it, otherwise to a bare SteamID64.

The fallback is only for NoMatch: falling back on Immune would turn a refused target into an offline one and act on it anyway, and on Ambiguous it would pick nobody's id.

Definition at line 57 of file ArgBinding.cpp.

References VoltMod::Strings::IsNumeric(), NoMatch, VoltMod::Args::PlayerOrSteamId::Online, ParseInt64(), ReadFile(), VoltMod::Player::SteamId(), and TargetKey().

Referenced by BindArgs().

◆ BindSteamId()

static std::expected< Args::SteamId, ArgError > VoltMod::BindSteamId ( const std::string & token )

static

Definition at line 91 of file ArgBinding.cpp.

References VoltMod::Strings::IsNumeric(), VoltMod::ArgError::Key, ParseInt64(), ReadFile(), and VoltMod::Args::SteamId::Value.

Referenced by BindArgs().

◆ BindTarget()

static std::expected< Args::Target, ArgError > VoltMod::BindTarget	(	ArgBinder &	binder,
		const std::string &	token,
		Player *	caller
	)

static

One token to the single player it names, or the key explaining why it named none.

Definition at line 30 of file ArgBinding.cpp.

References ReadFile(), TargetKey(), and VoltMod::Args::Target::Value.

Referenced by BindArgs().

◆ BindTargets()

static std::expected< Args::Targets, ArgError > VoltMod::BindTargets	(	ArgBinder &	binder,
		const std::string &	token,
		Player *	caller
	)

static

One token to every player it names. AllowMultiple is what separates this from BindTarget.

Definition at line 41 of file ArgBinding.cpp.

References VoltMod::TargetRules::AllowMultiple, ReadFile(), TargetKey(), and VoltMod::Args::Targets::Value.

Referenced by BindArgs().

◆ BindU64()

static std::expected< Args::U64, ArgError > VoltMod::BindU64 ( const std::string & token )

static

Definition at line 111 of file ArgBinding.cpp.

References VoltMod::ArgError::Key, ParseUInt64(), ReadFile(), and VoltMod::Args::U64::Value.

Referenced by BindArgs().

◆ BuildConfirmMenu()

std::shared_ptr< Menu > VoltMod::BuildConfirmMenu ( ConfirmMenu spec )

The menu ConfirmMenu describes.

Definition at line 62 of file MenuPresets.cpp.

References VoltMod::MenuItem::Describe, VoltMod::MenuRow::Label, and ReadFile().

◆ BuildDurationMenu()

std::shared_ptr< Menu > VoltMod::BuildDurationMenu ( DurationMenu spec )

Builds a duration menu. Invalid text prompts again.

Definition at line 24 of file MenuPresets.cpp.

References VoltMod::InputRow::Label, ParseDuration(), and ReadFile().

Referenced by VoltMod::Flow< TState >::AddDurationStep().

◆ BuildPlayerPicker()

std::shared_ptr< Menu > VoltMod::BuildPlayerPicker	(	PlayerManager &	players,
		PlayerPicker	spec
	)

Builds a menu containing only the AppendPlayerRows list.

Definition at line 47 of file PlayerRows.cpp.

References AppendPlayerRows(), VoltMod::MenuBuilder::Build(), BuildPlayerPicker(), and VoltMod::PlayerPicker::Title.

Referenced by BuildPlayerPicker().

◆ CallOriginal()

template<class Iface , class Ret , class... Args, class... Passed>

Ret VoltMod::CallOriginal	(	Ret(Iface::*)(Args...)	method,
		Iface *	instance,
		Passed &&...	args
	)

The engine's own implementation of method, bypassing every hook on the slot.

Definition at line 218 of file Hook.hpp.

References ReadFile().

◆ CheckConfig()

Result< Driver > VoltMod::CheckConfig ( const DatabaseConfig & config )

The driver config names, or why it cannot connect.

Definition at line 88 of file OpenConnection.cpp.

References VoltMod::Error::Invalid(), ParseDriver(), ParseSslMode(), Postgres, ReadFile(), and Sqlite.

Referenced by VoltMod::Database::Connect().

◆ ClassAndStructNames()

static std::array< std::string, 2 > VoltMod::ClassAndStructNames ( std::string_view name )

static

Definition at line 71 of file VtableLookup.windows.cpp.

Referenced by FindBaseInRtti(), and FindTypeDescriptor().

◆ ClientAddress()

static std::string_view VoltMod::ClientAddress	(	IVEngineServer2 *	server,
		CPlayerSlot	slot
	)

static

A client's address, or empty for a bot, which has no net channel.

Definition at line 60 of file EngineHooks.cpp.

References ReadFile(), and Text.

Referenced by VoltMod::EngineHooks::EngineHooks().

◆ ClientSlot()

int VoltMod::ClientSlot	(	const Bindings &	bindings,
		const void *	client
	)

client's player slot, or -1 when it or the offset is unavailable.

Definition at line 17 of file ServerSideClients.cpp.

References ReadFile().

◆ CloseLibrary()

static void VoltMod::CloseLibrary ( void * handle )

static

Definition at line 60 of file SharedLibrary.cpp.

References ReadFile().

◆ CollectBases()

static void VoltMod::CollectBases	(	uintptr_t	typeInfo,
		std::string_view	wanted,
		FoundBase	at,
		const TypeInfoKinds &	kinds,
		int	depth,
		std::vector< FoundBase > &	found
	)

static

Definition at line 193 of file VtableLookup.cpp.

References BaseCount(), BaseEntrySize, CollectBases(), HasSingleBase(), LooksLikeTypeInfo(), MaxDepth, NameIs(), VoltMod::FoundBase::Offset, ReadFile(), ReadWord(), TypeInfoBase, TypeInfoBaseList, and VirtualBaseFlag.

Referenced by CollectBases(), and FindBaseOffsetByTypeInfo().

◆ CollectHiddenPlayer()

static void VoltMod::CollectHiddenPlayer	(	EntitySystem &	entities,
		int	slot,
		bool	pawnHidden,
		bool	controllerHidden,
		HiddenPlayer &	out
	)

static

Definition at line 67 of file Visibility.cpp.

References AddHandleVector(), AddIndex(), VoltMod::Controller::Controller(), VoltMod::Entity::Raw(), and ReadFile().

Referenced by VoltMod::Visibility::OnCheckTransmit().

◆ ColumnValue()

template<class TEntry >

static Result< int > VoltMod::ColumnValue	(	const TEntry &	entry,
		std::string_view	what
	)

static

A non-negative number from this platform's column, or why there is none.

Definition at line 50 of file GameDataScanner.cpp.

References PlatformColumn(), PlatformName, ReadFile(), and Unbound().

◆ ConVars::Find< std::string >()

template Result< ConVar< std::string > > VoltMod::ConVars::Find< std::string > ( std::string_view )

◆ ConVarText()

template<class T >

std::string VoltMod::ConVarText ( const T & value )

Console and network text for a supported convar value. Bools use 1 and 0 for clients.

Referenced by VoltMod::ConVar< T >::Set(), VoltMod::ConVarOverrides::Set(), and VoltMod::ConVar< T >::SetFor().

◆ ConVarText< bool >() [1/2]

template<>

std::string VoltMod::ConVarText< bool > ( const bool & value )

Definition at line 42 of file ConVarTypes.cpp.

◆ ConVarText< bool >() [2/2]

template<>

std::string VoltMod::ConVarText< bool > ( const bool & value )

Definition at line 42 of file ConVarTypes.cpp.

◆ ConVarText< float >() [1/2]

template<>

std::string VoltMod::ConVarText< float > ( const float & value )

Definition at line 54 of file ConVarTypes.cpp.

◆ ConVarText< float >() [2/2]

template<>

std::string VoltMod::ConVarText< float > ( const float & value )

Definition at line 54 of file ConVarTypes.cpp.

◆ ConVarText< int >() [1/2]

template<>

std::string VoltMod::ConVarText< int > ( const int & value )

Definition at line 48 of file ConVarTypes.cpp.

◆ ConVarText< int >() [2/2]

template<>

std::string VoltMod::ConVarText< int > ( const int & value )

Definition at line 48 of file ConVarTypes.cpp.

◆ ConVarText< std::string >() [1/2]

template<>

std::string VoltMod::ConVarText< std::string > ( const std::string & value )

Definition at line 60 of file ConVarTypes.cpp.

◆ ConVarText< std::string >() [2/2]

template<>

std::string VoltMod::ConVarText< std::string > ( const std::string & value )

Definition at line 60 of file ConVarTypes.cpp.

◆ ConVarTypeMatches()

template<class T >

bool VoltMod::ConVarTypeMatches ( ConVarType type )

Whether a handle for T can access engine kind type.

All integer kinds use int; the engine accessor preserves their storage width. Bool remains a separate kind because accepting an int handle for it silently drops writes.

Definition at line 12 of file ConVarTypes.cpp.

References Bool, Float32, Int16, Int32, String, and UInt16.

◆ ConVarTypeMatches< bool >()

template bool VoltMod::ConVarTypeMatches< bool > ( ConVarType )

◆ ConVarTypeMatches< float >()

template bool VoltMod::ConVarTypeMatches< float > ( ConVarType )

◆ ConVarTypeMatches< int >()

template bool VoltMod::ConVarTypeMatches< int > ( ConVarType )

◆ ConVarTypeMatches< std::string >()

template bool VoltMod::ConVarTypeMatches< std::string > ( ConVarType )

◆ CountBytes()

void VoltMod::CountBytes	(	const uint8_t *	base,
		size_t	size,
		ByteHistogram &	counts
	)

Add the byte values in [base, base + size) to counts.

Definition at line 39 of file BytePattern.cpp.

References ReadFile().

Referenced by FrequenciesOf().

◆ CursorRowsFor()

static CursorRows VoltMod::CursorRowsFor	(	Menu *	menu,
		int	slot
	)

static

The rows of menu as the cursor sees them: how many, and which it may land on.

Definition at line 15 of file CenterHtmlMenu.cpp.

References VoltMod::CursorRows::Count, IsRowActionable(), and ReadFile().

◆ DescribeArgs()

template<class... A>

std::vector< ArgDesc > VoltMod::DescribeArgs ( )

The descriptor the router binds against, derived from the handler's parameter list.

Definition at line 280 of file Args.hpp.

References VoltMod::ArgDesc::Kind.

◆ DescribeRow()

static std::function< MenuRow(int)> VoltMod::DescribeRow	(	std::string	label,
		MenuRowKind	kind,
		EnabledCondition	enabled,
		std::function< void(int slot, MenuRow &row)>	live = `{}`
	)

static

Shared description callback for menu specs.

Definition at line 11 of file MenuBuilder.cpp.

Referenced by VoltMod::Internal::ChoiceItem(), VoltMod::ButtonRow::ToItem(), VoltMod::ToggleRow::ToItem(), VoltMod::InputRow::ToItem(), VoltMod::SubmenuRow::ToItem(), and VoltMod::TextRow::ToItem().

◆ DialectFor()

Dialect VoltMod::DialectFor ( Driver driver )

inline

The spellings driver wants.

Definition at line 71 of file Migrator.hpp.

References MariaDb, Postgres, and Sqlite.

Referenced by ResolveDialect().

◆ DlIterateCallback()

static int VoltMod::DlIterateCallback	(	struct dl_phdr_info *	info,
		size_t	,
		void *	data
	)

static

Definition at line 29 of file Image.linux.cpp.

References BaseName(), and ReadFile().

Referenced by FindModuleAndRanges().

◆ DriverName()

std::string VoltMod::DriverName ( Driver driver )

inline

The config spelling of driver; also the per-dialect migrations folder name.

Definition at line 27 of file Driver.hpp.

References Name, and VoltMod::Strings::ToLower().

◆ End()

static const uint8_t * VoltMod::End ( const ScanRange & range )

static

Definition at line 57 of file VtableLookup.windows.cpp.

References ReadFile().

Referenced by FindLocator(), FindTypeDescriptor(), and TableAfter().

◆ EnsureColorPrefix()

static std::string VoltMod::EnsureColorPrefix ( std::string_view message )

static

Definition at line 25 of file Messages.cpp.

References VoltMod::ChatColors::Default, and ReadFile().

Referenced by Render().

◆ EnumIndex()

template<class E >

constexpr std::size_t VoltMod::EnumIndex ( E value )

constexprnoexcept

Position of value in E's declaration order, for indexing a per-enumerator array.

Definition at line 57 of file EnumNames.hpp.

References ReadFile().

◆ EnumValues()

template<class E >

constexpr auto VoltMod::EnumValues ( )

constexprnoexcept

Every enumerator of E, in declaration order.

Definition at line 64 of file EnumNames.hpp.

◆ ExportedTypeInfoKinds()

static const TypeInfoKinds & VoltMod::ExportedTypeInfoKinds ( )

static

The cxxabi typeinfo vptrs exported by this process, cached for its lifetime.

Definition at line 157 of file VtableLookup.linux.cpp.

References ReadFile(), and VoltMod::TypeInfoKinds::SingleBase.

Referenced by FindBaseIn().

◆ FactoryAt()

InterfaceFactory VoltMod::FactoryAt ( const void * address )

CreateInterface of the loaded module whose image holds address.

Definition at line 34 of file Loader.linux.cpp.

References ReadFile().

Referenced by Patch().

◆ FailureLine()

static std::string VoltMod::FailureLine	(	const Error &	error,
		const Translations &	translations,
		int	slot
	)

static

The line a failed handler replies with: its own localized line, else its key, else the log text.

Definition at line 16 of file CommandRouter.cpp.

References ReadFile().

Referenced by VoltMod::CommandRouter::Dispatch().

◆ FilterClient()

const void * VoltMod::FilterClient	(	const Bindings &	bindings,
		const INetworkMessageProcessingPreFilter &	filter
	)

Return the client containing filter, or nullptr when its offset is unavailable.

Definition at line 8 of file ServerSideClients.cpp.

References ReadFile().

◆ FilterPlayers()

std::expected< std::vector< int >, TargetFailure > VoltMod::FilterPlayers	(	std::span< const PlayerView >	players,
		const TargetQuery &	query,
		const TargetRules &	rules,
		int	callerSlot,
		const std::function< std::size_t(std::size_t)> &	randomIndex = `{}`
	)

The slots of players that match query under rules; random kinds pick one through randomIndex(count). A failure says why the matches were rejected, so the caller can reply.

Definition at line 104 of file Targeting.cpp.

References Ambiguous, BotNotAllowed, DeadNotAllowed, Immune, MultiNotAllowed, NoMatch, ReadFile(), VoltMod::Strings::StartsWith(), and VoltMod::Strings::ToLower().

Referenced by VoltMod::EngineArgBinder::Resolve().

◆ FilterTextMessage()

static HookResult< void > VoltMod::FilterTextMessage	(	Event< TextMessage & > &	before,
		INetworkMessageInternal *	kind,
		const CNetMessage *	data
	)

static

Definition at line 14 of file TextMessages.cpp.

References VoltMod::HookResult< Ret >::Block(), ReadFile(), and VoltMod::TextMessage::Text.

◆ Find()

template<class Iface >

static Status VoltMod::Find	(	Iface *&	target,
		InterfaceFactory	factory,
		const char *	version
	)

static

Naming the version is the point: a game update is what breaks one.

Definition at line 18 of file EngineInterfaces.cpp.

References VoltMod::Error::Engine(), and ReadFile().

Referenced by FindOptional(), and ResolveEngineInterfaces().

◆ FindBaseIn()

Result< BaseSubobject > VoltMod::FindBaseIn	(	const Image &	module,
		std::string_view	className,
		std::string_view	baseName
	)

Find base baseName inside className in module through RTTI.

Returns: NotFound when either class is missing, Invalid when the base is in the class more than once, Unsupported for a virtual base. Table is null when the base has no vtable.

Definition at line 173 of file VtableLookup.linux.cpp.

References ExportedTypeInfoKinds(), FindBaseOffsetByTypeInfo(), FindVirtualTableByTypeInfo(), FindVirtualTableIn(), NotFound, VoltMod::Error::NotFound(), VoltMod::BaseSubobject::Offset, RangesOf(), and ReadFile().

Referenced by VoltMod::ModuleSymbols::Base(), and RttiOf().

◆ FindBaseInRtti()

Result< BaseSubobject > VoltMod::FindBaseInRtti	(	const PeRtti &	rtti,
		std::string_view	className,
		std::string_view	baseName
	)

Definition at line 145 of file VtableLookup.windows.cpp.

References AtRva(), BaseMemberOffset, BaseSize, BaseVirtualOffset, ClassAndStructNames(), FindLocator(), HierarchyBaseCount, HierarchyBaseList, HierarchySize, VoltMod::Error::Invalid(), LocatorHierarchy, MaxBases, VoltMod::Error::NotFound(), VoltMod::BaseSubobject::Offset, PrimaryLocator(), ReadFile(), TableAfter(), TypeDescriptorMatches(), and VoltMod::Error::Unsupported().

Referenced by RttiOf().

◆ FindBaseOffsetByTypeInfo()

Result< int > VoltMod::FindBaseOffsetByTypeInfo	(	const void *	typeInfo,
		std::string_view	baseName,
		const TypeInfoKinds &	kinds
	)

Find baseName in the class described by Itanium typeInfo. Uses the same NotFound, Invalid, and Unsupported errors as FindBaseIn.

Definition at line 233 of file VtableLookup.cpp.

References CollectBases(), VoltMod::Error::Invalid(), LengthPrefixedName(), LooksLikeTypeInfo(), VoltMod::Error::NotFound(), ReadFile(), and VoltMod::Error::Unsupported().

Referenced by FindBaseIn().

◆ FindBinding()

static const ScriptFunctionBinding * VoltMod::FindBinding	(	const ScriptClassDesc_t *	description,
		std::string_view	name
	)

static

Definition at line 25 of file ScriptBindings.cpp.

References VoltMod::ScriptFunctionBinding::Descriptor, and ReadFile().

Referenced by FindScriptBinding().

◆ FindExport()

void * VoltMod::FindExport	(	void *	handle,
		const char *	name
	)

static

Definition at line 55 of file SharedLibrary.cpp.

References ReadFile().

Referenced by StartHost(), and VoltMod::SharedLibrary::Symbol().

◆ FindFirst()

const uint8_t * VoltMod::FindFirst	(	const uint8_t *	base,
		size_t	size,
		const std::vector< PatternByte > &	pattern,
		size_t	anchor
	)

First match of pattern in [base, base + size), searched for by its anchor byte.

Parameters

anchor from AnchorOf, against the frequencies of the memory being searched. Any index of a non-wildcard byte gives the same answer; only the speed differs.

Returns: the match, or nullptr.

Definition at line 80 of file BytePattern.cpp.

References Matches(), and ReadFile().

Referenced by FindPatternEx().

◆ FindImage()

bool VoltMod::FindImage	(	std::string_view	moduleName,
		Image &	module
	)

Definition at line 58 of file SigScanner.cpp.

References FindModuleAndRanges(), PlatformModuleName(), and ReadFile().

Referenced by FindVirtualTable(), and VoltMod::ModuleSymbols::Module().

◆ FindLocator()

static const uint8_t * VoltMod::FindLocator	(	const PeRtti &	rtti,
		uint32_t	typeDescriptor,
		uint32_t	offset
	)

static

Definition at line 103 of file VtableLookup.windows.cpp.

References End(), FindValue(), LocatorOffset, LocatorSelf, LocatorSize, LocatorTypeDescriptor, and ReadFile().

Referenced by FindBaseInRtti(), and PrimaryLocator().

◆ FindModuleAndRanges()

bool VoltMod::FindModuleAndRanges	(	std::string_view	fileName,
		Image &	module,
		std::vector< ScanRange > &	ranges
	)

Locate the exact platform fileName and populate its mapping and readable scan ranges.

Windows returns the mapped image as one range. Linux returns individual PT_LOAD segments because the full module span may contain unmapped gaps.

Returns: false when the module is not loaded. Both outputs remain unchanged.

Definition at line 61 of file Image.linux.cpp.

References DlIterateCallback(), VoltMod::ModuleScan::Name, and ReadFile().

Referenced by FindImage(), FindPatternEx(), and RangesOf().

◆ FindNextFactory()

static InterfaceFactory VoltMod::FindNextFactory ( )

static

Definition at line 108 of file Loader.cpp.

References LoadNextServer(), and ReadFile().

Referenced by CreateInterface().

◆ FindOptional()

template<class Iface >

static void VoltMod::FindOptional	(	Iface *&	target,
		InterfaceFactory	factory,
		const char *	version
	)

static

Definition at line 29 of file EngineInterfaces.cpp.

References VoltMod::Log::Error(), Find(), and ReadFile().

Referenced by ResolveEngineInterfaces().

◆ FindPatternEx()

ScanResult VoltMod::FindPatternEx	(	std::string_view	moduleName,
		const std::string &	pattern
	)

Scan a loaded module for a byte pattern with ? wildcards. Address holds the first match, while Unique reports whether it is safe to bind.

Definition at line 64 of file SigScanner.cpp.

References AnchorOf(), VoltMod::Log::Error(), FindFirst(), FindModuleAndRanges(), FrequenciesOf(), ParsePattern(), PlatformModuleName(), ReadFile(), and VoltMod::Log::Warn().

Referenced by Scan().

◆ FindScriptBinding()

Result< ScriptTarget > VoltMod::FindScriptBinding	(	void *	classTable,
		std::string_view	name
	)

The ScriptBindingLookup the host uses.

Definition at line 75 of file ScriptBindings.cpp.

References VoltMod::ScriptTarget::Address, FindBinding(), VoltMod::ScriptTarget::Index, VoltMod::Error::NotFound(), ReadFile(), and VirtualIndex().

Referenced by VoltMod::Host::Start().

◆ FindSection()

static ScanRange VoltMod::FindSection	(	const Image &	module,
		std::string_view	name
	)

static

Definition at line 205 of file VtableLookup.windows.cpp.

References Name, and ReadFile().

◆ FindSymbolValue()

static uint64_t VoltMod::FindSymbolValue	(	const MappedFile &	elf,
		const std::string &	symbol
	)

static

Definition at line 72 of file VtableLookup.linux.cpp.

References ReadFile().

Referenced by FindVirtualTableIn().

◆ FindTypeDescriptor()

static uint32_t VoltMod::FindTypeDescriptor	(	const PeRtti &	rtti,
		std::string_view	className
	)

static

Definition at line 76 of file VtableLookup.windows.cpp.

References ClassAndStructNames(), End(), FindValue(), ReadFile(), and TypeDescriptorName.

Referenced by PrimaryLocator().

◆ FindValue()

static const uint8_t * VoltMod::FindValue	(	const uint8_t *	begin,
		const uint8_t *	end,
		const void *	needle,
		size_t	len,
		size_t	stride
	)

static

Definition at line 32 of file VtableLookup.windows.cpp.

References ReadFile().

Referenced by FindLocator(), FindTypeDescriptor(), and TableAfter().

◆ FindVirtualTable()

void * VoltMod::FindVirtualTable	(	std::string_view	moduleName,
		std::string_view	className
	)

Find className's primary vtable in loaded moduleName, or nullptr. It uses compiler metadata: MSVC RTTI on Windows (top-level, non-template classes only), and on Linux the Itanium _ZTV symbol, or the Itanium RTTI when the module hides that symbol.

Definition at line 18 of file VtableLookup.cpp.

References FindImage(), FindVirtualTableIn(), PlatformModuleName(), ReadFile(), and VoltMod::Log::Warn().

Referenced by HookSessionManifest().

◆ FindVirtualTableByTypeInfo()

void * VoltMod::FindVirtualTableByTypeInfo	(	std::span< const ScanRange >	ranges,
		const void *	typeInfo,
		intptr_t	offsetToTop
	)

Find the single vtable with typeInfo and offsetToTop whose first slot holds code. Returns nullptr when no candidate exists or the metadata is ambiguous.

Definition at line 260 of file VtableLookup.cpp.

References FindWords(), IsExecutableAddress(), ReadFile(), and ReadWord().

Referenced by FindBaseIn().

◆ FindVirtualTableByTypeName()

void * VoltMod::FindVirtualTableByTypeName	(	std::span< const ScanRange >	ranges,
		std::string_view	className
	)

Definition at line 77 of file VtableLookup.cpp.

References FindWords(), IsExecutableAddress(), LengthPrefixedName(), ReadFile(), and ReadWord().

Referenced by FindVirtualTableIn().

◆ FindVirtualTableIn()

void * VoltMod::FindVirtualTableIn	(	const Image &	module,
		std::string_view	className
	)

Definition at line 129 of file VtableLookup.linux.cpp.

References FindSymbolValue(), FindVirtualTableByTypeName(), LengthPrefixedName(), RangesOf(), and ReadFile().

Referenced by FindBaseIn(), FindVirtualTable(), RttiOf(), and VoltMod::ModuleSymbols::Table().

◆ FindVirtualTableInRtti()

void * VoltMod::FindVirtualTableInRtti	(	const PeRtti &	rtti,
		std::string_view	className
	)

Definition at line 139 of file VtableLookup.windows.cpp.

References PrimaryLocator(), ReadFile(), and TableAfter().

Referenced by RttiOf().

◆ FindWords()

static std::vector< uintptr_t > VoltMod::FindWords	(	std::span< const ScanRange >	ranges,
		uintptr_t	value
	)

static

Definition at line 54 of file VtableLookup.cpp.

References ReadFile(), and ReadWord().

Referenced by FindVirtualTableByTypeInfo(), and FindVirtualTableByTypeName().

◆ FireInput()

static void VoltMod::FireInput	(	const Bindings &	bindings,
		CEntityInstance *	entity,
		std::string_view	input,
		variant_t &	value,
		CEntityInstance *	activator
	)

static

Definition at line 61 of file Entity.cpp.

References ReadFile().

Referenced by VoltMod::Entity::AcceptInput(), and VoltMod::Entity::SetScale().

◆ FlattenInto()

static void VoltMod::FlattenInto	(	const glz::generic &	node,
		const std::string &	prefix,
		StringMap< std::string > &	out
	)

static

Definition at line 15 of file Translations.cpp.

References FlattenInto(), and ReadFile().

Referenced by FlattenInto(), and VoltMod::Translations::Load().

◆ FooterChunk()

static std::string VoltMod::FooterChunk	(	std::string_view	keyColor,
		std::string_view	keyText,
		const std::string &	label
	)

static

Definition at line 56 of file CenterHtmlRender.cpp.

References ReadFile(), and VoltMod::Theme::WarmGray.

Referenced by RenderFooter().

◆ FrequenciesOf()

static const ByteHistogram & VoltMod::FrequenciesOf	(	const Image &	module,
		const std::vector< ScanRange > &	ranges
	)

static

Byte frequencies are stable for a mapped module, so cache them by base address. Count explicit scan ranges because a Linux module's overall span may include unmapped gaps.

Definition at line 30 of file SigScanner.cpp.

References CountBytes(), and ReadFile().

Referenced by FindPatternEx().

◆ GameBuild()

std::string_view VoltMod::GameBuild ( )

steam.inf's ServerVersion, or "unknown"; read once per process.

Definition at line 10 of file GameBuild.cpp.

References ReadAllText(), ReadFile(), and VoltMod::Strings::Trim().

Referenced by VoltMod::GameDataScanner::LogSummary(), VoltMod::Schema::VerifySchemaLayout(), WriteGameDataRecord(), and VoltMod::Schema::WriteSchemaDump().

◆ GameDir()

static std::filesystem::path VoltMod::GameDir ( )

static

csgo/addons/voltmod/bin/<platform>/ holds this module, so csgo is four directories up.

Definition at line 46 of file Loader.cpp.

References OwnPath(), and ReadFile().

Referenced by LoadNextServer().

◆ GameRules()

static Schema::CCSGameRules VoltMod::GameRules ( EntitySystem & entities )

static

Definition at line 9 of file Rounds.cpp.

References VoltMod::Schema::CCSGameRulesProxy::GameRules(), and ReadFile().

Referenced by VoltMod::Rounds::End(), VoltMod::Rounds::SetTime(), and VoltMod::Rounds::TimeLeft().

◆ GameSearchPaths()

std::vector< std::string > VoltMod::GameSearchPaths ( std::string_view gameinfo )

The Game values under SearchPaths in a gameinfo.gi, in file order.

Other keys (Game_LowViolence, Mod...), comments, quotes and trailing conditions are dropped. The values are relative to the game directory.

Definition at line 36 of file GameSearchPaths.cpp.

References NextWord(), ReadFile(), and SameKey().

Referenced by LoadNextServer().

◆ HasSingleBase()

static bool VoltMod::HasSingleBase	(	uintptr_t	typeInfo,
		const TypeInfoKinds &	kinds
	)

static

Definition at line 150 of file VtableLookup.cpp.

References IsReadableAddress(), LooksLikeTypeInfo(), ReadFile(), ReadWord(), and TypeInfoBase.

Referenced by CollectBases().

◆ HistoryTableDdl()

static std::string VoltMod::HistoryTableDdl ( const std::string & table )

static

Definition at line 38 of file Migrator.cpp.

References ReadFile().

Referenced by RunMigrations().

◆ HookFunction()

template<class Object , class Ret , class... Args, class Before , class After = std::nullptr_t>

Result< Subscription > VoltMod::HookFunction	(	std::string_view	name,
		const Fn< Ret(Object *, Args...)> &	function,
		Before &&	before,
		After &&	after = `nullptr`
	)

Hook a signature-bound function at its entry.

Use this for functions without a vtable slot. The hook affects every caller of the matched code, including callers from other classes that share it.

Parameters

name	Names the hook in the log and in any error.
function	The binding; its first parameter is the object the function runs on.
before	Handler invoked before the engine call, or nullptr.
after	Handler invoked after the engine call, or nullptr.

Definition at line 200 of file Hook.hpp.

References VoltMod::Log::Info(), Installed(), ReadFile(), VoltMod::Internal::ToSubscription(), and VoltMod::Error::Unsupported().

◆ HookInterface()

template<class Iface , class Ret , class... Args, class Before , class After = std::nullptr_t>

Subscription VoltMod::HookInterface	(	Ret(Iface::*)(Args...)	method,
		Iface *	instance,
		Before &&	before,
		After &&	after = `nullptr`
	)

Hook one virtual method of an engine interface for a subscription's lifetime.

Only instance is hooked, even when other objects share its vtable. Pass nullptr for an unused handler. A before-handler that only observes returns nothing.

hooks.Add(VoltMod::HookInterface(&IServerGameDLL::GameFrame, gi.ServerGameDLL, nullptr,

[this](IServerGameDLL&, bool, bool, bool) { Tick(); }));

VoltMod::ReadFile

static std::string ReadFile(const std::filesystem::path &path)

Definition Loader.cpp:56

VoltMod::HookInterface

Subscription HookInterface(Ret(Iface::*method)(Args...), Iface *instance, Before &&before, After &&after=nullptr)

Hook one virtual method of an engine interface for a subscription's lifetime.

Definition Hook.hpp:142

Definition at line 142 of file Hook.hpp.

References Installed(), ReadFile(), and VoltMod::Internal::ToSubscription().

Referenced by VoltMod::EngineHooks::EngineHooks().

◆ HookSessionManifest()

static Result< Subscription > VoltMod::HookSessionManifest ( PluginRegistry & registry )

static

Hand every map's resource manifest to the plugins. The game rules system is in every session.

Definition at line 67 of file EngineHooks.cpp.

References FindVirtualTable(), HookVirtual(), and ReadFile().

Referenced by VoltMod::EngineHooks::EngineHooks().

◆ HookTeleport()

static Result< Subscription > VoltMod::HookTeleport	(	const Bindings &	bindings,
		EntitySystem &	entities,
		Event< int > &	before
	)

static

Definition at line 12 of file Teleport.cpp.

References HookVirtual(), IsValidSlot(), ReadFile(), and VoltMod::Pawn::Slot().

Referenced by VoltMod::Teleport::Teleport().

◆ HookVirtual()

template<class Object , class Ret , class... Args, class Before , class After = std::nullptr_t>

Result< Subscription > VoltMod::HookVirtual	(	std::string_view	name,
		const VirtualFn< Ret(Object *, Args...)> &	function,
		Before &&	before,
		After &&	after = `nullptr`
	)

Hook a gamedata-bound virtual function on objects sharing its class vtable.

The hook catches calls through that table only, even when its slot code is shared by other classes.

Parameters

name	Names the hook in the log and in any error.
function	Gamedata-resolved slot and class table. Its first parameter is the object.
before	Handler invoked before the engine call, or nullptr.
after	Handler invoked after the engine call, or nullptr.

Definition at line 168 of file Hook.hpp.

References VoltMod::Log::Info(), Installed(), ReadFile(), VoltMod::Internal::ToSubscription(), and VoltMod::Error::Unsupported().

Referenced by HookSessionManifest(), and HookTeleport().

◆ HudDestination()

static int VoltMod::HudDestination ( MessageKind kind )

static

Definition at line 44 of file Messages.cpp.

References Alert, Center, and ReadFile().

Referenced by VoltMod::Messages::Broadcast(), and VoltMod::Messages::Send().

◆ Insert()

template<class Conn , class Statement >

int64_t VoltMod::Insert	(	Conn &	conn,
		const Statement &	insert,
		std::string_view	table,
		std::string_view	key = `"id"`
	)

Insert one row and return its generated id. Postgres reads the <table>_<key>_seq sequence of a SERIAL column; the other drivers report it on the insert result.

Definition at line 39 of file Connection.hpp.

References ReadFile().

◆ Installed()

static InstalledScan VoltMod::Installed ( )

static

Definition at line 45 of file PluginLoader.cpp.

References VoltMod::InstalledPlugins::Discover(), and ResolvePath().

Referenced by HookFunction(), HookInterface(), HookVirtual(), and VoltMod::PluginLoader::LoadAll().

◆ IsExecutableAddress()

bool VoltMod::IsExecutableAddress ( const void * address )

Whether address lies in committed, executable memory.

This accepts hook trampolines allocated outside a module while rejecting vtable slots that point at data, such as RTTI, strings, or the tail of a shorter table.

Definition at line 174 of file SigScanner.cpp.

References QueryRegion(), and ReadFile().

Referenced by FindVirtualTableByTypeInfo(), and FindVirtualTableByTypeName().

◆ IsInstanceOf()

bool VoltMod::IsInstanceOf	(	const void *	object,
		const void *	table
	)

Definition at line 110 of file VtableLookup.cpp.

References IsReadableAddress(), ReadFile(), and ReadWord().

◆ IsModelEntity()

static bool VoltMod::IsModelEntity ( CEntityInstance * entity )

static

Definition at line 147 of file Entity.cpp.

References ReadFile().

Referenced by VoltMod::Entity::SetModel(), and VoltMod::Entity::SetRender().

◆ IsOpen()

bool VoltMod::IsOpen ( const AnyConnection & connection )

Definition at line 108 of file OpenConnection.cpp.

References ReadFile().

◆ IsPlaying()

constexpr bool VoltMod::IsPlaying ( Team team )

constexpr

True for the two teams that play a round.

Definition at line 18 of file Team.hpp.

References CT, ReadFile(), and T.

Referenced by VoltMod::Controller::ChangeTeam(), VoltMod::Visibility::HideFromTeam(), VoltMod::GlowVision::Refresh(), and VoltMod::Visibility::ShowOnlyToTeam().

◆ IsReadableAddress()

bool VoltMod::IsReadableAddress	(	const void *	address,
		size_t	bytes
	)

Whether the complete span [address, address + bytes) is readable in one mapping.

Use this before dereferencing untrusted object bytes. Calling IsExecutableAddress on p[0] is already too late because evaluating p[0] performs the unsafe read.

Definition at line 185 of file SigScanner.cpp.

References QueryRegion(), and ReadFile().

Referenced by BaseCount(), HasSingleBase(), IsInstanceOf(), LooksLikeTypeInfo(), NameIs(), and VirtualIndex().

◆ IsRowActionable()

bool VoltMod::IsRowActionable	(	const MenuItem &	item,
		int	slot
	)

inline

True when item is one a player may act on right now: it describes itself as both enabled and selectable. A cursor lands only on these, and only these activate.

Definition at line 128 of file MenuModel.hpp.

References VoltMod::MenuRow::Enabled, and ReadFile().

Referenced by VoltMod::MenuStack::Activate(), and CursorRowsFor().

◆ IsSelectable()

static bool VoltMod::IsSelectable	(	const CursorRows &	rows,
		int	index
	)

static

Definition at line 9 of file MenuCursor.cpp.

References ReadFile().

Referenced by VoltMod::MenuCursor::First(), VoltMod::MenuCursor::JumpPage(), and VoltMod::MenuCursor::Step().

◆ IsValidSlot()

constexpr bool VoltMod::IsValidSlot ( int slot )

inlineconstexpr

True if slot is a valid player-slot index.

Definition at line 13 of file Slot.hpp.

References MaxPlayers, and ReadFile().

◆ IsValidTableName()

static bool VoltMod::IsValidTableName ( const std::string & name )

static

[A-Za-z_][A-Za-z0-9_]* - the table name is interpolated into SQL, so reject anything else.

Definition at line 25 of file Migrator.cpp.

References ReadFile().

Referenced by RunMigrations().

◆ KitDefaults()

static const StringMap< std::string > & VoltMod::KitDefaults ( )

static

English text for the keys the framework itself emits, and each language's own name for a language picker. Translations::Get returns the raw key on a miss, so without this every plugin had to hand-copy all of them into every language file or players saw the literal string cmd.noPermission. A plugin's own file still wins - these are the floor, not an override.

Definition at line 42 of file Translations.cpp.

References ReadFile().

◆ LastError()

std::string VoltMod::LastError ( )

static

Why the last OpenModule or FindExport failed.

Definition at line 43 of file SharedLibrary.cpp.

References ReadFile().

Referenced by LoadNextServer(), VoltMod::SharedLibrary::Open(), StartHost(), and VoltMod::SharedLibrary::Symbol().

◆ LengthPrefixedName()

std::string VoltMod::LengthPrefixedName ( std::string_view className )

Definition at line 72 of file VtableLookup.cpp.

References ReadFile().

Referenced by FindBaseOffsetByTypeInfo(), FindVirtualTableByTypeName(), and FindVirtualTableIn().

◆ LibraryPath()

static std::filesystem::path VoltMod::LibraryPath ( std::string_view name )

static

Definition at line 40 of file PluginLoader.cpp.

References LibrarySuffix, PluginFile(), and ResolvePath().

◆ ListenForCommands()

static Subscription VoltMod::ListenForCommands	(	IPluginEvents &	events,
		Movement &	movement
	)

static

Definition at line 20 of file Runtime.cpp.

References VoltMod::Internal::HostSubscription(), and ReadFile().

Referenced by VoltMod::Runtime::Runtime().

◆ ListenForPresses()

static Subscription VoltMod::ListenForPresses	(	IPluginEvents &	events,
		ScreenManager &	screens
	)

static

Definition at line 32 of file Runtime.cpp.

References VoltMod::Internal::HostSubscription(), and ReadFile().

◆ LoadConfig()

template<class TConfig >

TConfig VoltMod::LoadConfig	(	Runtime &	runtime,
		TConfig	config = `{}`,
		const LoadConfigOptions &	options = `{}`
	)

Load the plugin's settings, then its translations, and return config.

Meant for the App's Config member initializer, so every member below it is built with settings: ConfigManager Config = VoltMod::LoadConfig<ConfigManager>(Runtime);.

The required "Configuration" step reads the plugin's LoadConfigOptions::SettingsFile through TConfig::LoadSettings when available, otherwise Options::Load. A failure keeps the defaults, and the framework refuses the plugin before Load runs. Translation loading then applies plugin.locale and reads the plugin's translations directory when enabled.

Definition at line 35 of file LoadConfig.hpp.

◆ LoadNextServer()

static InterfaceFactory VoltMod::LoadNextServer ( )

static

The first server library on the Game paths: Metamod's loader where it is installed, else the game's.

Definition at line 63 of file Loader.cpp.

References g_gameDir, g_start, VoltMod::LoaderHandoff::GameDir, GameDir(), GameSearchPaths(), LastError(), PlatformDir, ReadFile(), and ServerFile.

Referenced by FindNextFactory().

◆ LooksLikeTypeInfo()

static bool VoltMod::LooksLikeTypeInfo ( uintptr_t address )

static

Definition at line 127 of file VtableLookup.cpp.

References IsReadableAddress(), ReadFile(), and ReadWord().

Referenced by BaseCount(), CollectBases(), FindBaseOffsetByTypeInfo(), and HasSingleBase().

◆ MakeConsoleHandler()

Log::Handler VoltMod::MakeConsoleHandler ( std::string prefix )

The default handler: tier0 ConColorMsg/Msg, one colour per level.

The returned handler owns a copy of prefix and reaches the engine, so it may only be invoked on the game thread - which is exactly the contract VoltMod::Log::Handler already states.

Definition at line 11 of file ConsoleLogger.cpp.

References Error, Info, ReadFile(), and Warn.

Referenced by VoltMod::Host::Start().

◆ MakeFilter()

static CTraceFilter VoltMod::MakeFilter ( const TraceOptions & options )

static

Definition at line 32 of file Trace.cpp.

References MaskOf(), and ReadFile().

Referenced by VoltMod::Trace::Box(), and VoltMod::Trace::Line().

◆ MariaDbSettings()

static sqlpp::mysql::connection_config VoltMod::MariaDbSettings ( const DatabaseConfig & config )

static

Definition at line 54 of file OpenConnection.cpp.

References ParseSslMode(), ReadFile(), and TlsModes.

Referenced by OpenConnection().

◆ MaskOf()

static uint64_t VoltMod::MaskOf ( TraceLayers layers )

static

Definition at line 18 of file Trace.cpp.

References ReadFile(), Sight, SightMask, Surfaces, and SurfacesMask.

Referenced by MakeFilter().

◆ Matches()

static bool VoltMod::Matches	(	const uint8_t *	at,
		const std::vector< PatternByte > &	pattern
	)

static

Whether pattern matches at at, which must have room for all of it.

Definition at line 68 of file BytePattern.cpp.

References ReadFile().

Referenced by FindFirst().

◆ MemberPtr()

template<typename T >

T * VoltMod::MemberPtr	(	void *	base,
		std::ptrdiff_t	offset
	)

noexcept

Pointer to the field of type T located offset bytes into base.

Definition at line 21 of file MemoryAccess.hpp.

References ReadFile(), and T.

◆ ModuleAt()

static HMODULE VoltMod::ModuleAt ( const void * address )

static

The loaded module whose image holds address, without taking a reference to it.

Definition at line 27 of file Loader.windows.cpp.

References ReadFile().

◆ Name()

template<class E >

constexpr std::string_view VoltMod::Name ( E value )

constexprnoexcept

Identifier of value, or an empty view when it is not a declared enumerator.

Definition at line 33 of file EnumNames.hpp.

◆ NameIs()

static bool VoltMod::NameIs	(	uintptr_t	address,
		std::string_view	wanted
	)

static

Definition at line 143 of file VtableLookup.cpp.

References IsReadableAddress(), ReadFile(), and ReadWord().

Referenced by CollectBases().

◆ NavPhysics()

static EngineNavPhysics * VoltMod::NavPhysics ( void *& table )

static

Definition at line 62 of file Trace.cpp.

References ReadFile().

Referenced by VoltMod::Trace::Box(), and VoltMod::Trace::Line().

◆ NextWord()

static std::string_view VoltMod::NextWord ( std::string_view & line )

static

Take the next bare or quoted word off the front of line.

Definition at line 19 of file GameSearchPaths.cpp.

References Blank, and ReadFile().

Referenced by GameSearchPaths().

◆ NoGameRules()

static Status VoltMod::NoGameRules ( )

static

Definition at line 15 of file Rounds.cpp.

References VoltMod::Error::NotReady().

Referenced by VoltMod::Rounds::End(), and VoltMod::Rounds::SetTime().

◆ NotSourceXml()

static Error VoltMod::NotSourceXml ( std::string_view layout )

static

Definition at line 10 of file LayoutPath.cpp.

References VoltMod::Error::Invalid(), and ReadFile().

Referenced by VoltMod::LayoutPath::Parse().

◆ ObserverTarget()

static CEntityInstance * VoltMod::ObserverTarget	(	EntitySystem &	entities,
		int	recipientSlot
	)

static

Definition at line 54 of file Visibility.cpp.

References VoltMod::Pawn::Controller(), VoltMod::Controller::InputPawn(), and ReadFile().

Referenced by VoltMod::Visibility::OnCheckTransmit().

◆ OnConnect()

static bool VoltMod::OnConnect	(	void *	config,
		InterfaceFactory	engineFactory
	)

static

Definition at line 153 of file Loader.cpp.

References VoltMod::LoaderHandoff::EngineFactory, g_connect, g_start, and ReadFile().

Referenced by Patch().

◆ OnDisconnect()

static void VoltMod::OnDisconnect ( void * config )

static

Definition at line 181 of file Loader.cpp.

References g_disconnect, ReadFile(), and StopHost().

Referenced by Patch().

◆ OnInit()

static InitReturnVal_t VoltMod::OnInit ( void * server )

static

Definition at line 159 of file Loader.cpp.

References g_init, and StartHost().

Referenced by Patch().

◆ OnShutdown()

static void VoltMod::OnShutdown ( void * server )

static

Definition at line 174 of file Loader.cpp.

References g_shutdown, and StopHost().

Referenced by Patch().

◆ OpenConnection()

void VoltMod::OpenConnection	(	AnyConnection &	connection,
		Driver	driver,
		const DatabaseConfig &	config
	)

Opens a driver connection into connection. Throws what the driver throws, whose text can hold the password.

Definition at line 124 of file OpenConnection.cpp.

References InMemory, MariaDb, MariaDbSettings(), Postgres, PostgresSettings(), ReadFile(), Sqlite, and SqliteSettings().

◆ OpenLibrary()

static void * VoltMod::OpenLibrary ( const std::filesystem::path & path )

static

Definition at line 49 of file SharedLibrary.cpp.

References ReadFile().

Referenced by VoltMod::SharedLibrary::Open().

◆ OpenModule()

void * VoltMod::OpenModule ( const std::filesystem::path & path )

Null on failure, with the reason in LastError.

Definition at line 8 of file Loader.linux.cpp.

References ReadFile().

Referenced by StartHost().

◆ operator|()

constexpr GameDataSection VoltMod::operator\|	(	GameDataSection	left,
		GameDataSection	right
	)

constexpr

Definition at line 18 of file GameDataLocation.hpp.

References ReadFile().

◆ Opposite()

constexpr Team VoltMod::Opposite ( Team team )

constexpr

The other playing team; Team::None for a team that does not play.

Definition at line 24 of file Team.hpp.

References CT, None, ReadFile(), and T.

Referenced by VoltMod::Pawn::GiveItem().

◆ OptionalsTrail()

template<class... A>

consteval bool VoltMod::OptionalsTrail ( )

Whether every optional argument in A trails the required ones.

Definition at line 239 of file Args.hpp.

References ReadFile().

◆ OriginalSlot()

static const void * VoltMod::OriginalSlot	(	void *	table,
		int	index,
		const OriginalSlotLookup &	originalOf
	)

static

Definition at line 64 of file GameDataScanner.cpp.

References ReadFile().

◆ OwnerSlot()

static int VoltMod::OwnerSlot ( void * movementServices )

static

The slot of the player whose pawn owns movementServices, or -1.

Definition at line 16 of file PlayerCommands.cpp.

References VoltMod::Schema::CBasePlayerPawn::ControllerRef(), IsValidSlot(), VoltMod::Schema::CPlayer_MovementServices::OwnerEntity(), and ReadFile().

◆ OwnPath()

std::filesystem::path VoltMod::OwnPath ( )

This module's own file.

Definition at line 24 of file Loader.linux.cpp.

References ReadFile().

Referenced by GameDir(), and StartHost().

◆ PageCount()

constexpr int VoltMod::PageCount	(	int	items,
		int	perPage
	)

constexpr

Returns the number of pages needed for items, with at least one page.

Definition at line 14 of file MenuModel.hpp.

References ReadFile().

Referenced by VoltMod::MenuCursor::JumpPage(), and RenderMenuHtml().

◆ Parse()

template<class E >

constexpr std::optional< E > VoltMod::Parse ( std::string_view name )

constexprnoexcept

The enumerator spelled name, or nullopt.

Case-insensitive: enumerators are PascalCase, but the text being parsed is almost always a lowercase config value ("observe", "grants"), and a case-sensitive match would send every such call back to a hand-written chain. Pair it with value_or to supply the fallback.

Definition at line 46 of file EnumNames.hpp.

◆ ParseAddonList()

std::vector< uint64_t > VoltMod::ParseAddonList ( std::string_view field )

Split a join message's comma-separated addons field, skipping malformed entries.

Definition at line 226 of file DownloadQueue.cpp.

References ParseUInt64(), ReadFile(), and SplitAddonList().

Referenced by AppendToAddonList(), and VoltMod::DownloadQueue::DecideJoinMessage().

◆ ParseDriver()

std::optional< Driver > VoltMod::ParseDriver ( std::string_view name )

inline

Parse a config driver value ("postgres", "mariadb", "sqlite"); nullopt for anything else.

Definition at line 21 of file Driver.hpp.

References ReadFile().

Referenced by CheckConfig().

◆ ParseDuration()

int VoltMod::ParseDuration ( std::string_view text )

Parse a human duration string into seconds. Accepts a bare integer (seconds) or an integer with a unit suffix: s seconds, m minutes, h hours, d days, w weeks (case-insensitive). The literals 0, perm, and permanent mean "permanent" (returns 0). Surrounding whitespace is ignored. This is the single canonical duration grammar; Time::ParseDuration delegates here. Returns -1 on parse failure or int overflow, 0 for permanent, otherwise seconds.

Definition at line 35 of file Strings.cpp.

References ReadFile().

Referenced by BindDuration(), BuildDurationMenu(), and VoltMod::Validation::ParseDurations().

◆ ParseInt64()

std::optional< int64_t > VoltMod::ParseInt64 ( std::string_view text )

text as an int64_t, or nullopt unless it is entirely digits (with an optional sign).

Definition at line 13 of file Strings.cpp.

References ReadFile().

Referenced by BindInt(), BindPlayerOrSteamId(), BindSteamId(), and ParseTargetToken().

◆ ParseMigrationVersion()

std::optional< int > VoltMod::ParseMigrationVersion ( std::string_view filename )

inline

Leading NNNN version of a migration filename, or nullopt when it has none.

Definition at line 40 of file Migrator.hpp.

References ReadFile().

Referenced by RunMigrations().

◆ ParsePattern()

std::vector< PatternByte > VoltMod::ParsePattern ( const std::string & pattern )

Parse a pattern like 48 8B ? ? 05 into bytes and wildcards.

Returns: the bytes, or empty when a token is neither a hex byte nor ?. That is reported here and leaves the caller dropping the signature, rather than searching for something the author did not write.

Definition at line 11 of file BytePattern.cpp.

References VoltMod::Log::Error(), and ReadFile().

Referenced by FindPatternEx().

◆ ParseSslMode()

static std::optional< PostgresSslMode > VoltMod::ParseSslMode ( std::string_view name )

static

Definition at line 35 of file OpenConnection.cpp.

References VoltMod::SslModeName::Name, ReadFile(), and SslModes.

Referenced by CheckConfig(), MariaDbSettings(), and PostgresSettings().

◆ ParseTargetToken()

TargetQuery VoltMod::ParseTargetToken ( std::string_view token )

Definition at line 11 of file Targeting.cpp.

References CT, VoltMod::SteamId::FromSteamId(), VoltMod::SteamId::FromSteamId3(), VoltMod::SteamId::IsValid(), ParseInt64(), ReadFile(), Spectator, VoltMod::Strings::StartsWith(), T, and VoltMod::Strings::ToLower().

Referenced by VoltMod::EngineArgBinder::Resolve().

◆ ParseUInt64()

std::optional< uint64_t > VoltMod::ParseUInt64 ( std::string_view text )

text as a uint64_t, or nullopt unless it is entirely digits. A leading - is rejected rather than wrapped, which is the whole reason this is not ParseInt64 with a cast.

Definition at line 24 of file Strings.cpp.

References ReadFile().

Referenced by BindU64(), ParseAddonList(), and RemoveFromAddonList().

◆ Patch()

static void VoltMod::Patch	(	const char *	name,
		void *	object
	)

static

Definition at line 189 of file Loader.cpp.

References FactoryAt(), g_connect, g_disconnect, g_init, g_shutdown, g_start, OnConnect(), OnDisconnect(), OnInit(), OnShutdown(), ReadFile(), VoltMod::LoaderHandoff::ServerFactory, and SwapSlot().

◆ Perform()

static HttpResult VoltMod::Perform	(	const HttpRequest &	request,
		const std::atomic_bool &	stopped
	)

static

Worker thread: touches nothing but the request.

Definition at line 32 of file HttpClient.cpp.

References Delete, Get, Patch, Post, Put, ReadFile(), and ToResult().

Referenced by VoltMod::HttpClient::Requests::Work().

◆ PlatformColumn()

template<class TEntry >

const auto & VoltMod::PlatformColumn ( const TEntry & entry )

Definition at line 80 of file GameDataDocument.hpp.

References ReadFile().

Referenced by ColumnValue().

◆ PlatformModuleName()

std::string VoltMod::PlatformModuleName ( std::string_view moduleName )

Definition at line 49 of file SigScanner.cpp.

References ReadFile().

Referenced by FindImage(), FindPatternEx(), FindVirtualTable(), and VoltMod::Schema::ServerScope().

◆ PluginDir()

std::string VoltMod::PluginDir ( std::string_view plugin )

"addons/voltmod/plugins/<plugin>". Pure string building, so safe at static init.

Definition at line 20 of file Paths.cpp.

References ReadFile().

Referenced by PluginFile().

◆ PluginFile()

std::string VoltMod::PluginFile	(	std::string_view	plugin,
		std::string_view	relative
	)

"addons/voltmod/plugins/<plugin>/<relative>".

Definition at line 25 of file Paths.cpp.

References PluginDir(), and ReadFile().

Referenced by LibraryPath(), VoltMod::ServerAssets::Mount(), and VoltMod::Runtime::PluginFile().

◆ PostgresSettings()

static sqlpp::postgresql::connection_config VoltMod::PostgresSettings ( const DatabaseConfig & config )

static

Definition at line 41 of file OpenConnection.cpp.

References ParseSslMode(), and ReadFile().

Referenced by OpenConnection().

◆ PostUserMessage()

bool VoltMod::PostUserMessage	(	Interfaces &	interfaces,
		INetworkMessageInternal *&	cached,
		std::string_view	partialName,
		IRecipientFilter &	filter,
		const std::function< bool(CNetMessage *)> &	fill
	)

Send one user message: resolve its type, allocate it, let fill populate it, post it to filter, and deallocate it.

The deallocate has to pair with the allocate on every exit path, including the one where the protobuf cast fails. Getting that wrong leaks a net message per send, which is why every sender goes through here instead of repeating the sequence.

Parameters

cached	the caller's cache of the resolved message type, filled on the first call. Message types are stable for the process, so this is resolved once per sender.
partialName	matched with FindNetworkMessagePartial, e.g. "TextMsg" or "VoteStart". Partial rather than exact because a registered message is named with its id appended (`"CUserMessageTextMsg [124]"`), so INetworkMessages::FindNetworkMessage matches nothing at all - there is no name a caller could pass it that would.
fill	returns false to abandon the send; the message is still deallocated.

Returns: whether the message was posted.

Definition at line 12 of file NetMessage.cpp.

References ReadFile().

Referenced by VoltMod::Messages::Shake().

◆ PrimaryLocator()

static std::pair< uint32_t, const uint8_t * > VoltMod::PrimaryLocator	(	const PeRtti &	rtti,
		std::string_view	className
	)

static

Definition at line 133 of file VtableLookup.windows.cpp.

References FindLocator(), FindTypeDescriptor(), and ReadFile().

Referenced by FindBaseInRtti(), and FindVirtualTableInRtti().

◆ ProtoField()

const ProtoFieldDescriptor * VoltMod::ProtoField	(	const ProtoMessage &	message,
		std::string_view	name
	)

Descriptor for name, or nullptr when the field is absent.

Definition at line 8 of file ProtoReflect.cpp.

References ReadFile().

Referenced by VoteField().

◆ QueryRegion()

static std::optional< MemoryRegion > VoltMod::QueryRegion ( const void * address )

static

Definition at line 134 of file SigScanner.cpp.

References VoltMod::MemoryRegion::End, and ReadFile().

Referenced by IsExecutableAddress(), and IsReadableAddress().

◆ RaiseCommand()

static void VoltMod::RaiseCommand	(	CallbackList< IPluginEvents::PlayerCommandFn > &	listeners,
		int	slot,
		const PlayerInput &	input
	)

static

Definition at line 11 of file PluginRegistry.cpp.

References ReadFile().

Referenced by VoltMod::PluginRegistry::RaisePlayerCommand(), and VoltMod::PluginRegistry::RaisePlayerCommandDone().

◆ RandomIndex()

std::size_t VoltMod::RandomIndex ( std::size_t count )

A uniformly random index in [0, count), or 0 when count is 0.

The framework's single source of randomness, so features that need a random pick (@random targeting, a random menu entry) do not each seed their own generator - or fall back to something like the tick counter, which repeats within a frame.

Game-thread only; the generator is not synchronised.

Definition at line 7 of file Random.cpp.

References ReadFile().

Referenced by VoltMod::EngineArgBinder::Resolve().

◆ RangesOf()

static bool VoltMod::RangesOf	(	const Image &	module,
		std::vector< ScanRange > &	ranges
	)

static

Definition at line 122 of file VtableLookup.linux.cpp.

References FindModuleAndRanges(), and ReadFile().

Referenced by FindBaseIn(), and FindVirtualTableIn().

◆ ReadAllText()

Result< std::string > VoltMod::ReadAllText ( std::string_view path )

Read path (resolved via ResolvePath) into a string.

Binary mode: the bytes reach the caller exactly as written, so no text-mode line-ending translation can alter an offset or split a UTF-8 sequence.

Returns: ErrorCode::NotFound when the file cannot be opened.

Definition at line 12 of file File.cpp.

References VoltMod::Error::NotFound(), ReadFile(), and ResolvePath().

Referenced by VoltMod::ConVars::ExecuteFile(), GameBuild(), VoltMod::Translations::Load(), VoltMod::Json::ReadFile(), and RunMigrations().

◆ ReadAt() [1/2]

template<typename T >

static T VoltMod::ReadAt ( const uint8_t * address )

static

Definition at line 50 of file VtableLookup.windows.cpp.

References ReadFile(), and T.

◆ ReadAt() [2/2]

template<typename T >

T VoltMod::ReadAt	(	void *	base,
		std::ptrdiff_t	offset
	)

noexcept

Read the value of type T located offset bytes into base.

Definition at line 28 of file MemoryAccess.hpp.

References ReadFile().

◆ ReadFile()

static std::string VoltMod::ReadFile ( const std::filesystem::path & path )

static

Definition at line 56 of file Loader.cpp.

References ReadFile().

◆ ReadOriginalSlot()

const void * VoltMod::ReadOriginalSlot	(	void **	vtable,
		int	index
	)

inline

What vtable's index held before a hook patched it, or nullptr.

Definition at line 21 of file Detours.hpp.

References KHook::__exported__khook, and ReadFile().

Referenced by VoltMod::Host::Start().

◆ ReadU32()

static uint32_t VoltMod::ReadU32 ( uintptr_t address )

static

Definition at line 47 of file VtableLookup.cpp.

References ReadFile().

Referenced by BaseCount().

◆ ReadVarint()

static Result< uint64_t > VoltMod::ReadVarint	(	std::string_view	bytes,
		size_t &	at
	)

static

Definition at line 19 of file ButtonPressMessage.cpp.

References VoltMod::Error::Invalid(), MaxVarintBytes, and ReadFile().

Referenced by VoltMod::ButtonPressMessage::Parse(), and SkipField().

◆ ReadWord()

static uintptr_t VoltMod::ReadWord ( uintptr_t address )

static

Definition at line 40 of file VtableLookup.cpp.

References ReadFile().

Referenced by BaseCount(), CollectBases(), FindVirtualTableByTypeInfo(), FindVirtualTableByTypeName(), FindWords(), HasSingleBase(), IsInstanceOf(), LooksLikeTypeInfo(), and NameIs().

◆ RefOf()

static EntityRef VoltMod::RefOf ( const CEntityInstance * entity )

static

Definition at line 41 of file Trace.cpp.

References ReadFile().

Referenced by ToHit().

◆ RefuseUnsatisfied()

static void VoltMod::RefuseUnsatisfied	(	const PluginsByName &	plugins,
		RefusalsByName &	refused
	)

static

Definition at line 19 of file PluginDependencies.cpp.

References VoltMod::Error::NotFound(), VoltMod::Error::NotReady(), and ReadFile().

Referenced by VoltMod::PluginDependencies::Resolve().

◆ Rel32ReadInBounds()

constexpr bool VoltMod::Rel32ReadInBounds	(	uintptr_t	moduleBase,
		size_t	moduleSize,
		uintptr_t	matchAddress,
		int	ripOffset
	)

constexprnoexcept

Whether the four-byte displacement at matchAddress + ripOffset fits entirely within the mapped image. Invalid and overflowing offsets return false before any read occurs.

Definition at line 37 of file RelativeAddress.hpp.

References ReadFile(), Rel32Site(), and Rel32Size.

Referenced by ResolveRelativeAddress().

◆ Rel32Site()

constexpr uintptr_t VoltMod::Rel32Site	(	uintptr_t	matchAddress,
		int	ripOffset
	)

constexprnoexcept

Definition at line 19 of file RelativeAddress.hpp.

References ReadFile().

Referenced by Rel32ReadInBounds(), and ResolveRelativeAddress().

◆ Rel32Target()

constexpr uintptr_t VoltMod::Rel32Target	(	uintptr_t	site,
		int32_t	displacement,
		int	ripSize = `Rel32Size`
	)

constexprnoexcept

Resolve displacement from site. ripSize is the distance from the site to the end of the instruction and defaults to the four-byte displacement width.

Definition at line 28 of file RelativeAddress.hpp.

References ReadFile().

Referenced by ResolveRelativeAddress().

◆ RemoveFromAddonList()

void VoltMod::RemoveFromAddonList	(	std::string &	field,
		const std::vector< uint64_t > &	ids
	)

Remove one entry per id in ids, keeping the other entries verbatim.

Definition at line 262 of file DownloadQueue.cpp.

References ParseUInt64(), ReadFile(), and SplitAddonList().

◆ Render()

static std::string VoltMod::Render	(	std::string_view	message,
		MessageKind	kind
	)

static

Definition at line 39 of file Messages.cpp.

References Chat, EnsureColorPrefix(), and ReadFile().

Referenced by VoltMod::Messages::Broadcast(), and VoltMod::Messages::Send().

◆ RenderCaptureOverlay()

std::string VoltMod::RenderCaptureOverlay	(	const std::string &	menuTitle,
		std::string_view	prompt
	)

Renders the chat-input capture overlay shown while a player is typing a value.

Definition at line 230 of file CenterHtmlRender.cpp.

References VoltMod::Strings::EscapeHtml(), VoltMod::Theme::Gold, VoltMod::Theme::NavClose, ReadFile(), VoltMod::Theme::WarmGray, and VoltMod::Theme::WarmWhite.

◆ RenderFooter()

std::string VoltMod::RenderFooter	(	bool	isSubmenu,
		bool	isPaginated,
		bool	selectedRowSteps,
		int	slot,
		Translations &	translations
	)

The footer HTML for a menu: the key hints.

Parameters

isSubmenu	True if this menu is a submenu (shows "Back" hint), false if it's a root menu (shows "Close" hint).
isPaginated	True if the menu has multiple pages of items (shows page navigation hints)
selectedRowSteps	True when A/D steps the selected row's value rather than paging (shows "Change"/"Confirm" hints).
slot	Player slot used to look up the nav-label translations.
translations	Table the nav labels are looked up in.

Returns: The generated HTML string for the menu footer.

Definition at line 64 of file CenterHtmlRender.cpp.

References FooterChunk(), VoltMod::Theme::Gold, VoltMod::Theme::NavBack, VoltMod::Theme::NavClose, VoltMod::Theme::NavGold, and ReadFile().

Referenced by RenderMenuHtml().

◆ RenderHeader()

std::string VoltMod::RenderHeader ( const CenterHtmlHeader & header )

The header HTML for a menu. Empty parts of header add nothing.

Definition at line 26 of file CenterHtmlRender.cpp.

References VoltMod::Strings::EscapeHtml(), VoltMod::Theme::Gold, ReadFile(), and VoltMod::Theme::WarmGray.

Referenced by RenderMenuHtml().

◆ RenderItems()

static std::string VoltMod::RenderItems	(	const CenterHtmlView &	view,
		int	pageStart,
		int	pageEnd,
		MenuRow &	selected
	)

static

Definition at line 151 of file CenterHtmlRender.cpp.

References VoltMod::Theme::Amber, VoltMod::Theme::Disabled, ReadFile(), RowText(), VoltMod::Theme::WarmGray, and VoltMod::Theme::WarmWhite.

Referenced by RenderMenuHtml().

◆ RenderMenuHtml()

std::string VoltMod::RenderMenuHtml	(	const Menu *	menu,
		const CenterHtmlView &	view,
		Translations &	translations
	)

Renders the HTML for a menu, including its items and layout. translations localizes the default footer's nav labels and the empty-menu line, each looked up only where it is drawn.

Definition at line 190 of file CenterHtmlRender.cpp.

References CenterHtmlRowsPerPage, VoltMod::MenuRow::Enabled, VoltMod::Strings::EscapeHtml(), PageCount(), ReadFile(), RenderFooter(), RenderHeader(), RenderItems(), and VoltMod::Theme::WarmGray.

◆ ReplaceAll()

static std::string VoltMod::ReplaceAll	(	const std::string &	str,
		const std::string &	from,
		const std::string &	to
	)

static

Definition at line 159 of file Strings.cpp.

References ReadFile().

Referenced by VoltMod::Strings::SubstituteTokens().

◆ ResolveDialect()

Result< std::string > VoltMod::ResolveDialect	(	std::string_view	sql,
		Driver	driver
	)

inline

Substitute every dialect placeholder in sql for driver.

A placeholder is @NAME@ or @NAME(args)@ with NAME in [A-Z_], the same rule the CLI's renderer uses; any other @, such as one in an address literal, is ordinary text. An unknown placeholder fails rather than leaving a hole in a statement.

Definition at line 95 of file Migrator.hpp.

References DialectFor(), VoltMod::Error::Invalid(), and ReadFile().

Referenced by RunMigrations().

◆ ResolveEngineInterfaces()

Result< EngineInterfaces > VoltMod::ResolveEngineInterfaces ( const LoaderHandoff & start )

Fails when an interface the engine hooks need is missing; the optional ones are logged.

Definition at line 37 of file EngineInterfaces.cpp.

References Find(), FindOptional(), and ReadFile().

Referenced by VoltMod::Host::Start().

◆ ResolvePath()

std::filesystem::path VoltMod::ResolvePath ( std::string_view relativePath )

a relative path against the base directory. If the path is already absolute, returns it as-is.

Parameters

relativePath The relative path to resolve.

Returns: The resolved absolute path.

Definition at line 14 of file Paths.cpp.

References g_baseDir, and ReadFile().

Referenced by Installed(), LibraryPath(), VoltMod::Translations::Load(), VoltMod::ServerAssets::Mount(), ReadAllText(), RunMigrations(), SqliteSettings(), WriteAllText(), and VoltMod::Schema::WriteSchemaDump().

◆ ResolveRelativeAddress()

uintptr_t VoltMod::ResolveRelativeAddress	(	const Image &	module,
		uintptr_t	matchAddress,
		int	ripOffset,
		int	ripSize = `Rel32Size`
	)

Resolve the 32-bit displacement at matchAddress + ripOffset relative to the instruction end.

Returns: 0 when the displacement is not wholly inside the module.

Definition at line 108 of file SigScanner.cpp.

References ReadFile(), Rel32ReadInBounds(), Rel32Site(), and Rel32Target().

◆ RestIsLast()

template<class... A>

consteval bool VoltMod::RestIsLast ( )

Whether at most one Args::Rest appears in A, as the final argument. A Rest eats the remainder of the line, so anything after it could never be reached.

Definition at line 260 of file Args.hpp.

References ReadFile(), and Rest.

◆ RowText()

static std::string VoltMod::RowText ( const MenuRow & row )

static

Definition at line 116 of file CenterHtmlRender.cpp.

References Choice, VoltMod::Strings::EscapeHtml(), ReadFile(), and Toggle.

Referenced by RenderItems().

◆ RttiOf()

static PeRtti VoltMod::RttiOf ( const Image & module )

static

Definition at line 246 of file VtableLookup.windows.cpp.

References FindBaseIn(), FindBaseInRtti(), FindVirtualTableIn(), FindVirtualTableInRtti(), VoltMod::Error::NotFound(), ReadFile(), and RttiOf().

Referenced by RttiOf().

◆ RunCommand()

static HookResult< void > VoltMod::RunCommand	(	PluginRegistry &	registry,
		std::string_view	name,
		const CCommand &	arguments,
		int	slot
	)

static

Offer a command to the plugins, and keep it from the engine when one consumes it.

Definition at line 36 of file EngineHooks.cpp.

References VoltMod::HookResult< Ret >::Block(), ReadFile(), and Text.

Referenced by VoltMod::EngineHooks::EngineHooks().

◆ RunMigrations()

MigrationResult VoltMod::RunMigrations	(	Database &	db,
		std::string_view	dir,
		const MigrationOptions &	options = `{}`
	)

Apply the NNNN_*.sql files in dir newer than the database's version, in order, each in its own transaction under a lock. ResolveDialect fills their placeholders for the live driver. A missing directory is a no-op; on failure the database stays at the last applied version.

Definition at line 57 of file Migrator.cpp.

References ApplyMigration(), VoltMod::Log::Error(), HistoryTableDdl(), VoltMod::Log::Info(), IsValidTableName(), ParseMigrationVersion(), ReadAllText(), ReadFile(), ResolveDialect(), ResolvePath(), SplitStatements(), VoltMod::MigrationResult::Success, and VoltMod::Log::Warn().

◆ Rva()

static uint64_t VoltMod::Rva	(	const Image &	module,
		const void *	address
	)

static

Definition at line 20 of file GameDataScanner.cpp.

References ReadFile().

◆ SameFileName()

static bool VoltMod::SameFileName	(	std::string_view	left,
		std::string_view	right
	)

static

Definition at line 22 of file Image.windows.cpp.

References ReadFile().

◆ SameKey()

static bool VoltMod::SameKey	(	std::string_view	left,
		std::string_view	right
	)

static

Definition at line 11 of file GameSearchPaths.cpp.

References ReadFile().

Referenced by GameSearchPaths().

◆ Scan()

static Result< ScanResult > VoltMod::Scan	(	std::string_view	moduleName,
		const std::string &	pattern
	)

static

Definition at line 25 of file GameDataScanner.cpp.

References FindPatternEx(), ReadFile(), and Unbound().

◆ SceneNode()

static Schema::CGameSceneNode VoltMod::SceneNode ( const Entity & entity )

static

Definition at line 72 of file Entity.cpp.

References ReadFile().

Referenced by VoltMod::Entity::Angles(), and VoltMod::Entity::Origin().

◆ SetBaseDir()

void VoltMod::SetBaseDir ( const std::filesystem::path & baseDir )

Set the base directory for path resolution (the host's csgo directory). Must be called during initialization before any file loading.

Parameters

baseDir The base directory path to use for resolving relative paths.

Definition at line 9 of file Paths.cpp.

References g_baseDir, and ReadFile().

Referenced by VoltMod::Host::Start().

◆ SetBool()

static void VoltMod::SetBool	(	ProtoMessage *	message,
		std::string_view	name,
		bool	value
	)

static

Definition at line 68 of file Vote.cpp.

References ReadFile(), and VoteField().

◆ SetInt()

static void VoltMod::SetInt	(	ProtoMessage *	message,
		std::string_view	name,
		int32_t	value
	)

static

Definition at line 60 of file Vote.cpp.

References ReadFile(), and VoteField().

◆ SetStr()

static void VoltMod::SetStr	(	CUtlString &	out,
		std::string_view	text
	)

static

Assigned in place: CUtlString allocates inside tier0, the allocator the engine frees with.

Definition at line 27 of file ScreenEntity.cpp.

References ReadFile().

◆ SetString()

static void VoltMod::SetString	(	ProtoMessage *	message,
		std::string_view	name,
		const std::string &	value
	)

static

Definition at line 76 of file Vote.cpp.

References ReadFile(), and VoteField().

◆ SetWeapon()

static void VoltMod::SetWeapon	(	IGameEvent &	event,
		std::string_view	weapon
	)

static

Definition at line 31 of file Damage.cpp.

References ReadFile().

◆ SkipField()

static Status VoltMod::SkipField	(	std::string_view	bytes,
		size_t &	at,
		uint32_t	wireType
	)

static

Definition at line 39 of file ButtonPressMessage.cpp.

References VoltMod::Error::Invalid(), ReadFile(), ReadVarint(), WireFixed32, WireFixed64, WireLengthDelimited, and WireVarint.

Referenced by VoltMod::ButtonPressMessage::Parse().

◆ SplitAddonList()

static std::vector< std::string_view > VoltMod::SplitAddonList ( std::string_view field )

static

The comma-separated entries of field, verbatim; none for an empty field.

Definition at line 203 of file DownloadQueue.cpp.

References ReadFile().

Referenced by ParseAddonList(), and RemoveFromAddonList().

◆ SplitStatements()

std::vector< std::string > VoltMod::SplitStatements ( std::string_view sql )

inline

Split a migration file into single statements: -- line comments are stripped, a ; outside a single-quoted literal ends a statement, and blank statements are dropped. One statement per ; - procedure bodies are not supported, because MariaDB and SQLite run raw SQL one statement at a time.

Definition at line 168 of file Migrator.hpp.

References ReadFile().

Referenced by RunMigrations().

◆ SqliteSettings()

static sqlpp::sqlite3::connection_config VoltMod::SqliteSettings ( const DatabaseConfig & config )

static

Definition at line 70 of file OpenConnection.cpp.

References InMemory, ReadFile(), and ResolvePath().

Referenced by OpenConnection().

◆ StartHost()

static void VoltMod::StartHost ( )

static

Definition at line 119 of file Loader.cpp.

References VoltMod::LoaderHandoff::EngineFactory, FindExport(), g_start, g_stopHost, HostFile, HostStartName, HostStopName, LastError(), OpenModule(), OwnPath(), ReadFile(), and VoltMod::LoaderHandoff::ServerFactory.

Referenced by OnInit().

◆ StopHost()

static void VoltMod::StopHost ( )

static

Definition at line 166 of file Loader.cpp.

References g_stopHost.

Referenced by OnDisconnect(), and OnShutdown().

◆ Store()

template<class T >

static std::optional< ArgError > VoltMod::Store	(	std::expected< T, ArgError >	parsed,
		std::vector< BoundArg > &	bound
	)

static

Store parsed, or return its error. Each binder above returns its own argument type.

Definition at line 123 of file ArgBinding.cpp.

References ReadFile().

Referenced by BindArgs().

◆ SwapSlot()

template<class Fn >

static Fn VoltMod::SwapSlot	(	void *	object,
		int	index,
		Fn	replacement
	)

static

Definition at line 35 of file Loader.cpp.

References ReadFile().

Referenced by Patch().

◆ TableAfter()

static void * VoltMod::TableAfter	(	const PeRtti &	rtti,
		const uint8_t *	locator
	)

static

Definition at line 126 of file VtableLookup.windows.cpp.

References End(), FindValue(), and ReadFile().

Referenced by FindBaseInRtti(), and FindVirtualTableInRtti().

◆ TargetKey()

static ArgError VoltMod::TargetKey	(	const TargetFailure &	failure,
		const std::string &	token
	)

static

The reply key and tokens for a target that did not resolve.

Definition at line 10 of file ArgBinding.cpp.

References Ambiguous, BotNotAllowed, DeadNotAllowed, Immune, VoltMod::ArgError::Key, MultiNotAllowed, NoMatch, and ReadFile().

Referenced by BindPlayerOrSteamId(), BindTarget(), and BindTargets().

◆ Text()

static std::string_view VoltMod::Text ( const char * text )

static

The engine passes null for an absent string.

Definition at line 30 of file EngineHooks.cpp.

References ReadFile().

◆ TimerOn()

static PendingCommit::Timer VoltMod::TimerOn ( Scheduler & scheduler )

static

Definition at line 12 of file MenuStack.cpp.

References ReadFile().

◆ ToHit()

static TraceHit VoltMod::ToHit ( const CGameTrace & trace )

static

Definition at line 50 of file Trace.cpp.

References VoltMod::TraceHit::Hit, ReadFile(), and RefOf().

Referenced by VoltMod::Trace::Box(), and VoltMod::Trace::Line().

◆ TokenizeOneCommand()

static bool VoltMod::TokenizeOneCommand	(	std::string_view	command,
		CCommand &	args
	)

static

Tokenizes command into args when it is exactly one non-empty command.

Definition at line 69 of file Controller.cpp.

References ReadFile().

Referenced by VoltMod::Controller::ExecuteCommand().

◆ ToResult()

static HttpResult VoltMod::ToResult ( cpr::Response && response )

static

Definition at line 22 of file HttpClient.cpp.

References VoltMod::HttpResult::Error, and ReadFile().

Referenced by Perform().

◆ TypeDescriptorMatches()

static bool VoltMod::TypeDescriptorMatches	(	const PeRtti &	rtti,
		int32_t	rva,
		std::span< const std::string >	names
	)

static

Definition at line 90 of file VtableLookup.windows.cpp.

References AtRva(), ReadFile(), and TypeDescriptorName.

Referenced by FindBaseInRtti().

◆ Unbound() [1/2]

static std::unexpected< Error > VoltMod::Unbound ( std::string reason )

static

Definition at line 15 of file GameDataScanner.cpp.

References VoltMod::Error::NotFound(), and ReadFile().

Referenced by ColumnValue(), VoltMod::ModuleSymbols::Module(), Scan(), and VoltMod::ModuleSymbols::Table().

◆ Unbound() [2/2]

static std::unexpected< Error > VoltMod::Unbound ( std::string reason )

static

Definition at line 10 of file ModuleSymbols.cpp.

References VoltMod::Error::NotFound(), and ReadFile().

◆ Upsert()

template<class Conn , class Update , class Statement >

void VoltMod::Upsert	(	Conn &	conn,
		const Update &	update,
		const Statement &	insert
	)

Update by a natural key, inserting only when nothing matched: the portable upsert, since the three drivers disagree on ON CONFLICT / ON DUPLICATE KEY.

Not atomic, so the key needs a UNIQUE constraint to turn a race between two servers into one failed job rather than a duplicate row. Relies on Database setting CLIENT_FOUND_ROWS, which makes MariaDB count matched rows instead of changed ones.

Definition at line 61 of file Connection.hpp.

References ReadFile().

◆ UsagePlaceholderKey()

static std::string VoltMod::UsagePlaceholderKey ( ArgKind kind )

static

Translation key for an argument kind's usage placeholder.

Definition at line 30 of file CommandRouter.cpp.

References Name, and ReadFile().

◆ ValidateDescriptor()

Status VoltMod::ValidateDescriptor	(	const PluginDescriptor *	descriptor,
		std::string_view	hostVersion
	)

Whether descriptor is one a host of hostVersion can load, with the reason it is not.

Definition at line 123 of file InstalledPlugins.cpp.

References VoltMod::Error::Invalid(), PluginEntryName, and ReadFile().

◆ VirtualIndex()

static int VoltMod::VirtualIndex ( const void * function )

static

The vtable index function dispatches through, or -1 when it is not virtual.

Definition at line 44 of file ScriptBindings.cpp.

References IsReadableAddress(), and ReadFile().

Referenced by FindScriptBinding().

◆ VoteField()

static const ProtoFieldDescriptor * VoltMod::VoteField	(	ProtoMessage *	message,
		std::string_view	name
	)

static

ProtoField plus what a missing field costs here; see Engine/ProtoReflect.hpp for why the fields are reached by name at all.

Definition at line 48 of file Vote.cpp.

References ProtoField(), ReadFile(), and VoltMod::Log::Warn().

Referenced by SetBool(), SetInt(), and SetString().

◆ WarnLeaks()

static void VoltMod::WarnLeaks	(	std::string_view	name,
		const LeakReport &	leaks
	)

static

Definition at line 24 of file PluginLoader.cpp.

References ReadFile(), and VoltMod::Log::Warn().

◆ WhenEnabled()

static std::function< void(int, MenuSurface &)> VoltMod::WhenEnabled	(	EnabledCondition	enabled,
		std::function< void(int, MenuSurface &)>	action
	)

static

action, run only while enabled takes the slot.

Definition at line 29 of file MenuBuilder.cpp.

References ReadFile().

Referenced by VoltMod::Internal::ChoiceItem(), VoltMod::ButtonRow::ToItem(), VoltMod::ToggleRow::ToItem(), VoltMod::InputRow::ToItem(), and VoltMod::SubmenuRow::ToItem().

◆ WrapIndex()

constexpr int VoltMod::WrapIndex	(	int	value,
		int	count
	)

constexpr

Wraps value into [0, count), including when value is negative.

Definition at line 20 of file MenuModel.hpp.

References ReadFile().

Referenced by VoltMod::MenuCursor::JumpPage(), VoltMod::MenuCursor::Step(), and VoltMod::ChoiceState::Step().

◆ WriteAllText()

Status VoltMod::WriteAllText	(	std::string_view	path,
		std::string_view	text
	)

Write text to path (resolved via ResolvePath), creating its directory.

Binary mode, so the file is byte-identical on every platform.

Definition at line 24 of file File.cpp.

References VoltMod::Error::Invalid(), ReadFile(), and ResolvePath().

Referenced by VoltMod::Schema::WriteDumpFile(), and WriteGameDataRecord().

◆ WriteAt()

template<typename T >

void VoltMod::WriteAt	(	void *	base,
		std::ptrdiff_t	offset,
		const T &	value
	)

noexcept

Write value to the field of type T located offset bytes into base.

Definition at line 35 of file MemoryAccess.hpp.

References ReadFile().

◆ WriteGameDataRecord()

void VoltMod::WriteGameDataRecord ( const GameDataRecord & resolved )

Write resolved to addons/voltmod/gamedata/dumps/resolved.json once per build; failures only log.

Definition at line 37 of file GameDataRecord.cpp.

References VoltMod::GameDataRecord::Build, GameBuild(), VoltMod::Log::Info(), ReadFile(), VoltMod::Json::ReadFile(), VoltMod::Log::Warn(), WriteAllText(), and VoltMod::Json::WritePretty().

Referenced by VoltMod::GameDataTable::GameDataTable().

Variable Documentation

◆ AllTeams

constexpr int VoltMod::AllTeams = -1

staticconstexpr

Definition at line 30 of file Vote.cpp.

Referenced by VoltMod::Vote::Start().

◆ BaseEntrySize

constexpr size_t VoltMod::BaseEntrySize = 2 * sizeof(void*)

staticconstexpr

Definition at line 121 of file VtableLookup.cpp.

Referenced by BaseCount(), and CollectBases().

◆ BaseMemberOffset

constexpr size_t VoltMod::BaseMemberOffset = 0x08

staticconstexpr

Definition at line 27 of file VtableLookup.windows.cpp.

Referenced by FindBaseInRtti().

◆ BaseSize

constexpr size_t VoltMod::BaseSize = 0x18

staticconstexpr

Definition at line 29 of file VtableLookup.windows.cpp.

Referenced by FindBaseInRtti().

◆ BaseVirtualOffset

constexpr size_t VoltMod::BaseVirtualOffset = 0x0C

staticconstexpr

Definition at line 28 of file VtableLookup.windows.cpp.

Referenced by FindBaseInRtti().

◆ Blank

constexpr std::string_view VoltMod::Blank = " \t\r"

staticconstexpr

Definition at line 9 of file GameSearchPaths.cpp.

Referenced by NextWord().

◆ CenterHtmlRowsPerPage

constexpr int VoltMod::CenterHtmlRowsPerPage = 5

inlineconstexpr

Rows one center-HTML page holds. A renderer limit, not a menu-model limit.

Definition at line 13 of file CenterHtmlRender.hpp.

Referenced by RenderMenuHtml().

◆ ClassAbsent

constexpr int32_t VoltMod::ClassAbsent = 0

staticconstexpr

EHudPanelClassStatus_t values.

Definition at line 19 of file ScreenEntity.cpp.

◆ ClassPresent

constexpr int32_t VoltMod::ClassPresent = 1

staticconstexpr

Definition at line 20 of file ScreenEntity.cpp.

◆ CommandUsage

constexpr std::string_view VoltMod::CommandUsage

staticconstexpr

Initial value:

=
    "volt version | list | status [name] | load <name> | unload <name> | reload <name> | "
    "log <name> <info|warn|error>"

Definition at line 15 of file VoltCommand.cpp.

◆ ControllerClass [1/2]

constexpr std::string_view VoltMod::ControllerClass = "cs_player_controller"

staticconstexpr

Definition at line 30 of file EntitySystem.cpp.

◆ ControllerClass [2/2]

constexpr std::string_view VoltMod::ControllerClass = "vote_controller"

staticconstexpr

Definition at line 24 of file Vote.cpp.

◆ CustomHudClickType

constexpr int32_t VoltMod::CustomHudClickType = 390

staticconstexpr

Definition at line 23 of file ButtonPresses.cpp.

◆ DownloadTimeoutSeconds

constexpr double VoltMod::DownloadTimeoutSeconds = 30.0

staticconstexpr

How soon a client must reconnect for its addon to count as downloaded.

Definition at line 25 of file WorkshopDownloads.cpp.

Referenced by VoltMod::WorkshopDownloads::OnClientConnected().

◆ EntitySystemOffset

constexpr std::string_view VoltMod::EntitySystemOffset = "GameEntitySystem"

staticconstexpr

Definition at line 163 of file SchemaCheck.cpp.

Referenced by VoltMod::SchemaCheck::SchemaCheck().

◆ EnumCount

template<class E >

constexpr std::size_t VoltMod::EnumCount = magic_enum::enum_count<E>()

inlineconstexpr

How many enumerators E declares.

Definition at line 53 of file EnumNames.hpp.

◆ EveryoneSlot

constexpr int VoltMod::EveryoneSlot = -1

inlineconstexpr

The slot value meaning everyone: a layout's global state rather than one player's.

Definition at line 10 of file Slot.hpp.

Referenced by VoltMod::ScreenEntity::EnsureSpawned(), and VoltMod::ScreenManager::Shared().

◆ ForgetAfterSeconds

constexpr double VoltMod::ForgetAfterSeconds = 12.0 * 60.0 * 60.0

staticconstexpr

A player back within this long is not asked to download again.

Definition at line 29 of file WorkshopDownloads.cpp.

Referenced by VoltMod::WorkshopDownloads::OnClientDisconnected().

◆ g_baseDir

std::filesystem::path VoltMod::g_baseDir

static

Definition at line 7 of file Paths.cpp.

Referenced by ResolvePath(), and SetBaseDir().

◆ g_connect

bool(* VoltMod::g_connect) (void *config, InterfaceFactory engineFactory)	(	void *	config,
		InterfaceFactory	engineFactory
	)		= nullptr

static

Definition at line 29 of file Loader.cpp.

Referenced by OnConnect(), and Patch().

◆ g_disconnect

void(* VoltMod::g_disconnect) (void *config) ( void * config ) = nullptr

static

Definition at line 30 of file Loader.cpp.

Referenced by OnDisconnect(), and Patch().

◆ g_dispatcher

KHookForwarder VoltMod::g_dispatcher

static

Definition at line 23 of file Loader.cpp.

◆ g_gameDir

std::string VoltMod::g_gameDir

static

Definition at line 24 of file Loader.cpp.

Referenced by LoadNextServer().

◆ g_host

Host VoltMod::g_host

static

Definition at line 132 of file Host.cpp.

Referenced by VoltMod_HostStart(), and VoltMod_HostStop().

◆ g_init

InitReturnVal_t(* VoltMod::g_init) (void *server) ( void * server ) = nullptr

static

Definition at line 31 of file Loader.cpp.

Referenced by OnInit(), and Patch().

◆ g_shutdown

void(* VoltMod::g_shutdown) (void *server) ( void * server ) = nullptr

static

Definition at line 32 of file Loader.cpp.

Referenced by OnShutdown(), and Patch().

◆ g_start

LoaderHandoff VoltMod::g_start {.HookDispatcher = &g_dispatcher}

static

Definition at line 25 of file Loader.cpp.

Referenced by LoadNextServer(), OnConnect(), Patch(), and StartHost().

◆ g_stopHost

HostStopFn VoltMod::g_stopHost = nullptr

static

Definition at line 26 of file Loader.cpp.

Referenced by StartHost(), and StopHost().

◆ GameDataPath

constexpr std::string_view VoltMod::GameDataPath = "addons/voltmod/gamedata/gamedata.jsonc"

staticconstexpr

Definition at line 36 of file Host.cpp.

Referenced by VoltMod::Host::Start().

◆ GlowRangeUnits

constexpr int VoltMod::GlowRangeUnits = 5000

staticconstexpr

Definition at line 13 of file GlowVision.cpp.

◆ GlowRenderAmt

constexpr int VoltMod::GlowRenderAmt = 1

staticconstexpr

Definition at line 16 of file GlowVision.cpp.

◆ GlowStateAlwaysOn

constexpr int VoltMod::GlowStateAlwaysOn = 3

staticconstexpr

Definition at line 15 of file GlowVision.cpp.

◆ GlowTeamAny

constexpr int VoltMod::GlowTeamAny = -1

staticconstexpr

Definition at line 14 of file GlowVision.cpp.

◆ HierarchyBaseCount

constexpr size_t VoltMod::HierarchyBaseCount = 0x08

staticconstexpr

Definition at line 24 of file VtableLookup.windows.cpp.

Referenced by FindBaseInRtti().

◆ HierarchyBaseList

constexpr size_t VoltMod::HierarchyBaseList = 0x0C

staticconstexpr

Definition at line 25 of file VtableLookup.windows.cpp.

Referenced by FindBaseInRtti().

◆ HierarchySize

constexpr size_t VoltMod::HierarchySize = 0x10

staticconstexpr

Definition at line 26 of file VtableLookup.windows.cpp.

Referenced by FindBaseInRtti().

◆ HostFile

constexpr std::string_view VoltMod::HostFile = VOLTMOD_HOST_FILE

inlineconstexpr

Definition at line 18 of file Loader.hpp.

Referenced by StartHost().

◆ HostStartName

constexpr const char* VoltMod::HostStartName = "VoltMod_HostStart"

inlineconstexpr

Definition at line 26 of file LoaderHandoff.hpp.

Referenced by StartHost().

◆ HostStopName

constexpr const char* VoltMod::HostStopName = "VoltMod_HostStop"

inlineconstexpr

Definition at line 27 of file LoaderHandoff.hpp.

Referenced by StartHost().

◆ InMemory

constexpr std::string_view VoltMod::InMemory = ":memory:"

staticconstexpr

Definition at line 33 of file OpenConnection.cpp.

Referenced by OpenConnection(), and SqliteSettings().

◆ IsMariaDb

template<class Conn >

constexpr bool VoltMod::IsMariaDb = std::same_as<std::remove_cvref_t<Conn>, MariaDbConnection>

inlineconstexpr

Definition at line 31 of file Connection.hpp.

◆ IsOptionalArg

template<class T >

constexpr bool VoltMod::IsOptionalArg< Args::Opt< T > > = false

inlineconstexpr

Whether T is an Args::Opt.

Definition at line 191 of file Args.hpp.

◆ IsPostgres

template<class Conn >

constexpr bool VoltMod::IsPostgres = std::same_as<std::remove_cvref_t<Conn>, PostgresConnection>

inlineconstexpr

Dialect tests for the if constexpr branches of a job body run against auto& conn.

Definition at line 28 of file Connection.hpp.

◆ IsSqlite

template<class Conn >

constexpr bool VoltMod::IsSqlite = std::same_as<std::remove_cvref_t<Conn>, SqliteConnection>

inlineconstexpr

Definition at line 34 of file Connection.hpp.

◆ kBreadcrumbSeparator

constexpr std::string_view VoltMod::kBreadcrumbSeparator = " › "

staticconstexpr

Definition at line 10 of file MenuStack.cpp.

◆ KeySeparator

constexpr char VoltMod::KeySeparator = '\x1f'

staticconstexpr

Separates the parts of a key; not legal in an element id or a variable name.

Definition at line 7 of file WriteCache.cpp.

◆ LibrarySuffix

constexpr std::string_view VoltMod::LibrarySuffix = ".so"

staticconstexpr

Definition at line 20 of file PluginLoader.cpp.

Referenced by LibraryPath().

◆ LocatorHierarchy

constexpr size_t VoltMod::LocatorHierarchy = 0x10

staticconstexpr

Definition at line 21 of file VtableLookup.windows.cpp.

Referenced by FindBaseInRtti().

◆ LocatorOffset

constexpr size_t VoltMod::LocatorOffset = 0x04

staticconstexpr

Definition at line 19 of file VtableLookup.windows.cpp.

Referenced by FindLocator().

◆ LocatorSelf

constexpr size_t VoltMod::LocatorSelf = 0x14

staticconstexpr

Definition at line 22 of file VtableLookup.windows.cpp.

Referenced by FindLocator().

◆ LocatorSize

constexpr size_t VoltMod::LocatorSize = 0x18

staticconstexpr

Definition at line 23 of file VtableLookup.windows.cpp.

Referenced by FindLocator().

◆ LocatorTypeDescriptor

constexpr size_t VoltMod::LocatorTypeDescriptor = 0x0C

staticconstexpr

Definition at line 20 of file VtableLookup.windows.cpp.

Referenced by FindLocator().

◆ ManifestName

constexpr std::string_view VoltMod::ManifestName = "plugin.json"

staticconstexpr

Definition at line 45 of file InstalledPlugins.cpp.

Referenced by VoltMod::InstalledPlugins::Discover().

◆ MaxBases [1/2]

constexpr uint32_t VoltMod::MaxBases = 64

staticconstexpr

Definition at line 124 of file VtableLookup.cpp.

Referenced by BaseCount(), and FindBaseInRtti().

◆ MaxBases [2/2]

constexpr uint32_t VoltMod::MaxBases = 1024

staticconstexpr

Definition at line 30 of file VtableLookup.windows.cpp.

◆ MaxDepth

constexpr int VoltMod::MaxDepth = 32

staticconstexpr

Definition at line 125 of file VtableLookup.cpp.

Referenced by CollectBases().

◆ MaxDownloadAttempts

constexpr int VoltMod::MaxDownloadAttempts = 3

staticconstexpr

Offers of one addon before a declining client is dropped.

Definition at line 27 of file WorkshopDownloads.cpp.

◆ MaxIndicesPerPlayer

constexpr int VoltMod::MaxIndicesPerPlayer = 24

staticconstexpr

Definition at line 17 of file Visibility.cpp.

Referenced by AddHandleVector(), and AddIndex().

◆ MaxPlayers

constexpr int VoltMod::MaxPlayers = 64

inlineconstexpr

Maximum player slots on a CS2 server (slots 0..MaxPlayers-1).

Definition at line 7 of file Slot.hpp.

Referenced by VoltMod::MenuStack::AnyOpen(), VoltMod::Messages::Broadcast(), VoltMod::Messages::BroadcastKey(), VoltMod::PluginContext::DisconnectClients(), VoltMod::MenuFreeze::Enable(), IsValidSlot(), VoltMod::Visibility::OnCheckTransmit(), VoltMod::GlowVision::Refresh(), VoltMod::PluginContext::ReplayMissedEvents(), and VoltMod::CenterHtml::StopAll().

◆ MaxQueuedJobs

constexpr size_t VoltMod::MaxQueuedJobs = 4096

staticconstexpr

Jobs beyond this are refused while the database stalls.

Definition at line 10 of file Client.cpp.

◆ MaxScale

constexpr float VoltMod::MaxScale = 3.0f

staticconstexpr

Definition at line 58 of file Entity.cpp.

Referenced by VoltMod::Entity::SetScale().

◆ MaxVarintBytes

constexpr int VoltMod::MaxVarintBytes = 10

staticconstexpr

A varint is at most ten bytes; more is malformed rather than merely large.

Definition at line 17 of file ButtonPressMessage.cpp.

Referenced by ReadVarint().

◆ MaxWaiting

constexpr size_t VoltMod::MaxWaiting = 64

staticconstexpr

Requests beyond this many waiting fail at once.

Definition at line 20 of file HttpClient.cpp.

Referenced by VoltMod::HttpClient::Send().

◆ MaxWorkers

constexpr size_t VoltMod::MaxWorkers = 4

staticconstexpr

Definition at line 18 of file HttpClient.cpp.

Referenced by VoltMod::HttpClient::Send().

◆ MinScale

constexpr float VoltMod::MinScale = 0.05f

staticconstexpr

Definition at line 57 of file Entity.cpp.

Referenced by VoltMod::Entity::SetScale().

◆ NoIssue

constexpr int VoltMod::NoIssue = -1

staticconstexpr

Definition at line 29 of file Vote.cpp.

◆ NoOption

constexpr int VoltMod::NoOption = 1

staticconstexpr

Definition at line 34 of file Vote.cpp.

Referenced by VoltMod::Vote::TryCastBallot().

◆ PlatformDir

constexpr std::string_view VoltMod::PlatformDir = VOLTMOD_BIN_DIR

inlineconstexpr

Definition at line 17 of file Loader.hpp.

Referenced by LoadNextServer().

◆ PlatformName

constexpr std::string_view VoltMod::PlatformName = "linux"

inlineconstexpr

Definition at line 76 of file GameDataDocument.hpp.

Referenced by ColumnValue().

◆ PluginEntryName

constexpr const char* VoltMod::PluginEntryName = "VoltMod_Plugin"

inlineconstexpr

The one symbol the host resolves in a plugin library. A new name whenever the descriptor's layout changes, so an older library is never read.

Definition at line 36 of file PluginDescriptor.hpp.

Referenced by ValidateDescriptor().

◆ PropSpawnFlags

constexpr int VoltMod::PropSpawnFlags = 256

staticconstexpr

Definition at line 12 of file GlowVision.cpp.

◆ ReconnectBackoff

constexpr auto VoltMod::ReconnectBackoff = std::chrono::seconds(5)

staticconstexpr

After a failed connect, jobs fail at once for this long.

Definition at line 12 of file Client.cpp.

◆ Rel32Size

constexpr int VoltMod::Rel32Size = 4

inlineconstexpr

Definition at line 17 of file RelativeAddress.hpp.

Referenced by Rel32ReadInBounds().

◆ ServerFile

constexpr std::string_view VoltMod::ServerFile = "libserver.so"

inlineconstexpr

Definition at line 22 of file Loader.hpp.

Referenced by LoadNextServer().

◆ SightMask

constexpr uint64_t VoltMod::SightMask = CONTENTS_SOLID | CONTENTS_BLOCK_LOS

staticconstexpr

Windows are see-through and clips are invisible, so neither hides a player.

Definition at line 15 of file Trace.cpp.

Referenced by MaskOf().

◆ SolidNone

constexpr int VoltMod::SolidNone = 0

staticconstexpr

Definition at line 10 of file EntitySystemSpawn.cpp.

Referenced by VoltMod::EntitySystem::SpawnProp().

◆ SolidVPhysics

constexpr int VoltMod::SolidVPhysics = 6

staticconstexpr

Definition at line 11 of file EntitySystemSpawn.cpp.

Referenced by VoltMod::EntitySystem::SpawnProp().

◆ SourceExtension

constexpr std::string_view VoltMod::SourceExtension = ".xml"

staticconstexpr

Definition at line 8 of file LayoutPath.cpp.

Referenced by VoltMod::LayoutPath::Name(), and VoltMod::LayoutPath::Parse().

◆ SslModes

constexpr SslModeName VoltMod::SslModes[]

staticconstexpr

Initial value:

= {
    {"disable", PostgresSslMode::disable},     {"allow", PostgresSslMode::allow},
    {"prefer", PostgresSslMode::prefer},       {"require", PostgresSslMode::require},
    {"verify-ca", PostgresSslMode::verify_ca}, {"verify-full", PostgresSslMode::verify_full},
}

Definition at line 23 of file OpenConnection.cpp.

Referenced by ParseSslMode().

◆ StringTableCap

constexpr int VoltMod::StringTableCap = 1024

staticconstexpr

CS2 refuses to intern past this many entries per table; stop short so a runaway caller cannot fill them.

Definition at line 23 of file ScreenEntity.cpp.

◆ StringTableHeadroom

constexpr int VoltMod::StringTableHeadroom = 64

staticconstexpr

Definition at line 24 of file ScreenEntity.cpp.

◆ SurfacesMask

constexpr uint64_t VoltMod::SurfacesMask = CONTENTS_SOLID | CONTENTS_WINDOW | CONTENTS_PASS_BULLETS | CONTENTS_SKY

staticconstexpr

Definition at line 16 of file Trace.cpp.

Referenced by MaskOf().

◆ TlsModes

constexpr PostgresSslMode VoltMod::TlsModes[]

staticconstexpr

Initial value:

= {PostgresSslMode::require, PostgresSslMode::verify_ca,

PostgresSslMode::verify_full}

The modes MariaDB, which takes a bool, reads as "the connection must use TLS".

Definition at line 30 of file OpenConnection.cpp.

Referenced by MariaDbSettings().

◆ TypeDescriptorName

constexpr size_t VoltMod::TypeDescriptorName = 0x10

staticconstexpr

Definition at line 18 of file VtableLookup.windows.cpp.

Referenced by FindTypeDescriptor(), and TypeDescriptorMatches().

◆ TypeInfoBase

constexpr size_t VoltMod::TypeInfoBase = 2 * sizeof(void*)

staticconstexpr

Definition at line 117 of file VtableLookup.cpp.

Referenced by CollectBases(), and HasSingleBase().

◆ TypeInfoBaseList

constexpr size_t VoltMod::TypeInfoBaseList = 3 * sizeof(void*)

staticconstexpr

Definition at line 120 of file VtableLookup.cpp.

Referenced by BaseCount(), and CollectBases().

◆ TypeInfoCount

constexpr size_t VoltMod::TypeInfoCount = TypeInfoFlags + sizeof(uint32_t)

staticconstexpr

Definition at line 119 of file VtableLookup.cpp.

Referenced by BaseCount().

◆ TypeInfoFlags

constexpr size_t VoltMod::TypeInfoFlags = 2 * sizeof(void*)

staticconstexpr

Definition at line 118 of file VtableLookup.cpp.

Referenced by BaseCount().

◆ UserMessageName

constexpr std::string_view VoltMod::UserMessageName = "CSVCMsg_UserMessage"

staticconstexpr

Definition at line 22 of file ButtonPresses.cpp.

◆ VirtualBaseFlag

constexpr uintptr_t VoltMod::VirtualBaseFlag = 1

staticconstexpr

Definition at line 122 of file VtableLookup.cpp.

Referenced by CollectBases().

◆ VoteFailedMessage

constexpr std::string_view VoltMod::VoteFailedMessage = "CCSUsrMsg_VoteFailed"

staticconstexpr

Definition at line 39 of file Vote.cpp.

◆ VotePassMessage

constexpr std::string_view VoltMod::VotePassMessage = "CCSUsrMsg_VotePass"

staticconstexpr

Definition at line 38 of file Vote.cpp.

◆ VoteStartMessage

constexpr std::string_view VoltMod::VoteStartMessage = "CCSUsrMsg_VoteStart"

staticconstexpr

Definition at line 37 of file Vote.cpp.

◆ WarningIntervalSeconds

constexpr int64_t VoltMod::WarningIntervalSeconds = 10

staticconstexpr

Definition at line 24 of file ButtonPresses.cpp.

◆ WireFixed32

constexpr uint32_t VoltMod::WireFixed32 = 5

staticconstexpr

Definition at line 14 of file ButtonPressMessage.cpp.

Referenced by SkipField().

◆ WireFixed64

constexpr uint32_t VoltMod::WireFixed64 = 1

staticconstexpr

Definition at line 12 of file ButtonPressMessage.cpp.

Referenced by SkipField().

◆ WireLengthDelimited

constexpr uint32_t VoltMod::WireLengthDelimited = 2

staticconstexpr

Definition at line 13 of file ButtonPressMessage.cpp.

Referenced by VoltMod::ButtonPressMessage::Parse(), and SkipField().

◆ WireVarint

constexpr uint32_t VoltMod::WireVarint = 0

staticconstexpr

Protobuf wire types; only these can appear ahead of the fields we want.

Definition at line 11 of file ButtonPressMessage.cpp.

Referenced by SkipField().

◆ YesNoIssueIndex

constexpr int VoltMod::YesNoIssueIndex = 2

staticconstexpr

Definition at line 28 of file Vote.cpp.

Referenced by VoltMod::Vote::Start().

◆ YesOption

constexpr int VoltMod::YesOption = 0

staticconstexpr

Definition at line 33 of file Vote.cpp.

Referenced by VoltMod::Vote::TryCastBallot().

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AnyConnection

◆ BoundArg

◆ ByteHistogram

◆ EmitSoundFilterFn

◆ GameDataLookup

◆ HandleVector

◆ HasDefault

◆ HostStartFn

◆ HostStopFn

◆ HttpCompletion

◆ HttpHeaders

◆ InterfaceFactory

◆ MariaDbConnection

◆ OriginalSlotLookup

◆ PairCooldown

◆ PluginsByName

◆ PostEvent

◆ PostgresConnection

◆ PostgresSslMode

◆ ProtoFieldDescriptor

◆ ProtoMessage

◆ QAngle

◆ RefusalsByName

◆ Required

◆ Result

◆ ScriptBindingLookup

◆ SqliteConnection

◆ Status

◆ StringMap

◆ StringTable

◆ Tokens

◆ Vector

Enumeration Type Documentation

◆ AddonAction

◆ ArgKind

◆ ChoiceApply

◆ ClientConVarStatus

◆ CommandAccess

◆ ConVarType

◆ Driver

◆ ErrorCode

◆ GameDataSection

◆ HitGroup

◆ HookAction

◆ HttpMethod

◆ LogLevel

◆ MenuButtonKind

◆ MenuRowKind

◆ MessageKind

◆ ObserverMode

◆ Origin

◆ RoundEndReason

◆ TargetError

◆ TargetKind

◆ Team

◆ TraceLayers

◆ VoteEndReason

◆ WriteKind

Function Documentation

◆ AddHandleVector()

◆ AddIndex()

◆ AddonList()

◆ AdmitClient()

◆ AnchorOf()

◆ AngleToForward()

◆ AppendPlayerRows()

◆ AppendToAddonList()

◆ ApplyMigration()

◆ ArgKindsMatchOrder()

◆ AsProto()

◆ AtRva()

◆ BaseCount()