diff --git a/.forgejo/workflows/ci.yml b/.forgejo/workflows/ci.yml index 11844c8..ff9cedf 100644 --- a/.forgejo/workflows/ci.yml +++ b/.forgejo/workflows/ci.yml @@ -72,4 +72,4 @@ jobs: release-dir: dist token: ${{ secrets.GITHUB_TOKEN }} override: true - release-notes: "`source2rosetta-gen` ${{ github.ref_name }} — renders a published gamedata release into your framework's format: CounterStrikeSharp, Metamod/SourceMod, ModSharp, Swiftly, Plugify, or a typed C# SDK. Download it, `chmod +x`, and point it at the `gamedata-.json` / `netvars-.json` from a per-game release (`cs2-latest`, `dota2-latest`). Usage: see `crates/source2rosetta-core/README.md`. Linux x86-64." + release-notes: "`source2rosetta-gen` ${{ github.ref_name }} — renders a published release into your framework's format: CounterStrikeSharp, Metamod/SourceMod, ModSharp, Swiftly, Plugify, a typed C# SDK, or the Dota script API. A `--format` names WHO the output is for and writes every file that consumer reads, so `--out` is a directory. Download it, `chmod +x`, and point it at the `rosetta-.json` from a per-game release (`cs2-latest`, `dota2-latest`): `source2rosetta-gen --from rosetta-cs2.json --format cssharp --out ./out`. Usage: see `crates/source2rosetta-core/README.md`. Linux x86-64." diff --git a/.forgejo/workflows/derive.yml b/.forgejo/workflows/derive.yml index 0c48ada..c13353b 100644 --- a/.forgejo/workflows/derive.yml +++ b/.forgejo/workflows/derive.yml @@ -20,8 +20,9 @@ jobs: runs-on: s2-runner env: GAME: ${{ github.event.inputs.game }} - STEAM_APPS: /home/cs2/.steam/SteamApps STEAM_USER: source2rosetta + STEAM_HOME_ANON: /home/cs2 + STEAM_HOME_AUTH: /home/cs2/steam-auth RELEASE_BASE: ${{ github.server_url }}/${{ github.repository }}/releases/download OVERRIDE_DIR: /home/cs2/rosetta-override steps: @@ -30,12 +31,36 @@ jobs: - name: Update the install to the current build run: | case "$GAME" in - cs2) APPID=730 ;; - dota2) APPID=570 ;; + cs2) APPID=730; LOGIN=anonymous; STEAM_HOME="$STEAM_HOME_ANON" ;; + dota2) APPID=570; LOGIN="$STEAM_USER"; STEAM_HOME="$STEAM_HOME_AUTH" ;; *) echo "unknown game '$GAME' (expected cs2 or dota2)"; exit 1 ;; esac - echo "APPID=$APPID" >> "$GITHUB_ENV" - steamcmd +login "$STEAM_USER" +app_update "$APPID" +quit + env HOME="$STEAM_HOME" steamcmd +login "$LOGIN" +app_update "$APPID" +quit + + STEAM_APPS=""; SEEN=""; BUILD="" + for cand in "$STEAM_HOME/Steam/steamapps" "$STEAM_HOME/.steam/steam/steamapps" \ + "$STEAM_HOME/.steam/SteamApps"; do + m="$cand/appmanifest_$APPID.acf" + [ -f "$m" ] || continue + # The same tree reached twice through a symlink is ONE tree, not a disagreement. + key=$(stat -Lc '%d:%i' "$m") + case " $SEEN " in *" $key "*) continue ;; esac + SEEN="$SEEN $key" + b=$(grep -oP '"buildid"[[:space:]]+"\K[0-9]+' "$m") + echo " candidate $cand -> buildid $b" + if [ -z "$STEAM_APPS" ]; then + STEAM_APPS="$cand"; BUILD="$b" + elif [ "$b" != "$BUILD" ]; then + echo "::error::two Steam app trees under $STEAM_HOME disagree — $STEAM_APPS says" \ + "$BUILD, $cand says $b. One is stale; deriving from it would publish gamedata for" \ + "a build nothing is running. Remove the stale tree or symlink it to the live one." + exit 1 + fi + done + [ -n "$STEAM_APPS" ] || { + echo "::error::no appmanifest_$APPID.acf under $STEAM_HOME — did the update run?"; exit 1; } + echo "using $STEAM_APPS (buildid $BUILD)" + { echo "APPID=$APPID"; echo "STEAM_APPS=$STEAM_APPS"; } >> "$GITHUB_ENV" - name: Resolve the game paths + the new buildid run: | @@ -72,6 +97,7 @@ jobs: --seed "in/seed-$GAME.json" \ --corpus-model "in/model-$GAME.json" \ --prototypes mappings/prototypes.json \ + --semantics "mappings/semantics-$GAME.json" \ --ehandle-classes mappings/ehandle-classes.json \ --target "work/$BUILDID" \ --game-dir "$GAME_DIR" \ diff --git a/Cargo.lock b/Cargo.lock index c3a9cf0..8fe48f3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -248,7 +248,7 @@ dependencies = [ [[package]] name = "source2rosetta-core" -version = "2.0.0" +version = "3.0.2" dependencies = [ "anyhow", "clap", diff --git a/README.md b/README.md index a00cd5e..cb2319c 100644 --- a/README.md +++ b/README.md @@ -8,16 +8,16 @@ Here it takes **about half an hour, with nobody involved.** A timer notices the ```sh R=https://git.lo.sh/kamal/source2rosetta/releases/download/cs2-latest # always the newest build -curl -fsSLO $R/gamedata-cs2.json # WHERE functions are — signatures + vtable offsets -curl -fsSLO $R/netvars-cs2.json # field offsets and types -curl -fsSLO $R/abi-cs2.json # HOW to call them — parameter and return types, re-judged per build +curl -fsSLO $R/rosetta-cs2.json ``` -Also published: `bindings-.json` (the callable surface the binary declares about itself — Pulse -bindings, entity IO, console commands) and `manifest.json` (which build you got). The -[artifacts section](#artifacts-schemas--output-formats) covers all of them. +**One file per game.** One record per function: where it is, what its machine code was measured to take, what +a declaration says it takes, what the binary declares may be done with it, and what it does in plain language +— plus the typed schema, and the surfaces that are not function-keyed (the Pulse registry, entity outputs, +classnames, ConVars). `manifest.json` says which build you got. The +[artifacts section](#artifacts-schemas--output-formats) covers the shape. -The output is framework-neutral; `source2rosetta-gen` renders it into whatever your stack speaks — the gamedata into your framework's locator format, and `abi-.json` into **typed call sites** for the same functions. The deriver behind it is a standalone Rust tool — you only need that if you're self-hosting the pipeline or adding a game. +The output is framework-neutral; `source2rosetta-gen` renders it into whatever your stack speaks — one command writes both your framework's locator format and **typed call sites** for the same functions. The deriver behind it is a standalone Rust tool — you only need that if you're self-hosting the pipeline or adding a game. ## Docs @@ -28,14 +28,18 @@ The output is framework-neutral; `source2rosetta-gen` renders it into whatever y ## Results -Ballpark from a recent build, on a 16-core desktop. These move build-to-build — treat them as orders of magnitude, not guarantees. +Measured on CS2 build `24537688` and Dota 2 build `24541331`, on a 16-core desktop. These move build-to-build — treat them as orders of magnitude, not guarantees. -| | derived functions | typed schema | model | one-time distill | -|---|---|---|---|---| -| **CS2** | ~1,125 `core` + ~2,620 `high_confidence`, plus ~4,375 `experimental` name guesses | ~1,900 classes / ~12,300 fields | ~48 MB (a few MB gzipped) | ~15 min | -| **Dota 2** | ~1,930 `core` + ~2,450 `high_confidence`, plus ~5,950 `experimental` | ~2,960 classes / ~17,700 fields | ~570 MB | ~1 hr | +| | derived functions | declared surface | typed prototypes | typed schema | model | one-time distill | +|---|---|---|---|---|---|---| +| **CS2** | 1,086 `core` + 2,894 `high_confidence`, plus 4,374 `experimental` name guesses | **300 VScript bindings (247 located)**, 580 Pulse bindings (127 host-callable), 784 commands, 1,551 ConVars, 715 entity inputs / 226 outputs, 474 classnames | 2,158 `verified` + 92 `lower-bound`, 84 `mismatch`, 261 `return-only` | 1,899 classes / 12,331 fields | ~46 MB (a few MB gzipped) | ~15 min | +| **Dota 2** | 1,097 `core` + 4,047 `high_confidence`, plus 5,817 `experimental` | **1,841 VScript bindings (1,599 located)**, 500 Pulse bindings (99 host-callable), 855 commands, 1,171 ConVars, 624 entity inputs / 187 outputs, 3,528 classnames | 2,837 `verified` + 99 `lower-bound`, 45 `mismatch`, 1,594 `return-only` | 2,962 classes / 17,695 fields | ~735 MB | ~1 hr | -A full run live-validates what it ships and reports **0 dropped** on both games — for CS2 that is ~2,610 signatures and ~1,120 vtable offsets checked against a running server. Distilling the model is a one-time cost; after that each build's re-derive is minutes of compute, and the half hour in the headline is the whole loop: notice, update, derive, validate, publish. +**Declared surface** is what the binary states about itself, and it is a different kind of fact from the rest: no inference, no cross-build chaining, no confidence tier. Two counts in it are subsets worth reading precisely. *Host-callable* is the Pulse bindings invocable with an argument array alone — verified by calling each on a live server of both games. *Located* is the VScript bindings whose implementation folds onto a function record as a real locator; the rest are documented but not addressable, and a C++ name registered at two addresses is dropped rather than guessed. + +The VScript surface is the newest and it moves the `high_confidence` count more than anything else has: **+247 on CS2 and +1,599 on Dota**, every one a name Valve states in the binary alongside a declared return type. On Dota that is a 65% increase in the named surface, and it reaches gameplay verbs no other source in this project locates — `AddNewModifier`, `AddItemByName`, `CastAbilityOnTarget` and `ChangeTeam` are all absent from every tier of the previous release. + +A full run live-validates what it ships and reports **0 dropped** on both games — for CS2 that is 3,972 entries carrying 2,848 signatures and 1,129 vtable offsets, all checked against a running server (Dota: 5,138 entries, 4,309 signatures, 829 offsets). Distilling the model is a one-time cost; after that each build's re-derive is minutes of compute, and the half hour in the headline is the whole loop: notice, update, derive, validate, publish. --- @@ -51,14 +55,213 @@ A CS2 update never rebuilds Dota, and vice versa. Two rules keep it honest: ever | you want | use | |---|---| -| the newest build, always | `…/releases/download/cs2-latest/gamedata-cs2.json` | -| a specific build, pinned | `…/releases/download/cs2--0/gamedata-cs2.json` | +| the newest build, always | `…/releases/download/cs2-latest/rosetta-cs2.json` | +| a specific build, pinned | `…/releases/download/cs2--0/rosetta-cs2.json` | | to know what you got | `manifest.json` — carries `version = --` | Follow `-latest` to adopt updates as they land, or pin a buildid tag to adopt them deliberately; old snapshots stay up either way. Whichever you choose, **check the manifest's build id against the server you're actually running** before loading — that is what stops stale offsets meeting a changed binary. (`patch` counts rebuilds on the same binary, e.g. a merged contribution.) --- +## What can you build with this? + +The artifacts answer four different questions, and most useful work joins two or more of them: + +- **`functions` — where the code is.** Every record is a hook point or a call target: a byte signature or an RTTI vtable slot, tiered and, for `core`/`high_confidence`, checked against a running server. +- **`schema` — what the state is.** Field offsets and types for every SchemaSystem class, plus the base graph, the enum tables and per-type sizes. This is the half that needs no hooking at all: a great deal of gameplay is readable and writable as plain memory. +- **`prototype`, on each record — whether it is safe to call.** A declared prototype joined to the register footprint measured in *this* build, with a verdict per function. `verified` and `lower-bound` are callable; `mismatch` says the prototype in circulation is wrong for this binary. +- **`bindings` and `surfaces` — what the binary declares about itself.** Console commands and ConVars with decoded flags, entity inputs and outputs, map classname → C++ class, the typed Pulse registry with a callable entry point per binding, and the VScript registry — the surface Valve exposes to Lua, each entry pairing a script-facing name with a C++ name, an English description and a declared return type. + +Three of those are newer than the rest and worth calling out, because they change what a plugin can do: + +**The VScript registry closes the biggest gap in the Dota surface.** 1,841 bindings on Dota and 300 on CS2, each pairing the name a script author types with the C++ name, Valve's own English description, and a declared return type — and 1,599 / 247 of them fold into the gamedata as real locators. It is the only source here that supplies gameplay VERBS on Dota: `AddNewModifier`, `AddItemByName`, `CastAbilityOnTarget`, `ChangeTeam`, `ModifyGold` and `AddExperience` are absent from every tier of the previous release and present now, which is why the [Dota section below](#dota-2) reads differently from how it did. They are script-facing wrappers rather than the underlying methods, and for a caller that is a feature: the wrapper's argument shape is the one Valve declared for a content author to use safely, and the wrapper is what the engine itself invokes. + +**ConVars ship with their flags.** 1,551 on CS2 across four libraries, 782 in Dota's `libserver` — with `cheat`, `replicated`, `archive` and `notify` decoded, and the raw word beside them. The names are not the point: a consumer finds a convar by name at runtime with no gamedata at all. The *flags* are, because they are engine-declared authority. A host that wants to say "this module may change gameplay settings but not cheat-protected ones" can key that on what the engine itself declares instead of maintaining an allowlist by hand. + +**Most of the Pulse surface is callable.** Each binding carries a `shim` address and a `call.needs` verdict; the `args-only` tier — roughly 110 on CS2, 82 on Dota within `libserver` — is invocable with an argument array and nothing else, through Valve's own marshalling, which enforces the binding's declared types. Those are *actions* (teleport, ignite, change team, start a mover, spawn a template), which is the half no field write can do; reading state remains the schema's job and is better served there. + +Tiers stay visible throughout. `core` and `high_confidence` are buildable today; the `experimental` band is fenced off at the end and is a different kind of thing entirely. + +--- + +### CS2 + +#### Movement and player physics + +The whole per-tick movement chain is individually hookable — `PhysicsSimulate` → `ProcessMovement` → `MoveInit` → `CheckParameters` → `PlayerMove` → `FullWalkMove` → `{Friction, AirMove/AirAccelerate, CategorizePosition, CheckVelocity, StartGravity, CheckFalling}` → `PostPlayerMove`. Every stage is `core` with a validated signature, and 22 ABI entries declare the `CMoveData*` they hand you. `AirAccelerate` resolves as `void(CCSPlayer_MovementServices*, CMoveData*, Vector&, float, float)`, `verified`, with a measured footprint of three integer and two float registers — so a surf/KZ/bhop server that rewrites air acceleration in flight is a detour and two float writes, not a reverse-engineering project. Watch two edges: `PreWalkMove`'s prototype is `unverified`, and `GroundAccelerate` has a validated signature but no declared prototype at all (footprint only). + +Jumping splits into two independently hookable implementations — `CheckJumpButtonModern(CCSPlayerModernJump*, CMoveData*)` and `CheckJumpButtonLegacy(CCSPlayerLegacyJump*, CMoveData*)`, both `verified` — and both jump objects are fully laid out, down to sub-tick press and landing fractions. That plus `m_flAccumulatedJumpError` and `m_bHasWalkMovedSinceLastJump` is enough for either a legitimising autohop or a bhop-script detector built on press-phase distribution. + +Surf detection does not need heuristics: `CCSPlayer_MovementServices::m_flTicksSinceLastSurfingDetected` is the engine's own signal, sitting next to the ground normal, surface friction and the surface-property token. Per-player speed control is `CCSPlayerPawn::GetPlayerMaxSpeed` (`verified`) plus `m_flMaxspeed`, `m_flStamina` and `m_flVelocityModifier`. Crouch work has a real predicate to hook — `CanUnduck` is `bool(CCSPlayer_MovementServices*, CMoveData*)`, so returning false pins a player crouched with full engine consistency rather than by poking a netvar. And the input side is intercepted at `CPlayer_MovementServices::RunCommand`, with `m_nButtons`, the fully enumerated 64-bit `InputBitMask_t`, the `uint32[64]` per-button last-press command numbers, and the four sub-tick move fractions all readable. + +What you do not get: `TryPlayerMove`, `WalkMove`, `Accelerate` and `TracePlayerBBox` are all `unresolved` (`sig-drifted`) this build, and `CMoveData` itself is not a schema class — you get a correctly-typed pointer and no field offsets. + +#### Combat, damage and tracing + +`CBaseEntity::TakeDamage` is the funnel and `CCSPlayerPawn::OnTakeDamage_Alive` the player-specific override, but the interesting part is that you do not need a constructor to build a damage packet: `CTakeDamageInfo` is laid out completely — 22 fields over 280 bytes — and `CTakeDamageResult` (15 fields) tells you what the engine actually did, including `m_flPreModifiedDamage` beside `m_flDamageDealt` and a `m_bWasDamageSuppressed` flag. `DamageTypes_t`, `HitGroup_t` and the 21-flag `TakeDamageFlags_t` (`DFLAG_PREVENT_DEATH`, `DFLAG_IGNORE_ARMOR`, …) give you the switchboard. Two prototype notes, and the second is the sharpest example in this file of why the locator and the prototype are separate facts. `CBaseEntity::Event_Killed` is `verified` and measures as the CS2-shaped `(CCSPlayerPawn*, CTakeDamageResult*)`, not the Source-1 `CTakeDamageInfo const&` everyone assumes. And `CBaseEntity::TakeDamage` — the funnel itself — is tier `core` with `validated: true`, and its prototype verdict is **`mismatch`**: the circulated declaration `(CTakeDamageInfo&)` accounts for two integer registers and this build's callee reads **three**. The address is right and hooking it is fine; *calling through that declaration* would load the wrong registers. Build the struct by offsets and prefer the verified entry points. + +**Do not use `CBaseEntity::DispatchTraceAttack`. Earlier revisions of this section recommended it, and it is mislocated** — the entry resolves to `CLogicRelay::Trigger`, which is a different function entirely. It is the clearest example in this file of why a locator that passes every check can still be wrong, so it is worth reading rather than just avoiding: its shipped pattern is a bare compiler prologue with no distinguishing content, so it is unique in the library by luck rather than by identity; the address holds real executable code, so live validation passed it; and `Trigger(hActivator, hCaller)` on a relay measures the same `int=3, ret=int` footprint as the declared `(CBaseEntity*, CTakeDamageInfo*, CTakeDamageResult*)`, so the ABI check called it `verified`. Three independent guards, none of which is an identity check. What caught it was **Valve's VScript registry naming that same address `Trigger`, with the description "Triggers the logic_relay"** — and the disassembly agreeing, every offset it touches being a named `CLogicRelay` field (`m_OnTrigger` at `+0x7a0`, `m_bDisabled`, `m_bPassthoughCaller`). Found 2026-08-01 by the [alias grouping](#functions--one-record-each), which is what made two sources' accounts of one address comparable at all. + +Weapon rebalancing is entirely schema work. `CCSWeaponBaseVData` is 84 fields over 2,216 bytes: damage, headshot multiplier, armour ratio, penetration, range falloff, cycle time, seven per-stance inaccuracy terms, four recoil terms, the spray-recovery transition bullets, price, kill award — and `m_nRecoilSeed`/`m_nSpreadSeed`, the per-weapon RNG seeds that generate CS2's deterministic spray patterns. Reach it with `FindWeaponVDataByName` (`verified`); there is no member offset from a weapon entity to its VData. + +Tracing has one fully `verified`, params-complete entry point — `TraceShape(const void*, const Ray_t&, const Vector&, const Vector&, const CTraceFilter*, trace_t*)` — corroborated by two independent declarations. The catch is structural and worth planning for: `Ray_t`, `trace_t`, `CGameTrace` and `CTraceFilter` are not schema types, so you get the call shape and must supply the struct definitions. If you would rather not, `CPulseServerFuncs::GetTraceHit` is a fully typed ray cast with six named return values, and `DealDamage`/`DealRadiusDamage` sit beside it — a complete custom hitscan weapon with no native code. + +For inventory and loadout rules, eight `CCSPlayer_WeaponServices` entry points carry `verified`, params-complete prototypes including `this` (`EquipWeapon`, `DropWeapon`, `SwitchWeapon`, `GetWeaponBySlot`, and the `CanEquip`/`CanSwitch`/`CanUse` predicates), and `CCSPlayer_ItemServices::CanAcquire` is a verified buy gate. Skins and StatTrak are pure offsets: the `CEconEntity` fallback block, `CAttributeContainer::m_Item` → a fully laid-out `CEconItemView`, and `CAttributeList::SetOrAddAttributeValueByName` (`verified`) to write. + +Two things make this domain unusually workable. The entire combat pipeline lands in `core` and `high_confidence` — the experimental band contributes nothing to it. And `CCSScript_EntityScript` comes out as a contiguous named vtable run with a three-stage damage pipeline — `OnBeforePlayerDamage`, `OnModifyPlayerDamage`, `OnPlayerDamage` (veto / scale / observe) — which is exactly the shape a perk or RPG mod wants, though none of those slots has a typed prototype, only a measured register count. + +#### Bots and the nav mesh + +`CCSPlayerPawn::m_pBot` is a typed `CCSBot*` on the pawn, and `CCSBot` is 140 typed fields over 24,088 bytes: current enemy, visible parts, goal position, path index, heard noise, panic and hurry timers, stuck state with a velocity ring buffer, radio timestamps, and the whole aim model (`m_lookPitch`/`m_lookYaw` with velocities, `m_aimError`, `m_aimFocus`, the reaction-queue indices). Every `CountdownTimer` is itself a schema class, so timers are readable *and* writable. A live bot-brain inspector, a custom difficulty curve, or an anti-stuck watchdog all need zero hooking. + +The aim and behaviour functions — `UpdateLookAngles`, `UpdateReactionQueue`, `BendLineOfSight`, `FindMostDangerousThreat`, plus the direct verbs `SetBotEnemy`, `SetState`, `Panic`, `Blind`, `Retreat` — are `core` or `high_confidence` byte signatures, but **none has a declared prototype**: not one `CCSBot::` method carries one. You get an address and a register count. + +The state machine is more limited than it first looks. All 16 behaviour states appear as `core` entries and a `OnEnter=0 / OnUpdate=1 / OnExit=2 / GetName=3` slot convention is visible across them. But those offset-form entries carry no class binding — `IdleState::OnEnter`, `HideState::OnEnter` and `PickupHostageState::OnEnter` are all bare "slot 0" — so resolving a specific state's vtable needs a class pointer the artifacts do not supply. Eleven of the state methods (including `CCSBot::SetState` and eight `OnUpdate` slots) ship as byte signatures instead, and those you can resolve directly. + +Nav work is better served from the sides than the middle. `CPulseServerFuncs::GetEntityNavMeshPosition` and `GetEntityHeightAboveNavMesh` are typed with no signature dependency at all; `CCSBot::m_playerTravelDistance` is a `float32[64]` of nav travel distance from that bot to every player slot, maintained by the engine every tick — real walk distances for free. Runtime map flow is `CFuncNavBlocker` with `m_nBlockedTeamNumber` (per-team blocking) driven by `BlockNav`/`UnblockNav`, whose handlers are `verified` and params-complete. The 44 `nav_*` editor commands survive in the dedicated server with verified `void(CCommandContext*, CCommand*)` handlers, including `nav_check_connectivity` — but nearly all of them carry the `cheat` flag, so a CI map-validation harness runs with `sv_cheats` on, not on a public server. There is no `CNavArea` or `CNavMesh` schema class: area-level data means calling engine functions with pointers you obtained from other engine functions. + +#### Entities, spawning and map mechanics + +The runtime-spawn chain is `core` and `verified` end to end: `CreateEntityByName` → `CEntityKeyValues::FindOrCreateKeyValues`/`SetString` → `CEntityKeyValues::AddConnectionDesc` → `CGameEntitySystem::DispatchSpawn`. `AddConnectionDesc`'s nine-parameter prototype maps field-for-field onto the schema struct `EntityIOConnectionData_t`, and its `targetType` argument is enumerated by `EntityIOTargetType_t` — prototype, struct layout and legal constants derived separately and agreeing. The 474-entry classname table (`prop_dynamic` → `CDynamicProp`, and the alias forms Valve registers separately) tells you what to pass. One hole: nothing here tells you how to *allocate* the `CEntityKeyValues` object. + +Entity I/O is where one hook shape covers an enormous surface. 715 CS2 inputs are enumerated with class, handler symbol and address, 673 have a live signature, and the overwhelming majority carry the same `verified` prototype `void(CEntityInstance*, InputData_t&)` — so a single trampoline plus a dispatch table keyed by address is an IO firewall for community maps. Do check before assuming universality: about fifteen handlers declare something else (`CBaseFilter::InputTestActivator` takes a `CBaseEntity*`; `CGamePlayerEquip::InputTriggerForActivatedPlayer` takes an `InputData_t*`; the `CMathCounter` arithmetic inputs declare only `inputdata_t&`), and thirteen are verdict `unverified`. To fire rather than intercept, `CGameEntitySystem::AddEntityIOEvent` is `verified` with a full 10-parameter prototype including the delay float. The limit: `InputData_t` and `Variant_t` have no schema layout, so you get the hook point and not a payload decoder. + +Trigger volumes have a single global arbiter — `CBaseTrigger::PassesTriggerFilters` is `verified` `bool(CBaseEntity*)` at vtable 270 — and a passive reader: `m_hTouchingEntities` is a live handle vector at a fixed offset. Collision surgery is netvar-only and complete: `VPhysicsCollisionAttribute_t` exposes `m_nInteractsAs`/`m_nInteractsWith`/`m_nInteractsExclude` as three `uint64` masks, which is exactly the knob a no-block plugin flips. + +`func_mover` is a trap for anyone working from the IO graph: it has zero entity inputs and zero entity outputs, so an audit of that graph concludes it is inert. Its entire runtime surface is 44 typed `CFuncMoverAPI` Pulse methods plus 98 netvar fields. CS2's spline-mover system lives outside the classic IO graph. + +#### Game rules, teams and economy + +`CCSGameRules` is 189 fields over 70,720 bytes, reached by finding `cs_gamerules` and reading `CCSGameRulesProxy::m_pGameRules` — the bare `GameRulesPointer` signature is `unresolved` this build, so use the entity route. From there `RestartRound` and `GoToIntermission` are `verified`, `TerminateRound` is `lower-bound` with a delay/reason/reward-vector prototype, and warmup, phase and reset drivers are validated addresses with **no** declared prototype — a real gap in an otherwise strong domain. The round-end presentation block (winner, reason, message string, fun-fact token, mute flags) is all writable, and `m_iMatchStats_RoundResults[30]` with the two per-round alive-count arrays means a full competitive match history is readable from one pointer with no event subscription. + +Money is a plain `int32`: `m_pInGameMoneyServices` → `m_iAccount`, with start/spent/next-round fields beside it and the whole team loss-bonus model on the rules object. Note there is **no per-player money function at any tier** — no `AddAccount`, no `GiveMoney` anywhere in the search — so an economy mod writes the ledger and replicates with `NetworkStateChanged` (`verified`; its sibling `StateChanged` is verdict `mismatch`, so use the right one). + +Team moves have three independent paths — `CBaseEntity::ChangeTeam` at vtable 102, `CBasePlayerController::SwitchSteam` (`verified`), and the command path — gated by `CCSGameRules::WillTeamHaveRoomForPlayer` (`verified`). Two of the alternatives are weaker than they look: `CCSPlayerController::SwitchTeam` and `HandleCommandJoinTeam` are `unverified`, and `abi:CCSPlayerController::ChangeTeam` is `return-only` (no parameter list). Respawn waves are two arrays on the rules object (`m_TeamRespawnWaveTimes`, `m_flNextRespawnWave`), and spawn-point pools with round-robin cursors sit beside them — though the engine's *choice* of spawn point is not exposed as a hookable function. One inconsistency to resolve in-engine before relying on either: `CCSPlayerController::Respawn` and `CCSPlayerController::RoundRespawn` are both reported at vtable 272 while the base-class `RoundRespawn` is at 270 — two names cannot share one slot. + +Stats need no events at all. `CSMatchStats_t` derives from `CSPerRoundStats_t` and already tracks `m_i1v1Count`/`m_i1v1Wins`, `m_i1v2*`, `m_iEntryCount`/`m_iEntryWins`, `m_iEnemy5Ks` through `m_iEnemy2Ks`, and shots fired vs shots on target — the clutch and entry numbers most stats plugins recompute from kill events. + +#### Effects, sound and networking + +The lowest-risk half of this domain needs no signatures: `env_shake`, `env_fade`, `env_beam`, `env_instructor_hint`, `env_fog_controller`, `env_tonemap_controller` and the render/glow block on `CBaseModelEntity` are all datadesc-sourced inputs plus exact schema offsets, with their enums (`ShakeCommand_t`, `ViewFadeMode_t`, `BeamType_t`, `RenderFx_t`) fully enumerated. `CParticleSystem` networks 64 entity-attached control points *and* 64 control-point names, so a beam tracking two moving players is state, not a call. + +`UTIL_DispatchEffect`/`UTIL_DispatchEffectFilter` are `core`, `verified`, params-complete, and their one non-trivial argument — `CEffectData` — is fully mapped (20 fields, 112 bytes, SysV `memory`). That pairing is the ideal case these artifacts exist to produce. + +Recipient filters are the gap in this domain, and several otherwise-attractive routes run through them. The filtered dispatchers (`UTIL_DispatchParticleEffectFilter_Position`/`_Attachment`, `UTIL_SayTextFilter`, `UTIL_SayText2Filter`, `SoundOpGameSystem::StartSoundEventString`) are real and verified — but the *only* recipient-filter symbol anywhere in the catalogue is `CRecipientFilter::AddAllPlayers`, whose ABI entry is `unverified` with an empty parameter list. There is no `AddRecipient`, no per-team filter, no single-user filter. You get "dispatch to everyone" and a filter-shaped hole you must fill from your own framework. The genuinely per-client route that *is* covered is the `point_soundevent` entity: `StartSoundOnSingleClient` targets one player index and fires an `m_onSoundFinished` output when the sound ends. + +The sound-operator system itself is unusually complete — start-by-string, the 11-argument raw start, set-param-string, and stop-with-filter are all `core` with `verified`, params-complete prototypes from a single provenance. The exception is flagged loudly: `SoundOpGameSystem::StopSoundEvent` is verdict `mismatch` (measured footprint exceeds declared), so use `StopSoundEventFilter`. + +Both game-event stacks ship: the legacy `CGameEventManager` with fixed vtable getters, and the modern `CGameEventSystem` as a contiguous `verified` run (`PostEventAbstract` at 15, `PostEntityEventAbstract` at 17, register/unregister at 12/13). Bind to the concrete classes — the `IGameEventManager2::`/`IGameEventSystem::` interface aliases are all `unresolved`. Transport for custom messages is there (`CServerSideClient::SendNetMessage` is `core`/`verified`; the broadcast, channel and registry entries are `high_confidence`, several of them AI-derived names that passed live validation), but **no protobuf field layouts exist anywhere** — you get the pipe and the message id, never the payload shape. + +Voice routing splits cleanly: `CServerSideClient::IsHearingClient` (`verified`, vtable 21) is the per-listener decision hook and `CLCMsg_VoiceData` (vtable 39) the inbound handler — both `core`. Everything that would let you touch the raw voice *stream* (`IsProximityHearingClient`, `SendVoiceData`, `ProcessVoiceData`) is experimental, i.e. a guess. + +#### Performance, profiling and integrity + +A real tick profiler is buildable because both halves are present: `IGameSystem::LoopPostInitAllSystems->pEventDispatcher` is the `core` anchor, and the payloads it delivers are schema-laid-out — `EventAdvanceTick_t::m_nTotalTicksThisFrame` tells you the server ran N ticks in one frame, `EventSetTime_t::m_flRenderFrameTimeUnbounded` is the pre-clamp cost that reveals a hitch. Bring your own monotonic clock: there is no `Plat_FloatTime` in the artifacts. + +Per-entity think attribution is pure schema. `CBaseEntity::m_aThinkFunctions` is a `CUtlVector` and `thinkfunc_t` exposes the raw `m_think` function pointer, the `CUtlStringToken` naming the context, and next/last think ticks — so you can walk every entity, see which contexts are due this tick, and wrap only those. The same `m_think` pointer doubles as an integrity signal: it must land inside `libserver`'s text range. + +That is one leg of a defensive integrity monitor for the server process an operator owns. The others: 628 `core` and 1,401 `high_confidence` signatures have a wildcard-free first eight bytes, which is exactly where an inline detour lands, so prologue snapshots detect another module hooking the engine underneath you; and 705 ABI entries carry an explicit vtable index, so named slots can be snapshotted and diffed. Every locator names its owning library, so "is this pointer still in the module that owns it" is answerable per key. + +The console surface is the most mechanically reliable thing in the release. 755 of CS2's 784 registered commands carry a hookable `ConCommand::` locator with a `verified` prototype — that is *all* commands, not a diagnostics subset, though the diagnostics family within it is broad (`stats_print`, `sv_packstats` with its `clear` argument, the `vprof_*` family, `mem_dump`, `net_stats_json`, `status_json`, `lrucache_stats`, `check_nofilefd`). Hooking is the reliable direction: the artifacts give you the callback address, not the `CCommand` layout needed to synthesize a call. `logaddress_add_http` ships log fan-out to an arbitrary URI with no sidecar, and tier0 carries a complete scripted-test harness (`Test_StartScript`, `Test_LoopForNumSeconds`, `Test_Checkpoint`, `Test_ExitProcess` with a chosen exit code) that is a CI rig Valve already wrote. + +Because command flags are decoded, the client-reachable attack surface is exactly enumerable rather than folklore: **30 CS2 commands carry `client_can_execute`**, including `ent_setpos` and `ent_setang` — which move *arbitrary entities* — alongside `give`, `god`, `noclip`, `kill`, `explode`, `setpos_player`, `callvote` and `replay_start`. Exactly two carry `server_can_execute` (`echo`, `play`), which answers a question plugin authors argue about: the server cannot push arbitrary console commands to clients through the normal path. That static audit is solid, and it now extends to ConVars: their flags are decoded the same way, so `cheat`-guarded and `replicated` tunables are enumerable rather than assumed. Detecting a *runtime* change to any of those flags is a different matter — every cvar-registry accessor (`CCvar::GetConVarFlags`, `CCvar::FindCommand`, `CCvar::RegisterConCommand`) is experimental with a guessed name. + +--- + +### Dota 2 + +Dota's surface is materially larger, and the difference is structural rather than incidental: **3,528 registered entity classnames against CS2's 474**, and 2,962 schema classes / 17,695 fields against 1,899 / 12,331. The reason is that in Dota every ability and every item is a networked entity with its own class — 2,155 `CDOTA_Ability*` classnames (795 of them `special_bonus_*` talents, 1,360 regular abilities), 660 `CDOTA_Item*`, 231 unit types, 130 heroes. What that buys is identification: given any script name a mod author types, you get the exact C++ class. What it does not buy is per-ability hooking — only a minority of those classes carry fields or functions of their own; the shared bases (`CDOTABaseAbility` 54 fields, `CDOTA_Item` 63, `CDOTA_BaseNPC` 269) are where the data lives. + +The shape of Dota's coverage is also different from CS2's. Its `core` tier is narrow: 919 `CModifierFactory<…>` entries and several hundred game-system factories account for most of it, and the classic gameplay verbs a Dota modder expects are not in *that* tier. + +**They are in `high_confidence`, via the VScript registry, and that is recent.** `AddNewModifier`, `CastAbilityOnTarget`, `AddItemByName`, `ChangeTeam`, `ModifyGold`, `AddExperience` — cast, apply, give, pay, add a modifier — all fold as located names with a Valve-declared return. Earlier releases of this file said Dota's strength was observation and CS2's was invocation; that is no longer the split. What separates them now is that CS2's verbs are mostly native methods while Dota's are mostly script wrappers, which mainly changes which argument shapes you get for free. + +#### Custom game rules + +`CDOTABaseGameMode` is 110 networked fields at exact offsets, and it is recognisably the Lua `GameRules:GetGameModeEntity():SetXxx()` API re-expressed as memory: fog of war, custom XP curves (`m_nCustomXPRequiredToReachNextLevel` is a networked int vector — replace the whole curve), respawn scaling, buyback rules, the attribute-to-stat coefficients (`m_flStrengthHP`, `m_flAgilityArmor`, `m_flIntelligenceSpellAmpPercent`), per-rune-type toggles as a `bool[10]` indexed by `DOTA_RUNES`, custom shops, ability-upgrade whitelists, HUD visibility bits, camera distance and min/max attack speed. Reach it via `CGameSystemReallocatingFactory::GetStaticGameSystem` → `CDOTAGamerulesProxy::m_pGameRules` → `m_hGameModeEntity`. Four of these knobs also have typed Pulse setters that avoid raw writes. + +`CDOTAGameRules` itself is 326 fields and reads like a design document: the Roshan respawn *phase machine* is explicit (`ERoshanSpawnPhase` = ALIVE / BASE_TIMER / VARIABLE_TIMER — the variable window is a modelled state), pause has per-player budgets, and there are three distinct kinds of night with separate timers and a `HeroID_t` attributing which hero caused it. + +#### Modifiers, and the catalogue nobody else has + +919 `CModifierFactory<…>` entries sit in `core` with live-validated byte signatures — 812 `::Create`, 71 `::Destroy`, 36 `::IsSameType`, covering 826 distinct modifier classes including the Lua-backed ones (`CDOTA_Modifier_Lua`, the three motion variants, `CDOTA_Modifier_ScriptedMotionController`). The class name is not inferred; it is the template argument of a symbol Valve shipped. That gives you a complete, name-accurate index of every shipped modifier implementation plus a per-class hook point. `Create` is nullary, so hook the *return*, not the arguments. + +The vocabulary is complete too: `modifierfunction` has all 409 `MODIFIER_PROPERTY_*`/`MODIFIER_EVENT_*` values, `modifierstate` all 65 states, and `CDOTA_BaseNPC::m_nUnitState64` is a `uint64` — one read decodes stunned/silenced/rooted/hexed/disarmed/magic-immune for any unit. `CDOTA_Buff` is 38 fields including `m_hScriptScope`, the handle back into the Lua object. + +The wall used to be that nothing could APPLY one. **The VScript registry breaks it:** `AddNewModifier` folds as a `high_confidence` locator with a Valve-declared return, alongside the rest of the script-facing verb set — `AddItem`, `AddItemByName`, `CastAbilityOnTarget`, `CastAbilityNoTarget`, `ChangeTeam`, `AddSpeechBubble`. None of these existed at any tier before it landed. They are the script WRAPPERS rather than the underlying C++ methods, which is the right target anyway: their argument shapes are the ones Valve declared for a content author to call safely. + +What is still missing is the read side of the same surface. `RemoveModifierByName` is not in the registry either, and `CDOTA_ModifierManager` still exposes only 7 of its 904 bytes — no vector of active buffs. So you can hook creation, read a buff you hold, and now apply one; you still cannot enumerate a unit's modifiers, except through the debug command `dota_modifier_test `, whose handler is `verified`. + +#### Match telemetry + +`DataTeamPlayer_t` is 96 fields and splits gold 23 ways — hero kill, creep, neutral, summon, bounty, Roshan, building, courier, ward kill, ability, deny, comeback, income, shared — matching the 23-value `EDOTA_ModifyGold_Reason` enum one for one, with the four spending buckets and `m_iGoldLostToDeath` beside them. `CDOTA_PlayerResource` adds `m_playerAbilityUpgradeOrder` as `AbilityID_t[25][24]` and `m_playerAbilityUpgradeTimes` alongside it — the complete skill build for every slot *with timestamps* — plus a 24×24 hero-damage matrix and a 24×24 assist matrix. This is replay-parser-grade data available live from schema offsets. + +The engine also publishes things people normally reconstruct from replays: `m_fCreepDistanceSafe`/`Mid`/`Off` are per-team lane-equilibrium floats refreshed on their own timer, `m_flAvailableLaneGold` is a lane gold pool, and `CDOTAGameRules::m_hEnemyCreepsInBase` is literally a handle vector of creeps in your base. `CDOTA_NeutralSpawner` records `m_iStackingCreditPlayerID` and a per-team `m_bSeenClearedByTeam`, so camp analytics needs no heuristics. Every creep death carries `m_flTimeOfDeath`, `m_vWsKillOrigin` and `m_vWsKillDirection`. + +Reading was the strong direction until the VScript registry landed; the economy is now writable. `ModifyGold`, `ModifyGoldFiltered` ("gives this hero some gold, using the gold filter"), `SetGold`, `SpendGold` and `AddExperience` are all located, as are the passive knobs — `SetGoldPerTick`, `SetGoldTickTime`, `SetStartingGold`, `SetLoseGoldOnDeath`, `SetMinimumGoldBounty` / `SetMaximumGoldBounty`. Better than a mutator, the FILTERS are exposed too: `SetModifyGoldFilter`, `SetModifyExperienceFilter` and `SetExecuteOrderFilter` install a script callback the engine consults, which is interception rather than a race with the engine's own bookkeeping. Only the experimental `CDOTATurboGameMode::FilterModifyGold` was reachable before. + +#### Map, encounters and scripting + +`CDOTA_ScriptedSpawner` has a 22-method Pulse API — `SpawnNPC`, `SetNPCType`, `SetCustomNPCName`, `SetHealth`, `SetInvulnerable`, `SetNPCWaypoint`, `UseAbility`, `SetAutomaticallyRespawn` — backed by an 18-field entity with three IO outputs (`m_OnAllUnitsKilled`, `m_OnUnitKilled`, `m_OnHealthLow`). Around it: `CDOTA_MapTree_API` cuts and regrows individual trees, `CDOTA_SimpleObstruction_API` toggles blockers whose schema separately controls FoW-blocking versus nav-blocking, `CDOTA_BaseNPC_API` issues movement orders and speech bubbles, `CDOTA_BaseNPC_Building_API` pushes invulnerability refcounts. That is a fairly complete undocumented encounter-scripting system, and the whole map's tree state is one `uint64[256]` bitfield — 16,384 trees in 2 KB. + +The Pulse registry is self-documenting: all 500 Dota bindings are typed with parameter names and, for many, Valve's own English description read out of the binary. Note the tier is per-game, though — Dota's Pulse *runtime* entry points (`CPulseSystem::CreateInstance`, `CPulseGraphInstance::Unserialize`, `CPulseTypeManager::FindTypeByName`) are all experimental, where CS2 has `core` equivalents. The same applies to `CGameEntitySystem::AddEntityIOEvent`: `core` in CS2, experimental in Dota. Tiers are per-game, so check the tier in the artifact for the game you are targeting — a shared engine symbol can be first-class in one and a guess in the other. + +`CLuaVM` comes out as a near-complete `IScriptVM` map — vtable slots 0 through 63, with `RegisterFunction`, `SetValue`, `CreateScope`, `LookupFunction`, `ExecuteFunction` and `RegisterScriptClass` all `verified` — so a native plugin can compile and run Lua into a live custom game, register C++ functions into the addon namespace, and redirect script output. Several slots carry an honest `mismatch` verdict (`GetRootTable`, `CreateTable`, `RegisterInstance`, `CScriptManager::CreateVM`): the slot index is good, the declaration is not. And `CBaseEntity_SharedAPI` exposes `RunScriptCode`, `CallScriptFunction` and `CallGlobalScriptFunction` as Pulse methods, so the two scripting systems bridge in both directions. + +For test rigs, all 107 `dota_*` commands share one `verified` prototype and a validated handler address, so a single ~20-line detour shim covers the whole rules console surface. 67 Dota commands carry `client_can_execute` with no cheat bit — including `dota_create_unit`, `dota_create_item`, `dota_spawn_creeps`, `dota_spawn_neutrals` and `dota_treerespawn` — which is simultaneously a modding shortcut and a server-hardening checklist. + +--- + +### What the schema and prototypes add + +A flat offset dump cannot do any of the following, and each one is a real failure mode without it. + +**`bases` makes inherited fields reachable at all.** `CCSPlayerPawn` declares 104 fields and *none* of them is health, team, life state or move type. Walking the base chain to `CEntityInstance` flattens it to 297 and puts `m_iHealth` at 1456, `m_iTeamNum` at 1572, `m_lifeState` at 1464. The same walk turns a map classname into a field table: `trigger_multiple` goes from 1 own field to 158 flattened. + +**`bases` is also the only place multiple inheritance is expressed.** Treating a `CEconEntity` as `IHasAttributes` requires adding 3,136 bytes; for `CChicken` it is 3,728. In Dota, 16 ability classes carry a second base at +2144 — `CDOTA_Ability_Morphling_Waveform` and friends inherit `CHorizontalMotionController` there, `CDOTA_Ability_DataDriven` inherits `CDOTA_ActionRunner`. A naive `(Base*)ptr` cast at any of these sites corrupts memory silently. + +**`enums` recovers field width, not just readability.** 812 CS2 fields report `size: 0`; the enum's own size is what makes them decodable. `CBaseEntity::m_MoveType`, `m_nPreviouslySetMoveType` and `m_nActualMoveType` sit at 1491/1492/1493 and are only three consecutive `u8`s because `MoveType_t` is one byte wide. Beyond that, 524 CS2 enums / 710 Dota give you the legal-value tables — damage-type bitmasks, hit groups, observer modes, and on Dota the entire gameplay vocabulary. + +**`types` gives size and SysV class.** Size turns every generated accessor into a bounds check (12,331/12,331 CS2 fields pass). SysV class is what stops a struct-return call from corrupting the stack: a 12-byte `Vector` comes back in XMM registers (`sse`), a 48-byte `matrix3x4_t` through a hidden pointer (`memory`). That is what makes `CBaseEntity::GetEyePosition` callable correctly. + +**A field's `name_hash` is stable across builds *and* across games.** 10,363 `Class::field` pairs exist in both artifacts; all 10,363 have identical hashes, and 2,589 of them sit at different offsets. So ship one hash-keyed table of the fields your plugin touches and bind offsets per build and per game at load. A hash that vanishes means a rename; a hash that moves means a rebind. + +**A checked prototype is worth more than a declared one, and the verdict is the product.** `verified` (2,158 CS2 / 2,837 Dota) means declared arity matches the footprint measured in this build. `lower-bound` (92/99) means the declaration passes registers the callee never reads — compatible, but not the same claim. **`mismatch` (84/45) is the most immediately useful of the six**: it names community-circulated prototypes that are wrong for this binary and will load the wrong registers. `ambiguous` lists the surviving overloads for you to separate; `return-only` gives a return type and no arity claim; `unverified` means nothing checked it. + +Two structural cross-checks come for free: all **226 CS2 entity outputs agree exactly with netvars** on class, member and byte offset, independently derived; and for all 759 CS2 commands present in both files, the dispatch form in `bindings` agrees with the prototype in `abi` — 674 `direct`, 81 `member` (extra leading `this`), 4 `interface`, zero disagreements. Hooking a member-form command with the free-function signature shifts every argument by one, and nothing in the command's name tells you which it is. + +--- + +### The experimental band — read this before using any of it + +`experimental` is 4,374 entries on CS2 and 5,817 on Dota, and it is a different kind of artifact from everything above. + +**Resolvable locator. Unverified name. Never live-validated.** Every entry has `validated: null`, `corroboration: bare` (one source, nothing independently agreed) and `self_named: false`. What is real is the *locator* — an RTTI class plus vtable slot, or a byte signature — and the *measured register footprint*, which every entry carries. What is a guess is the label. 270 CS2 / 355 Dota entries carry `collision: true` (another guessed name resolved to the same target) and 42 / 130 carry `dead_weight: true` (the target is a stub). + +The two games' bands are not the same product. CS2's is 3,230 vtable locators across 914 RTTI classes plus 1,144 byte signatures across 21 libraries — and **zero in `libserver`**. It is engine infrastructure: `CPhysicsBody`, `CVPhys2World`, `CEngineServer`, `CServerSideClient`, `CNetChan`, `CCvar`, `CSchemaSystem`. If the names are right, that is a whole telemetry, physics and cvar surface — `CNetChan::GetAvgLatency` at slot 11 measures `{int:1, ret=float}`, which is at least the shape of a `float GetX() const`. If they are wrong, you have called a numbered slot with the wrong idea of what it does. Anyone hunting there for an unnamed `CCSPlayerPawn` method will not find it. + +Dota's band *does* reach gameplay: 2,040 byte signatures in `libserver`, roughly 350 of them DOTA-named — `CDOTAGameRules::KillCreeps`, `CDOTATurboGameMode::FilterModifyGold`, `CDOTA_Ability_*::OnSpellStart`. If those names are right it is a gold mine for custom-game work. Treat every one as a hypothesis. + +One sub-band is self-checking, which makes it usable on different terms: the `CNetMessagePB` template instantiations bake a wire id, a protobuf class name, a signon group and a reliability flag into the mangled name. Unlike a bare `CFoo::Bar` guess, that is structured data you can falsify against live traffic in one command (`net_listallmessages`, `net_messageinfo`). Note that for Dota the *authoritative* message-id source is not this band at all — it is the schema enums `EDotaUserMessages`, `EBaseUserMessages` and `EDotaClientMessages`, which are deterministic. Use those for ids and the templates as corroboration. + +The only defensible workflow for anything in this band: pick a candidate, check the measured footprint matches the semantics you expect, then confirm behaviour in-engine yourself before shipping. + +--- + +### What is not covered + +- **ConVars ship names, help and flags — but no defaults or ranges.** The default value is built in a stack structure at the registration site rather than passed as a literal, so it is not recoverable the way the rest is. `min`/`max` likewise. If you need the shipped default, read it off a running server. +- **No protobuf field layouts.** You get message ids and class names; you must supply the `.proto` definitions. +- **No game-event name tables.** The event *system* is there (post, register, the legacy bridge); the names (`player_death`, `dota_player_gained_level`) are not. On CS2 the practical substitutes are function-level equivalents and `logic_gameevent_listener`, which needs only a string. +- **No content names.** No `.vpcf` particle systems, no sound events, no model paths, no Dota KeyValues gameplay data (no ability special values, no hero base stats, no item costs). +- **Server-side only.** Neither game's artifacts contain a `client` library. No Panorama, no client prediction, no client-side anticheat surface. +- **Linux x86-64 only.** Every signature object carries exactly `{library, linux}`. +- **Some struct types are named but not laid out** — `CMoveData`, `CUserCmd`, `Ray_t`, `trace_t`, `InputData_t`, `Variant_t`, `EmitSound_t`, `SpawnGroup_t`. They appear in verified prototypes; you can pass pointers through them and cannot construct or inspect them from these files. +- **Bitfield netvars are unusable.** 52 CS2 / 122 Dota fields typed `bitfield:N` all report offset 0 and size 0 — the name is there, the location is not. +- **Nothing marks a field as networked.** A field entry is `{offset, type, kind, size, name_hash}`; there is no replicated/server-only distinction, so send-table-aware tooling is out of scope. + +--- + ## How it works Six stages: **read → derive → locate → measure → validate → emit.** The organising distinction, which everything else hangs off: @@ -80,6 +283,15 @@ ELF parsing is by hand. Three things make a stripped binary readable at all: On top of that sits a whole-binary **cross-reference index**: for every referenced address, the instructions that reference it. That gives the string-anchored locator ("which function uses this string?"), which several later stages depend on. +**"Which function" is an attribution, and it is only as good as the entry list.** Nearest-entry-at-or-below is +how an instruction is credited to a function, and CS2 strips `.eh_frame` from the game code, so a +`[entry, next_entry)` range routinely spans a real function plus unindexed neighbours and inherits their +strings. Anchor RECOVERY — using an anchor to locate a function that no byte-signature found — therefore +applies the same test anchor DERIVATION does: every instruction that loads the string must fall inside the +candidate's own flow-reachable code, walked from its entry. On CS2 that rejects 38 of 476 recoveries; on +Dota, whose FDEs span the whole `.text`, it rejects 4. The asymmetry is the point — the test fires where the +attribution is genuinely weak and stays quiet where it is not. + All Source-2 `.so` files link at vaddr 0, so a runtime address is simply `load_base + file_vaddr`. ### 2. Derive from the binary's own reflection @@ -88,9 +300,9 @@ Valve compiles two reflection systems into every module, and both are read direc **RTTI** gives the type hierarchy and vtable layout: which classes exist, what they inherit, and the ordering of every vtable. Where a slot is read *directly* — the fold's offset locators and the experimental band — a slot index is a fact, not a guess. -**SchemaSystem** gives class → field metadata. Be precise about what is static here: **name and offset are in the file; the TYPE is not.** A field's type pointer is a null placeholder on disk and is populated only at runtime, which is why typed netvars require a live process and why an offline run ships no `netvars-.json` at all. +**SchemaSystem** gives class → field metadata. Be precise about what is static here: **name and offset are in the file; the TYPE is not.** A field's type pointer is a null placeholder on disk and is populated only at runtime, which is why the typed schema requires a live process and why an offline run states `"schema": null` instead. -### 3. Names Valve ships in the binary — three sources, and only two locate +### 3. Names Valve ships in the binary — four sources, and only three locate Every Source-2 module names some of its own functions. This is ground truth from the shipped binary — not inference, not cross-game transfer — so it outranks every derived name, and it re-derives on every build with no input to maintain and nothing to bootstrap: the source travels with the binary. @@ -98,9 +310,26 @@ Every Source-2 module names some of its own functions. This is ground truth from |---|---|---| | **entity-IO datadesc** | the C++ handler name (`InputKill`) with the handler's address | **yes** | | **console-command registration** | the command name (`bot_add`) with its callback | **yes** | -| **Pulse binding registry** | a qualified `Class::Method` with display name, description, call policy and a full typed signature | **no** | +| **VScript binding registry** | a script-facing name (`TakeDamage`) with a C++ name, an English description, a return type and the implementation | **yes** | +| **Pulse binding registry** | a qualified `Class::Method` with display name, description, call policy, a full typed signature and an invocation shim | **not as a C++ symbol** | -**The Pulse registry does not locate anything, and the mistake is instructive.** Its records carry two code pointers, which an early pass folded as locators for a headline `+782` names. They are *descriptor accessors* — every CS2 `libserver` binding measures the same empty `int=0 float=0` footprint, and they disassemble to a lazy-init singleton that returns a static vector. Folding them would have shipped `CBaseEntityAPI::GetAbsOrigin` pointing at a zero-argument accessor: a locator that resolves, passes live validation as executable code, and is still the wrong function. The honest yield from that table is zero locators — and a complete typed API surface, which ships separately as `bindings-.json`. +**The VScript registry is the fourth, and it is the only one that states a RETURN TYPE.** Valve exposes a subset of the C++ surface to script — Lua in Dota's custom games, a smaller set in CS2 — and each exposed method is registered with a descriptor carrying both names, Valve's own prose, a `ScriptDataType_t` return and a pointer to the implementation. That is a locator, a prototype and documentation in one record. + +It is not a table walk, for the same reason the Pulse signatures are not: **the descriptors are built at runtime and are zeroes on disk.** A scan of Dota's `libserver.so` finds 2,268,664 `R_X86_64_RELATIVE` relocations and not one points at a description string. What is static is the code that fills them in, so the same answer applies — constant-propagate the initialiser rather than read the table. Three distinct registration forms are recovered: a packed pair of name pointers, a single string duplicated when both names are the same, and a record base copied between registers mid-construction. + +The return-type decoding is DERIVED rather than assumed. An early reading fitted two observations to Source 1's historical `FIELD_*` ordering and was wrong; joined against 389 bindings whose return type Valve's published dump states, `5` is `int` and `6` is `bool`. The raw word ships beside the decoding regardless. + +**It is very nearly disjoint from everything else here, and the exceptions are measured rather than assumed.** On Dota not one of the 1,652 implementations shares an address with an existing catalogue entry, and no name is shared either — a `Script_TakeDamage` is a script-facing WRAPPER, a different function from the `TakeDamage` it wraps. **On CS2 twelve are not wrappers**: `SetAbsOrigin`, `SetAbsVelocity`, `ScriptSetAbsAngles`, `Script_SetModelScale` and eight others are bound straight to the native method, so they land on an address the catalogue already names. That is a fact about the two games' bindings rather than a defect — where a native signature is already script-callable, Valve binds it directly — and both names now ship, each [declaring the other as an alias](#functions--one-record-each) instead of appearing as two unrelated functions. + +An earlier revision of this section generalised the Dota measurement to both games and said the surface was disjoint outright. It is not, and the alias field is how a consumer sees where. + +A C++ name registered at more than one address is a different case and is still dropped rather than guessed (2 of 1,650 on Dota, 0 on CS2), the same rule the ambiguous datadesc handlers follow. + +**Two of the Pulse record's three code pointers do not locate anything, and the mistake is instructive.** An early pass folded the pair at `+24`/`+32` as locators for a headline `+782` names. They are *descriptor accessors* — every CS2 `libserver` binding measures the same empty `int=0 float=0` footprint, and they disassemble to a lazy-init singleton returning a static vector. Folding them would have shipped `CBaseEntityAPI::GetAbsOrigin` pointing at a zero-argument accessor: a locator that resolves, passes live validation as executable code, and is still the wrong function. + +**The third pointer, at `+72`, is a real entry point** — one per binding, never shared. It is not the bound C++ method and cannot be folded as one (that method's address is genuinely unrecoverable offline; the shim dispatches indirectly). It is a fixed-signature marshalling stub, and calling it *invokes the binding*. That is verified by doing it: `SetRenderAlpha` and `SetRenderColor` were called on a live CS2 server and moved the entity's `m_clrRender`, and a `SetRenderColor` on Dota set the RGB bytes while leaving the alpha byte untouched — proof that dispatch honours the binding's DECLARED `PulseValueType_t`, so a caller cannot smuggle a mistyped argument past it. Every eligible binding is re-checked on each derive by calling it with a sentinel handle (see [the standing oracles](#the-standing-oracles)). + +So the honest yield from this table is **zero C++ symbol locators, a complete typed API surface, and a callable entry point per binding** — all of which ship under `surfaces.pulse`, with `call.needs` stating what a host must supply for each. **The datadesc handlers are class-qualified** by joining each record's array against the SchemaSystem: a datadesc array also carries field descriptors, and a `(member, offset)` pair is something the schema states from an entirely different table, so the class whose schema satisfies every pair in the array owns it. 653 of 715 CS2 handlers qualify this way. This is what makes `InputEnable` — a distinct handler on 48 classes — nameable at all; unqualified names that resolve to several addresses are still **dropped, not guessed**. Note for consumers: qualification **renamed 343 shipped keys** (`InputActivateSkybox` → `CAmbientGeneric::InputActivateSkybox`). @@ -136,7 +365,7 @@ So each function's observable **SysV-AMD64 shape** (which argument registers are The footprint is a deliberate **lower bound** — a callee that ignores an argument reads fewer registers than it is passed — and that is checked rather than asserted. Valve's entity-IO datadesc declares hundreds of independent handlers to one fixed prototype, and every one measures within it: **CS2 715/715, Dota 624/624**, on every derive. -Types cannot be recovered from a stripped binary, so `abi-.json` joins *declared* prototypes to that measurement and judges each one. See [the manifest](#abi-gamejson--declared-prototypes-judged-against-this-build). +Types cannot be recovered from a stripped binary, so each record's `prototype` joins a *declared* prototype to that measurement and judges it. See [the verdicts](#prototype--declared-types-judged-against-this-build). ### 6. Validate — against a live server, not a spec @@ -164,9 +393,19 @@ The contract is blunt: **"degrades or stops loudly, never lies."** An entry live | `core` | derived and, in a full run, live-validated — the load-bearing gamedata | | `high_confidence` | names folded in as verified offsets/sigs — Valve's own in-binary sources (`valve-table` provenance, ground truth) first, then macOS ground-truth transfer, dictionary-exact, and gated extrapolation | | `experimental` | the least-filtered band — every graded name guess, each with a **resolvable locator** but an **unverified name**. **Never live-validated.** | -| `unresolved` | catalogued but not confidently produced this build, with a closed-vocabulary reason (`sig-drifted`, `offset-low-conf`, `unresolved`, `abi-drift`) and no locator | +| `unresolved` | catalogued but not confidently produced this build, with a closed-vocabulary reason (`sig-drifted`, `offset-low-conf`, `unresolved`, `abi-drift`, `name-contradicted`) and no locator | -A function that couldn't be derived this build shows up as `unresolved` with a reason — it never just disappears. +A function that couldn't be derived this build shows up as `unresolved` with a reason — it never just +disappears, and that is now a checked property rather than a habit: after every pass, whatever the catalogue +named and no locator or flag accounts for is swept into `unresolved` with a reason naming which of the three +things went wrong. Measured on the current builds, `core + high_confidence + experimental + unresolved` +accounts for **1,601 of 1,601 CS2 catalogue names and 2,131 of 2,131 on Dota**. + +The reason matters as much as the presence, because most of what the sweep catches was never a function: +86 CS2 names and 193 Dota ones carry only an `offset` variant (a raw member offset this tool does not +derive) or name no library to search — the catalogue is harvested from other people's dumps, and a dumper's +own JSON keys (`build_number`, `dwEntityList`, `attack`) arrive looking exactly like function names. +Reporting those as "functions we failed to locate" would trade one silence for a louder untruth. **Naming is not derivation.** AI-assisted name extrapolation exists but is producer-side dev tooling, not part of the shipped deriver; every proposed name is gated on self-naming or ground-truth corroboration and then live-validated. A wrong *name* mislabels a real slot; it never touches the **offset**, which comes from RTTI. @@ -187,14 +426,22 @@ A `produce` run **aborts rather than publish** a collapsed artifact. Each surfac | entity-IO records | inputs + outputs | | | entity classnames | factory-record count | | | console commands | recovered-command count | the registrar is found by SHAPE, so a reworked constructor yields **zero** commands rather than wrong ones — correct, and invisible without this | +| host-callable Pulse shims | count of `call.needs == "args-only"` | the registry can read perfectly and every signature recover perfectly while a codegen change makes each shim appear to read another argument — retiring the one callable tier without failing anything | +| ConVars | recovered-convar count | found by a DIFFERENT test than commands — convergence of registrar wrappers on a shared core, not a sentinel in the callee — so it can collapse while commands keep working | +| VScript bindings | recovered-binding count | a THIRD identification test again: a record base computed by the initialiser's own `idx*5 << 4 + [class+0x28]`. The floor is set deliberately loose because the reader recovers three distinct registration forms, and losing any ONE of them would still clear a tight floor while quietly dropping a third of the surface | +| VScript owning classes | attributed-binding count, **full runs only** | the one floor an offline run skips rather than fails, because zero is correct there by construction — the class is live-only. It is separate from the row above because it fails in the opposite direction: that floor guards the offline READER against a Valve reshape, this one guards the LIVE WALK, and the walk breaking leaves every binding recovered, described and located with no class on any of them. `class` is what `gen`'s `moddota` format groups by, so the release would clear every other gate while both renderers emitted nothing | | typed netvars | fraction of fields typed | a runtime type-layout reshape resolves every field "untyped" and would otherwise ship a typeless schema at exit 0 | | schema enums | enum count | read by shape like the class table, so a reshape yields zero rather than wrong | -| live validation | pass rate, above a minimum sample | | +| schema classes | class count | the largest table, and the one every other schema claim rests on — the `schema` section itself, the entity-output and datadesc joins, the derived type layouts, and half the identity check's conjunction. Nothing else covers it: the enum floor passes at zero classes, and the live oracle's own class gate is SKIPPED below its minimum sample, which is the collapse range | +| derived functions | `core` + `high_confidence` count | the headline product, and the one place a pass-RATE gate cannot help: the live oracle scores entries that reached the gamedata document, and a signature that failed to resolve never enters it — so a derive emitting forty functions instead of four thousand passes at 100% | +| live validation | pass rate, above a minimum sample | covers the derived locators too, not only the Valve-table oracles: the stage judging the primary product used to print its tally and discard it | ### `validated` is three-valued `true` / `false` / `null`, and `null` is not a synonym for failure. Three cases ship `null` legitimately: the library is not mapped in the vanilla server, the class is not a vtable class (an engine special or a carried member offset), or the entry has no locator to check. An **offline run ships the whole monolith `null`** — absence of validation, not failed validation. Treat `null` as "not checked here", never as "checked and passed". +**`true` means every locator the entry carries was checked, not the first one found.** An entry may hold a signature *and* a vtable offset — five CS2 `core` entries do — and each is a separate claim about the running server. Both are validated; the entry is dropped if either is confidently bad; and if any half went unchecked the whole entry degrades to `null` rather than letting the checked half vouch for the other. That last rule is the one that matters to a hooking consumer: those offsets ship into ModSharp's `VFuncs` and Metamod's `Offsets`, where a wrong slot is what crashes a plugin. + ### The standing oracles A dozen free, mostly two-sided checks run on **every** derive and are reported. Two-sided means the two halves are read from different places by readers that don't know about each other, so agreement is evidence and disagreement is a defect: @@ -206,16 +453,41 @@ A dozen free, mostly two-sided checks run on **every** derive and are reported. - **entity-output ↔ schema join** — 226/226 CS2, 186/187 Dota. - **EHANDLE class grouping** — Valve's naming vs the binary's destructor addresses: 0 of 44 CS2 / 41 Dota groups carry two classes. - **Pulse element stride** — derived by consensus per image, unanimous across six libraries in both games. -- **live schema oracle** — offline layout vs the running process: 852/852 CS2, 1,912/1,912 Dota. +- **live schema oracle** — offline layout vs the running process: 852/852 CS2, 1,916/1,916 Dota. Note the population: this reads `libserver` alone, where the release floor counts the union across every mapped library (1,899 / 2,962). Two different numbers for two different questions. +- **Pulse shim invocation** — the only *behavioural* oracle here: every binding the artifact calls `args-only` is invoked on the live server with a sentinel entity handle, which the engine's own resolve rejects before touching anything. CS2 **67/67 clean**. It verifies a claim the artifact makes rather than a value it reports, and it is safe to run in CI precisely because the sentinel path mutates nothing — every argument slot the measurement calls unused is passed as null, so a slot that is actually used faults, and a fault is caught and the thread restored. +- **Pulse descriptors, against the live ones** — the reconstruction check. A binding's typed signature is *constant-propagated out of an initialiser*, not read from data: the elements are written at runtime and are zeroes on disk. So the shipped `params` were, until this landed, an unverified inference. The oracle reads what the running server actually holds and compares: **383/383 on `libserver` and 155/155 on `libpulse_system`, with returns 139/139, zero disagreements.** The trick is that the regions are lazy-init singletons a normal match never populates — a standard game executes no Pulse graph — so the oracle *calls the accessor first*. Those are the same `+24`/`+32` accessors the fold refuses to treat as locators: nullary, `int=0`, body builds a static once. Worthless as locators, and exactly what makes this check possible. - **field-gap size calibration**, the semantic call sweep, and a 500-iteration live fuzz. -One of these found a real defect on its first run: 34 of 715 handlers measured float arguments a `void(ptr, ref)` cannot have, which traced to the ABI reader treating a `call` as fall-through so a callee's *return* propagated backwards as a phantom argument. +**One of these is not like the others, and it is the newest: the IDENTITY check.** Every oracle above verifies that a locator *resolves* — that the address is real, the slot is real, the declaration matches the measurement. None of them asks whether it resolves to the **right function**, and a wrong locator passes all of them: the address holds real code, so live validation confirms it; the pattern is unique in its library, so the scan is clean; and if the impostor happens to take the same number of arguments, the ABI verdict reads `verified`. + +So one check asks the other question, from two things the binary states about an address and a name that is a `Class::Method`: + +- **Valve's VScript registry names the address something else.** Ground truth — the binary naming its own function. +- **The code operates on a different class.** A `CFoo::` method reaches its object through `this`, so every `this + N` it touches must satisfy `N < sizeof(CFoo)`, and the SchemaSystem states that size offline. + +**Both must hold, and the conjunction is the whole design.** Either alone rejects good entries, measured rather than supposed: a dozen CS2 bindings are bound *straight* to the native method instead of through a script wrapper, so `SetAbsOrigin` and `CBaseEntity::SetAbsOrigin` legitimately share an address (as do `ScriptSetSize` and `CBaseModelEntity::SetCollisionBounds`, whose names do not even resemble each other); and separately, six entries reach past their class because their NAME carries the wrong prefix while the locator is fine — four `CPathMover::` entries that are really `CFuncMover` setters, two `CBasePlayerController::` that are really `CCSPlayerController`. All eight of those still ship. + +Across the ~3,980 CS2 entries that resolved before it ran, the conjunction fires **once**, and that one had shipped in a release: `CBaseEntity::DispatchTraceAttack` resolved to `CLogicRelay::Trigger`. It now ships as `name-contradicted` instead of as a locator. Because n=1, it refuses the entry rather than failing the release. + +**It runs where the model LEARNS, not only where the artifact is written**, and that placement is the point. The same locate step feeds the incremental fold and the distill, so a check applied only at emit time would leave the model recording the impostor's fingerprint — and the strict fingerprint check would then *confirm* the wrong address on the next build. That is exactly how this entry survived: the model had learned the decoy, so the guard that should have caught it vouched for it instead. + +That sentence described the design before it described the code. The fold-path call passed the library's FILE name to a map keyed by its SHORT one, so the lookup missed, the `?` returned, and the check silently passed on every call — while the line four below it applied the very normalisation the lookup omitted. It was dead on the one path the paragraph above says matters most, and the shipped model carried **eight** fingerprint observations plus a consensus ABI for `DispatchTraceAttack` — the wrong function's, `Trigger(hActivator, hCaller)`'s `int=3`. Re-distilling with the check live removes exactly that one name and nothing else. + +Worth stating precisely, because the honest version is less dramatic than it sounds: the contamination was **latent, never active**. The emit-time check rejected the entry regardless of what the model held, so a derive against the contaminated model and one against the clean model produce byte-identical artifacts. What the dead guard cost was not a wrong locator today but a loaded one tomorrow — had the conjunction's other half ever drifted (Valve renames the binding, the class size moves), those eight observations were sitting ready to confirm the decoy as correct. + +The `this`-tracking is deliberately conservative — a register stops holding `this` on any write that is not a move from another register already holding it, all caller-saved registers drop across a `call`, and a path merge keeps only what holds on both paths — so the error direction is a missed contradiction, never a false accusation. + +Two of these have found real defects. The entity-IO ABI check, on its first run: 34 of 715 handlers measured float arguments a `void(ptr, ref)` cannot have, which traced to the ABI reader treating a `call` as fall-through so a callee's *return* propagated backwards as a phantom argument. And the descriptor oracle settled a question the multi-library duplicate check had been reporting with no way to resolve — for every binding it can read, the two libraries' accounts are identical and both match the live descriptor, so the reported disagreement is not in the parameter or return lists. ### What is NOT gated -Stated because "we check things" is worthless without a boundary. There is **no** floor on the validate-live drop rate, the live-fuzz fault rate, the schema class count, or the RTTI class / base-graph size. A regression in any of those is reported, not refused. +Stated because "we check things" is worthless without a boundary. There is **no** floor on the live-fuzz fault rate or the RTTI class / base-graph size. A regression in either is reported, not refused. -**One oracle is currently reporting.** The Pulse registry is keyed by qualified name, so a binding registered by several modules keeps one row, and every duplicate is compared against the row already present. On the current builds **CS2 flags 331 of 419 repeat registrations and Dota 271 of 359** as disagreeing — so for those names `bindings-.json` carries one module's account of the signature, not a merged one. It is flagged on every run and is not yet resolved; if you consume `params`/`returns` for a multiply-registered binding, know that. +The list used to be longer. The validate-live drop rate, the schema class count and the derived function count were all ungated and are now floored — see the table above. They are called out here rather than quietly removed because the gap they left was structural rather than an oversight of three numbers: **every gate measured what was emitted, never what failed to be emitted**, so a collapsed derive scored 100% on a shrinking denominator. + +**One oracle is currently reporting.** The Pulse registry is keyed by qualified name, so a binding registered by several modules keeps one row, and every duplicate is compared against the row already present. On the current builds **CS2 flags 331 of 419 repeat registrations and Dota 271 of 359** as disagreeing — so for those names `surfaces.pulse` carries one module's account of the signature, not a merged one. It is flagged on every run and is not yet resolved; if you consume `params`/`returns` for a multiply-registered binding, know that. + +*Which* module's account it carries is now the highest-precedence one, matching the rule `GameProfile::libs` states and every sibling table in that fold already followed — the earlier library wins, with one exception: a later library that recovered a typed signature replaces an earlier one that did not, since precedence must not cost information. It previously kept the LAST registration read, so 224 of 580 CS2 rows shipped another module's account of a name libserver also registers — and, because the live shim and descriptor oracles run against the server image, the rows that got verified were not the rows that got shipped. --- @@ -243,7 +515,7 @@ cargo build --release -p source2rosetta-core # → ./target/release/source2roset | `fold-model` | Roll an existing model forward by ONE build (`model N + build → N+1`), reading only the model and that one binary. The production update path (also a sidecar inside `produce`). | | `integration-test` | Stand-alone CI live oracle: launch a vanilla server, populate it, and verify derived gamedata against it — schema oracle, a semantic ptrace CALL on a live pawn, and (with `--gamedata`) a full validate-live plus optional live fuzzing. | | `backfill` | Give an extrapolated name a real cross-build timeline — resolve its string anchor in every corpus build, or chain a vtable slot through the model — and report history depth + consistency (how a guess graduates to first-class). | -| `classify-change` | `--prev`/`--new` → `skip` / `normal` / `shift` + the exact % of function bodies that changed, comparing with position-dependent bytes masked so a pure layout shift reads as unchanged. An **operator primitive** — nothing in the shipped pipeline invokes it; the poller dispatches a derive on any buildid change. | +| `classify-change` | `--prev`/`--new` → `skip` / `normal` / `shift` + the exact % of function bodies that changed, comparing with position-dependent bytes masked so a pure layout shift reads as unchanged. Enumerates functions over relocation code-pointers ∪ decoded call targets ∪ `.eh_frame` starts — the FDE list alone covers ~12% of a CS2 binary, since Valve strips unwind info from the game code and leaves it only for the statically-linked runtime tail. An **operator primitive** — nothing in the shipped pipeline invokes it; the poller dispatches a derive on any buildid change. | | `filter-corpus` | Collapse runs of code-identical builds to one representative, label each transition `normal`/`shift`, and segment the timeline into toolchain eras. Writes an **advisory** selection manifest; the distill does not read it (see [corpus curation](#getting-the-corpus-only-to-bootstrap-a-model)). | ### Quickstart @@ -255,6 +527,8 @@ Releases live on the **[releases page](https://git.lo.sh/kamal/source2rosetta/re ./target/release/source2rosetta --game cs2 produce \ --seed mappings/seed-cs2.json \ --corpus-model model-cs2.json \ + --prototypes mappings/prototypes.json \ + --semantics mappings/semantics-cs2.json \ --target \ --out-dir out @@ -263,6 +537,8 @@ Releases live on the **[releases page](https://git.lo.sh/kamal/source2rosetta/re ./target/release/source2rosetta --game cs2 produce \ --seed mappings/seed-cs2.json \ --corpus-model model-cs2.json \ + --prototypes mappings/prototypes.json \ + --semantics mappings/semantics-cs2.json \ --target \ --game-dir \ --out-dir out @@ -270,7 +546,7 @@ Releases live on the **[releases page](https://git.lo.sh/kamal/source2rosetta/re - `--target ` — the build **directory** to derive from; `produce` requires a directory and its libraries are searched by name. (Other subcommands accept a bare `.so` as well, which is how `classify-change --prev` is used.) - `--game-dir ` — must be the **`game/` subtree** of the install, the same directory layout the dedicated server is launched from. -- `--seed ` — one file bundling every derive input. The loose equivalent is `--catalogue ` plus the optional `--promotable` / `--candidates` / `--full-names` / `--extra-offsets` / `--extra-sigs`, all defaulting to empty — **so a brand-new game needs only a catalogue to start deriving.** +- `--seed ` — one file bundling every derive input. The loose equivalent is `--catalogue ` plus the optional `--promotable` / `--candidates` / `--full-names` / `--extra-offsets` / `--extra-sigs`, all defaulting to empty — **so a brand-new game needs only a catalogue to start deriving.** The two forms are mutually exclusive and the CLI says so: `--seed` supplies all six, so passing one alongside it is a usage error rather than an input silently dropped. - Corpus signal — exactly one of `--corpus-model ` (the normal path: forward-derive from the model + target binary, rolling the model N→N+1 as a sidecar) or `--corpus ` (fingerprint raw build binaries on the fly). Model-based derives are **forward-only**: the model describes history up to its newest build, so pointing one at an *older* target is not supported. @@ -352,37 +628,107 @@ A full `produce` run writes a self-contained release set per game into `--out-di | File | What it is | When | |------|-----------|------| -| `gamedata-.json` | The **monolith** — the tiered function catalogue (signatures + vtable offsets) with provenance and live-validation folded inline | always | -| `abi-.json` | The **prototype manifest** — declared parameter/return types, each judged against the footprint measured in this build | always | -| `bindings-.json` | The **declared callable surface** — what the binary says about itself: Pulse bindings, entity IO, entity classnames, console commands | always | -| `netvars-.json` | The **typed schema** — every SchemaSystem class → field → offset/type, plus the base graph and type layouts | full (`--game-dir`) runs only | +| `rosetta-.json` | **The release** — one record per function, plus the typed schema and the surfaces that are not function-keyed | always | | `model-.json` | The **per-game model** — the distilled facts derivation reads instead of the corpus | when the run folds an existing model | | `manifest.json` | Volatile release metadata: `{ version, artifacts: [...] }` | always | -Wall-clock and other volatile metadata live only in `manifest.json`; the other artifacts carry no timestamp, so they are **byte-reproducible** — the same build in yields the same JSON out. +Wall-clock and other volatile metadata live only in `manifest.json`; the release artifact carries no +timestamp, so it is **byte-reproducible** — the same build in yields the same JSON out. Verified rather +than asserted: two consecutive derives over identical inputs produce byte-identical `rosetta-.json`, +`model-.json` and `manifest.json`. -### `gamedata-.json` — the monolith +Reproducibility is a property that has to be defended at every tie-break, not only at the obvious ones. A +`HashMap` iterated to build an output is the usual culprit, but so is a *stable* sort on a key that repeats: +two libraries registering the same schema class, or one class registering a script name twice, leave the +survivor of the dedup decided by hash order. Those are sorted on a total key now. + +### `rosetta-.json` ```jsonc { - "meta": { "game_key", "game", "source_build", "version", - "counts": { "core", "high_confidence", "experimental", "unresolved" } }, - "core": { "": , ... }, - "high_confidence": { "": , ... }, - "experimental": { "": , ... }, - "unresolved": { "": { "reason", "detail" }, ... } + "meta": { "game_key", "game", "source_build", "version", "counts", "alias_groups", + "aliased_names", "merged", "joined" }, + "functions": { "": , ... }, + "unresolved": { "": { "reason", "detail" }, ... }, + "schema": { "classes", "bases", "enums", "types", "meta" }, // null on an offline build + "surfaces": { "pulse", "entity_outputs", "entity_classes", "convars", "unjoined" } } ``` -A **`MonoEntry`** is a locator flattened to the top level, plus its grading and — where the address resolved offline — its measured `abi` footprint inline. A virtual method ships as a bare integer `offset` (its RTTI vtable slot index); a non-virtual function as a `signature` object with the `library` it scans and a space-hex `linux` pattern with `?` wildcards. By deriver convention an entry carries one or the other; the readers handle the rare both-present case deterministically. +**One record per function is the whole point.** Where a function is, what its machine code was measured to +take, what a declaration says it takes, what the binary declares may be done with it, and what it means are +five different KINDS of fact about one thing — separately derived, separately trustworthy, and useless apart. +A consumer answering "may I call this, and how" needed four files open at once to find out. -`reason` on an unresolved entry comes from a closed vocabulary: `sig-drifted`, `offset-low-conf`, `unresolved`, `abi-drift`. +What is NOT function-keyed stays whole under `surfaces`: a Pulse binding names no C++ function, an entity +output is a member rather than a method, a classname binds one name to another, and a ConVar is +configuration rather than code. -Console-command handlers ship under the key **`ConCommand::`**. The prefix says what the entry *is* — the handler bound to that command — rather than claiming a C++ symbol; `ent_fire`'s real method name appears nowhere in the binary. +### `functions` — one record each -### `abi-.json` — declared prototypes, judged against this build +A **`FunctionRecord`** opens with its `tier` (`core` / `high_confidence` / `experimental`) and the locator +flattened to the top level. A virtual method ships as a bare integer `offset` (its RTTI vtable slot index); a +non-virtual function as a `signature` object with the `library` it scans and a space-hex `linux` pattern with +`?` wildcards. Usually one or the other — but **a record may carry both**, and a handful of `core` CS2 records +do, so a consumer (and the live oracle) has to judge every locator a record holds rather than the first it +finds. -Gamedata says *where* a function is; it never says what it takes. Types cannot be recovered from a stripped binary, so they come from declarations — and a declaration must be checked before anything calls through it, because a stale one produces a call that resolves, validates, and loads the wrong registers. +Two further locator keys appear where they were established: + +- **`class`** — for an `offset` entry, the class whose vtable the slot was measured on. A slot index alone + locates nothing, since it only means anything relative to a particular vtable. It is the record's own name + class, stated explicitly: the deriver keys its slot timelines and alignment hops by that class and chains + through it, so "the class chained through" and "the class in the name" are one fact. Directly folded + offsets (the multilib ground-truth path) omit it and leave the consumer to split the name. +- **`anchors`** — distinctive string literals the function references, each unique to it within its library. + Not a locator competing with the signature and the offset, but a supplement with a *different failure + mode*: a byte signature is a snapshot of one build's codegen, while a string survives a recompile that + moves instructions. Emitted alongside the signature, never instead of it. + +Then, each labelled by where it came from: + +| field | what it is | +|---|---| +| `measured` | the SysV argument footprint read out of THIS build's machine code — a lower bound, never an over-count | +| `validated` | the live-validation verdict, **three-valued** — see [below](#validated-is-three-valued) | +| `aliases` | the other shipped names for this same function | +| `provenance` | how the name and locator were arrived at, and at what confidence | +| `prototype` | the DECLARED parameter and return types, and this build's verdict on them — see [the verdicts](#prototype--declared-types-judged-against-this-build) | +| `bindings` | what the binary itself declares may be done with this function — see [below](#bindings--what-the-binary-declares) | +| `description` | what it does, in plain language, and whether that text is derived or generated | + +**`aliases` — the other shipped names for the same function, and the one key that is about the RELEASE rather +than the locator.** Several names on one function is normal here and not a defect: the catalogue is assembled +from independent sources that spell the same function differently, so `CreateEntityByName`, +`UTIL::CreateEntityByName`, `CBaseEntity::CreateEntityByName` and `CGameEntitySystem::CreateEntityByName` are +four names on one address. Dropping three of them would break whichever spelling a given consumer's code +already uses, so all four ship and each one names the other three. On CS2 that is **80 functions covering 172 +names, 4.3% of the resolved surface**; on Dota it is a single group, because that catalogue is far less of a +merge. + +Read it before treating a tier count as a function count. `counts.core + counts.high_confidence` = 3,980 is +exactly right about NAMES and describes **3,888 distinct functions**. And read it before hooking: two names on +one address detoured independently is one trampoline chain claimed twice. + +Grouping is by locator identity across `core` + `high_confidence` — a shipped pattern is generated at the +resolved address and confirmed unique in its library, so an identical `(library, pattern)` pair cannot be two +functions, and a vtable entry keys on `(class, slot)`. **Two limits, both deliberate.** `experimental` is +excluded, because a shared target between two unverified guesses is not evidence of a shared meaning (that +band states the converse relation — one name guessed at several addresses — through `provenance.collision`). +And a bare `offset` with no `class` is never grouped: it names no vtable, so two of them carrying slot 3 are +not evidence of anything. Grouping those anyway would assert 1,080 CS2 names to be aliases of each other in 70 +fictitious groups. So an entry with no `aliases` means *none was derivable*, which for a bare slot is not the +same as *none exists*. + +Console-command handlers are keyed **`ConCommand::`**. The prefix says what the entry *is* — the handler +bound to that command — rather than claiming a C++ symbol; `ent_fire`'s real method name appears nowhere in +the binary. + +### `prototype` — declared types, judged against this build + +A locator says *where* a function is; it never says what it takes. Types cannot be recovered from a stripped +binary, so they come from declarations — and a declaration must be checked before anything calls through it, +because a stale one produces a call that resolves, validates, and loads the wrong registers. **The verdict is the product**, and there are six: @@ -395,34 +741,87 @@ Gamedata says *where* a function is; it never says what it takes. Types cannot b | `unverified` | nothing to check it against | | `ambiguous` | several signatures on offer and no measurement to separate them | -Types come from three places, and `provenance` says which: a source declaration; the engine's own **dispatch contract**; or, for a return with neither, the measured register class (written `ret=…` so it can never be mistaken for a declared type — the measured class is wrong about known-void functions roughly seven times in eight). +Types come from three places, and `provenance` says which: a source declaration; the engine's own **dispatch +contract**; or, for a return with neither, the measured register class (written `ret=…` so it can never be +mistaken for a declared type — the measured class is wrong about known-void functions roughly seven times in +eight). -**Two dispatch contracts exist**, and both are stronger than any header because nobody has to have written the function down for the way the engine invokes it to be known: an entity-IO handler is invoked through `void(CEntityInstance*, InputData_t&)`; a console-command handler through the command-context and command pair, plus a receiver where the registration dispatches through an object. Which of the three callback forms a command uses is recorded at the registration site, so the contract is keyed on it rather than assumed. A contract is judged as a **lower bound** — it describes how the function is *invoked*, so only an over-count refutes it. +**Two dispatch contracts exist**, and both are stronger than any header because nobody has to have written the +function down for the way the engine invokes it to be known: an entity-IO handler is invoked through +`void(CEntityInstance*, InputData_t&)`; a console-command handler through the command-context and command +pair, plus a receiver where the registration dispatches through an object. Which of the three callback forms a +command uses is recorded at the registration site, so the contract is keyed on it rather than assumed. A +contract is judged as a **lower bound** — it describes how the function is *invoked*, so only an over-count +refutes it. -In the artifact, parameters are spelled as **pointers** (`CCommandContext*`, `CCommand*`), not as the C++ reference types. +Parameters are spelled as **pointers** (`CCommandContext*`, `CCommand*`), not as the C++ reference types. +`vtable` is present exactly when the locator is a vtable offset that live validation confirmed: a slot is only +reachable through an object, so it states a receiver no measurement can see. -`source2rosetta-gen --abi … --format ` turns this into **call sites**: typed C# fields for CounterStrikeSharp, a C++ typedef header for Metamod plugins, an `[AddressKey]` interface for ModSharp, and runtime type descriptors for Swiftly and Plugify. Both `verified` and `lower-bound` entries with a settled receiver are emitted, and every output marks the lower-bound ones. +### `bindings` — what the binary declares -### `bindings-.json` — the declared callable surface +A LIST, because one function can be several — and because a `kind` tells a consumer which it got: -What the binary *says about itself*, as opposed to what the derivation *infers about it*. Kept out of the monolith deliberately: `gamedata` answers "where is this function", this answers "what may I do with it, and how". **Five sections:** +- `entity-input` — the map-facing input name this handler answers, and the class the datadesc join qualified. +- `command` — the console name, Valve's help text, decoded flags with the raw word beside them, and which of + the three callback forms the registration used. +- `vscript` — the script-facing name a content author types, the owning class, Valve's own description, and + the declared return type. -- `pulse` — bindings keyed by qualified `Class::Method`, each with Valve's display name and description, a decoded call policy (receiver kind, mutating, blocking) with the raw words beside it, and the recovered typed signature. -- `entity_inputs` — the map-facing input name, the C++ handler, its owning class where the schema join qualified it, and the handler's **address** (these also ship as gamedata). -- `entity_outputs` — the events an entity fires and where the subscriber list lives on the instance. -- `entity_classes` — map classname → the C++ class it constructs (`func_door` → `CBaseDoor`). Names to names, no addresses. -- `commands` — console commands with description, decoded flags, the raw flags word, the callback form, the measured ABI shape and the handler **address** (these also ship as gamedata). +**A row is attached only when the record cannot contradict it.** A name is unique only within a module: +`AddOutput` is registered in three libraries as three different functions, and `cl_particles_dumplist` in two, +while the catalogue holds one entry under each name. Asserting every registration onto that one record would +be a claim about code it does not locate — so a row joins on matching library (or onto a vtable-located record, +which names no library to contradict), and the rest are stated under `surfaces.unjoined`. -**`descriptor` on a Pulse binding is NOT a locator** — see [above](#3-names-valve-ships-in-the-binary--three-sources-and-only-two-locate). Any Pulse count is a count of *registrations*, not distinct bindings. - -### `netvars-.json` — the typed schema +### `schema` — the typed schema, and it is LIVE-ONLY Every SchemaSystem class → field → offset and type, plus two sections that are easy to miss and load-bearing: +`bases`, the class base graph, without which an inherited field is unresolvable; and `types`, per-type size +and SysV register class, needed to compute a by-value argument's register cost. Of a field's attributes, +`type` and `kind` are read from the **live process**; `size` and the name hash are derived offline. -- `bases` — the class base graph. Without it an inherited field is unresolvable. -- `types` — per-type size and SysV register class, needed to compute a by-value argument's register cost. +**An offline build states `"schema": null`** — an explicit null, not an absent key, because absence would be +indistinguishable from a build that resolved zero classes. -Of a field's attributes, `type` and `kind` are read from the **live process**; `size` and the name hash are derived offline. +### `surfaces` — what is not function-keyed + +- `pulse` — bindings keyed by qualified `Class::Method`, each with Valve's display name and description, a + decoded call policy (receiver kind, mutating, blocking) with the raw words beside it, the recovered typed + signature, and — where the record carries one — a `shim` address plus a `call` block saying how to invoke + it. `call.needs` is the field to read: + - `args-only` — callable with an argument array and nothing else; the other argument slots may be null. + **Validated by calling every such binding on a live server of both games.** + - `output-sink` — it returns a value, and writes through a register-file object a host does not have. Read + the state through the `schema` section instead; the Pulse getters are redundant with schema fields. + - `pulse-context` — needs a live `CPulseExecCursor` or graph instance. Not host-callable. + - `other-slots` — reads an argument whose role is not established (the `CPulseCell_*` family, which are + graph *node* implementations rather than API bindings). Not host-callable. + + `call.reads` carries the measured slot list beside the decoding, so a build that changes the contract is + re-readable rather than silently mis-labelled. +- `entity_outputs` — the events an entity fires and where the subscriber list lives on the instance. +- `entity_classes` — map classname → the C++ class it constructs (`func_door` → `CBaseDoor`). Names to names, + no addresses. +- `convars` — the configuration half of the console surface: name, help text, decoded flags, the raw flags + word, and the ConVar object's address. Emitted for the **metadata**, not as a locator — a consumer finds a + convar by name at runtime with no gamedata at all, so the name alone would add nothing. The flags are the + payload: `cheat`, `replicated`, `archive`, `notify` are engine-*declared* authority, which is what lets a + host decide what a plugin may change without a hand-maintained allowlist. Decoded by a **convar-specific** + bit table, not the command one — see [Known limitations](#known-limitations). +- `unjoined` — declared rows that belong to no function record here, split by kind, each keeping its own + `library` and `addr`. Two things put a row here and they differ in kind: **nothing located it** (the + implementation did not resolve, or an ambiguous handler name was dropped rather than guessed), or **the name + belongs to another module's function**, as above. Keeping them is what makes the fold lossless — every row + the deriver read is either on the function it describes or stated here. + +`unresolved` sits beside `functions` rather than inside it: those names have no locator, so they are not +function records. `reason` comes from a closed vocabulary: `sig-drifted`, `offset-low-conf`, `unresolved`, +`abi-drift`, `name-contradicted`. + +**`name-contradicted` is the newest and means something different from the rest.** The others say a locator was +not *found*; this one says a locator **was** found and the binary proves it is a different function, so it was +refused. The entry needs a new locator rather than another build — see [the identity check](#the-standing-oracles). ### `model-.json` — the per-game model @@ -430,15 +829,43 @@ The distilled facts derivation reads instead of the corpus. Not a consumer artif ### Rendering — the `gen` binary -`source2rosetta-gen` takes the monolith (`--from`), the schema (`--netvars`) or the manifest (`--abi`) and renders the matching format. The **input** chooses what is rendered; the `--format` id chooses for whom. +`source2rosetta-gen --from rosetta-.json --format --out ` writes the files that +consumer reads. A framework gets **two**: the gamedata its loader resolves through, and the typed call sites +that go through it — `cssharp`, `metamod` (also SourceMod's VDF), `modsharp`, `swiftly`, `plugify`. Beside +them, `cs-sdk` / `netvars` render the schema, and `moddota` renders the VScript surface for the Dota +custom-game ecosystem — both shapes it publishes, `api.json` and `api.d.ts` — grouping members by owning class +with Valve's own description as the doc comment. + +Every published artifact renders all nine, because a release is always derived against a running server. It +is only a **locally derived OFFLINE artifact** that renders fewer: the schema is live-only and so is the +owning class `moddota` groups by, so those three have nothing to work from and `gen` says so rather than +writing an empty file. + +**The artifact states its own game and the output follows it**, so there is no `--game` flag. Two formats are +game-keyed and both key by the game DIRECTORY, which is what `meta.game_key` holds: Metamod's +`Games { csgo | dota }` section, which a plugin looks up by the engine's own `GetGameDir()`, and Plugify's +top-level key, matched against the `S2SDK_GAME_NAME` its plugin was built with. Two consumers cannot run on +Dota 2 at all — CounterStrikeSharp and Swiftly both resolve their binaries out of `/csgo/bin/` — and +`gen` declines those rather than write a file that can never load, with `--force` to override. + +**Every call site carries its description into the generated source**, as a C# XML doc comment, a C++ header +comment, or a field in the data formats — so hovering `CBaseEntity_SetParent` in an editor says what it does +instead of only what it takes. Each one states **whose sentence it is**: Valve's own, read from a registry in +the binary, or this project's reading of the build. Valve's always wins where both exist, and a generated one +only ever fills a gap. On the rendered surface that is 2,073 CS2 and 2,326 Dota call sites, 717 / 774 of them +in Valve's own words. Two things to know before you diff outputs: -- The default `cssharp` gamedata output is **JSONC** — it carries comment banners, so a strict JSON parser will reject it. -- The `swiftly` gamedata format emits **signature entries only**; vtable-offset entries are omitted (that is over a thousand entries on CS2), because that framework takes offsets through a separate file. -- The `model` format emits a tier-selected `Gamedata` with no `meta`, so its output cannot be fed back in via `--from`. +- The default `cssharp` gamedata output is **JSONC** — it carries comment banners, so a strict JSON parser + will reject it. +- The `swiftly` gamedata format emits **signature entries only**; vtable-offset entries are omitted (that is + over a thousand entries on CS2), because that framework takes offsets through a separate file. +- The `modsharp` format emits a **`refs`** block where one was derived — `refs.strings` for string anchors and + `refs.vtable` for an offset entry's class, both ModSharp's own keys. An entry with anchors and no byte + pattern is emitted as `refs`-only, which is how several of ModSharp's own hand-written entries are written. ---- +See [source2rosetta-gen](crates/source2rosetta-core/README.md) for the full format table. ## Provenance @@ -459,9 +886,11 @@ This is a publishable tool, so where declarations and names come from is a hard - **Linux x86-64 only.** SysV register classification, `/proc`-based validation and ptrace are all platform-specific. - **Dota's core leans on the unverified fallback** — 69.8% of it, against CS2's 0.4%. Those entries are marked; treat the marker as real. - **`experimental` is never live-validated.** Resolvable locator, unverified name. -- **Offline runs ship no netvars and no `validated` state**, because field types and validation both require a running process. +- **Offline runs state `"schema": null` and no `validated` verdicts**, because field types and validation both require a running process. - **Two games cannot be produced concurrently** on one host (fixed server port). - **The Pulse duplicate-registration disagreement is open** — see [What is NOT gated](#what-is-not-gated). +- **ConVar flag bits are decoded by a convar-specific table, and three bits are unnamed.** FCVAR is not one flag space across object types — decoding convars with the *command* table mislabels bit 0 on 185 Dota and 56 CS2 convars with a name Valve's own dumps give to none of them. The convar table was derived against both games' published dumps (1,939 convars pooled) keeping only bits that hold at 100% precision; bits 0, 1 and 2 are set often and match nothing cleanly, so they stay unnamed and survive in `flags_raw`. +- **String anchors cover a minority, by design.** 480 catalogued + 77 derived on CS2, 103 + 22 on Dota. Two conditions do the filtering: an anchor names a *function*, so an entry whose locator points mid-function (a hook site rather than a prologue) gets none; and the string must be referenced only from inside that function. Most shipped functions reference no string unique to them, which is the real ceiling — 859 of 1,505 CS2 candidates fail on that alone. - **Some declared returns are decided by source order.** Where sources disagree on a return type, the untrusted source is ranked last, but among the trusted ones the order is the order they were merged. A handful of names are settled that way, which is stated rather than papered over. --- diff --git a/crates/source2rosetta-core/Cargo.toml b/crates/source2rosetta-core/Cargo.toml index 4fd4f2b..61a47d4 100644 --- a/crates/source2rosetta-core/Cargo.toml +++ b/crates/source2rosetta-core/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "source2rosetta-core" -version = "2.0.0" +version = "3.0.2" edition = "2024" description = "source2rosetta's deriver-free core: canonical gamedata model + format emitters (serde-only)" license = "AGPL-3.0-only" diff --git a/crates/source2rosetta-core/README.md b/crates/source2rosetta-core/README.md index 45227bf..43ed378 100644 --- a/crates/source2rosetta-core/README.md +++ b/crates/source2rosetta-core/README.md @@ -1,13 +1,14 @@ # source2rosetta-gen -Render a published [source2rosetta](../../README.md) gamedata release into whatever format your framework -reads. `source2rosetta` does the hard part — deriving CS2 / Dota 2 gamedata from the stripped engine and -validating it on a live server — and publishes a small set of JSON files per game. `source2rosetta-gen` turns those into -CounterStrikeSharp, Metamod/SourceMod, ModSharp, Swiftly, Plugify, or a typed C# SDK, locally, in a second. +Render a published [source2rosetta](../../README.md) release into whatever format your framework reads. +`source2rosetta` does the hard part — deriving CS2 / Dota 2 gamedata from the stripped engine and +validating it on a live server — and publishes **one file per game**, `rosetta-.json`. +`source2rosetta-gen` turns that into CounterStrikeSharp, Metamod/SourceMod, ModSharp, Swiftly, Plugify, a +typed C# SDK, or the Dota script API, locally, in a second. It's deliberately tiny: it links only `source2rosetta-core` (serde + the format emitters) — **no** ELF reader, -no disassembler, no ptrace. So a consumer who "just wants the files" downloads one release + this small binary -and generates exactly what they need, instead of every format being pre-baked into the release. +no disassembler, no ptrace. So a consumer who "just wants the files" downloads one release + this small +binary and generates exactly what they need, instead of every format being pre-baked into the release. ## Get it @@ -23,109 +24,140 @@ does **not** build it — use `-p source2rosetta-core` or `--workspace`.) ## Use it -Three of the published artifacts are `gen` inputs, one per `--` flag: - -- `gamedata-.json` (`--from`) — the derived gamedata (function signatures + vtable offsets), tiered by confidence. -- `netvars-.json` (`--netvars`) — the typed schema (field offsets + runtime types, plus the class base - graph and per-type sizes). -- `abi-.json` (`--abi`) — declared parameter and return types, each re-judged against the footprint - measured in that build. This is what a function TAKES, as opposed to where it is. See - [Call shapes](#call-shapes----abi-abi-gamejson). - -`bindings-.json` ships beside them and `gen` does **not** render it — it is not locator data. It is -what the binary declares about itself, in five sections: Pulse bindings (display name, description, call -policy, and each binding's typed signature), entity-IO inputs and outputs, map-classname → C++ class, and -console commands. Plain JSON, readable as-is. - -Then point `gen` at whichever you need and pick a `--format`. Output goes to `--out`, or stdout if omitted. +One input, one flag. `--format` says **who the output is for**; `--out` is a **directory**, because most +formats write more than one file. ```sh -# CounterStrikeSharp combined gamedata (the default) -source2rosetta-gen --from gamedata-cs2.json --format cssharp --out gamedata.json +R=https://git.lo.sh/kamal/source2rosetta/releases/download/cs2-latest +curl -fsSLO $R/rosetta-cs2.json -# Metamod / SourceMod gamedata VDF (one .games.txt) -source2rosetta-gen --from gamedata-cs2.json --format metamod --out csgo.games.txt +# CounterStrikeSharp: the combined gamedata + typed call sites for the same functions +source2rosetta-gen --from rosetta-cs2.json --format cssharp --out ./csharp -# Swiftly / ModSharp / Plugify gamedata -source2rosetta-gen --from gamedata-cs2.json --format swiftly --out gamedata.json +# Metamod:Source / SourceMod: the gamedata VDF + a C++ prototype header +source2rosetta-gen --from rosetta-cs2.json --format metamod --out ./mm -# Typed C# SDK from the schema — one `static class` per engine class, `const` field offsets + types -source2rosetta-gen --netvars netvars-cs2.json --format cs-sdk --out Schema.cs +# A typed C# SDK from the schema — one `static class` per engine class, `const` offsets + types +source2rosetta-gen --from rosetta-cs2.json --format cs-sdk --out ./sdk -# Flat netvar offset map (class -> field -> offset) -source2rosetta-gen --netvars netvars-cs2.json --format netvars --out netvars.json +# The Dota script API: ModDota's dota-data shape AND the TypeScript declarations +source2rosetta-gen --from rosetta-dota2.json --format moddota --out ./dota ``` +Each run prints what it wrote. + ## Formats -| `--format` | needs | output | +**A framework gets two files, and it needs both.** The gamedata says *where* a function is; the call sites say +*how to call it*. They were separate inputs when the release was four files; one artifact makes them one +command. + +| `--format` | writes | notes | |---|---|---| -| `cssharp` *(default)* | `--from` | CounterStrikeSharp combined gamedata — **JSONC**: banner comments mean a strict JSON parser will reject it | -| `metamod` | `--from` | Metamod:Source / SourceMod gamedata VDF (`.games.txt`) | -| `modsharp` | `--from` | ModSharp gamedata JSON | -| `swiftly` | `--from` | Swiftly gamedata JSON — **signature entries only**; vtable-offset entries are omitted, because that framework takes offsets through a separate file | -| `plugify` | `--from` | Plugify gamedata JSON | -| `model` | `--from` | the selected tiers flattened to one name → locator map (format-neutral; not a re-readable monolith) | -| `cs-sdk` | `--netvars` | typed C# SDK — `static class` per schema class, `const int` field offsets tagged with their type | -| `netvars` | `--netvars` | flat schema map, `{ class: { field: offset } }` | +| `cssharp` *(default)* | `gamedata.json` + `RosettaFunctions.cs` | the gamedata is **JSONC** — banner comments, so a strict JSON parser will reject it. The `.cs` is `MemoryFunction*` fields / `VirtualFunction*` factories | +| `metamod` | `.games.txt` + `rosetta_prototypes.h` | the VDF also covers SourceMod. Metamod plugins are C++, so the prototypes are a header of `using X_t = RET (*)(…)` plus an `X_vtidx` constant per slot | +| `modsharp` | `gamedata.json` + `RosettaCalls.cs` | `[AddressKey]` interface for its Roslyn generator, plus a vtable-dispatch class | +| `swiftly` | `gamedata.json` + `prototypes.json` | **signature entries only** in the gamedata; that framework takes offsets through a separate file | +| `plugify` | `gamedata.json` + `prototypes.json` | runtime type arrays (`{"paramTypes":["pointer","string"],"retType":"void"}`) | +| `cs-sdk` | `Schema.cs` | typed C# SDK: `static class` per schema class, `const int` field offsets tagged with their type, plus the engine's own enums at their real width | +| `netvars` | `netvars.json` | flat schema map, `{ class: { field: offset } }` | +| `moddota` | `api.json` + `api.d.ts` | the VScript API in ModDota `dota-data`'s shape (their toolchain renders from it), plus TypeScript declarations for authors using the published packages as-is — one `interface` per class, Valve's own description as the doc comment | +| `flat` | `gamedata-flat.json` | the selected tiers as one name → locator map, format-neutral | -### Call shapes — `--abi abi-.json` +**Every published artifact renders every format on this list.** The releases are always derived against a +running server, so nothing here is conditional on how the artifact was made. (If you derive your own, that +changes — see [below](#if-you-derived-the-artifact-yourself).) -The same framework ids, a different input: `--abi` renders **how to call** a function rather than where it -is. The input picks the family, so `--abi … --format cssharp` emits typed call sites while -`--from … --format cssharp` emits the gamedata those calls resolve through. +### Which games a format covers -All five framework ids work here, exactly as they do for `--from`: +**The artifact states its own game** (`meta.game_key`, `csgo` or `dota`) and the output follows it — there is +no `--game` flag, because a second place to state one fact is a second place for it to be wrong. -```sh -source2rosetta-gen --abi abi-cs2.json --format cssharp --out RosettaFunctions.cs -source2rosetta-gen --abi abi-cs2.json --format metamod --out rosetta_prototypes.h -source2rosetta-gen --abi abi-cs2.json --format modsharp --out RosettaCalls.cs -source2rosetta-gen --abi abi-cs2.json --format swiftly --out prototypes.json -source2rosetta-gen --abi abi-cs2.json --format plugify --out prototypes.json -``` +Two formats are **game-keyed**, and for both the key is the game DIRECTORY the server runs out of, which is +what `game_key` already holds: -| `--format` | output | -|---|---| -| `cssharp` | C# `MemoryFunction*` fields (signature) / `VirtualFunction*` factories (vtable slot) | -| `metamod` | C++ header of `using X_t = RET (*)(…)`, plus an `X_vtidx` constant for a slot — Metamod plugins are C++ and take the **declared** types verbatim | -| `modsharp` | C# `[AddressKey]` interface for its Roslyn generator (signature) + a vtable-dispatch class (slot) | -| `swiftly` | JSON per-function type descriptors (`{"args":"ppf","ret":"v","call":"address"}`) | -| `plugify` | JSON runtime type arrays (`{"paramTypes":["pointer","string","float"],"retType":"void"}`) | +- `metamod` writes `Games { { … } }`. The consuming plugin looks that section up by the engine's + own `GetGameDir()` — see [cs2kz-metamod's reader][kz] — so `dota` is what a Dota 2 plugin will look for. + Metamod takes Dota 2 as a first-class SDK target ([`dota.json`][mm], `define: DOTA`, `source2: true`). +- `plugify` writes `{ "": { … } }`, matched against the `S2SDK_GAME_NAME` its s2sdk plugin was + BUILT with (default `csgo`). -Source for the two C# targets and for C++ because their type lists are **compile-time**; data for Swiftly -and Plugify because theirs are resolved at runtime. +The rest are game-neutral in shape: `modsharp` and `cssharp` carry no game key at all (flat, keyed only by +platform), and `flat` / `cs-sdk` / `netvars` / `moddota` are plain data. -**The two locator forms are not interchangeable, and every output distinguishes them.** A signature -resolves to one address; a vtable slot is entered through the object, so the framework reaches it by a -different call entirely — `VirtualFunctionVoid(instance, slot)` rather than `GameData.GetSignature(key)`, -`GetVFuncIndex` rather than `GetAddress`, `(*(void***)self)[idx]` rather than a scanned pointer. Roughly -a quarter of a LIVE-derived manifest's call sites are vtable-located, so binding them all through the -signature path would look up keys that live in the gamedata's `offsets` section and never in its -`signatures` one. +**Two consumers cannot run on Dota 2 at all**, and `gen` declines rather than write a file that can never +load: CounterStrikeSharp resolves its binaries out of `/csgo/bin/`, and Swiftly initialises against the +`csgo` game directory. `--force` renders anyway. It is a warning rather than a rule on purpose — that is a +claim about somebody else's project, read out of their source at one point in time, and projects add games. -An **offline**-derived manifest emits none through the vtable path at all: a slot is recorded only once -live validation has confirmed it is really a vtable slot and not a carried member offset, so an offline -run states no slot rather than guess one. Same artifact shape, fewer vtable call sites — worth knowing -before diffing two manifests produced different ways. +**ModSharp is CS2-first but not excluded.** Its own paths are hardcoded (`../../csgo/steam.inf`), yet its +gamedata carries no game key whatsoever — flat `Addresses` / `VFuncs`, platform-keyed — so the file rendered +here is the same one whatever game the build targets. -**The receiver is always in the type list.** Where the declaration came from an Itanium-mangled symbol -`this` is invisible, so it is prepended, spelled from the function's own class (`CBaseEntity*`, not -`void*`) and marked `[this]` in the C++ header. It is a real register in the call frame — leaving it out -shifts every argument by one. +[kz]: https://github.com/KZGlobalTeam/cs2kz-metamod/blob/dev/src/utils/gameconfig.cpp +[mm]: https://github.com/alliedmodders/hl2sdk-manifests/blob/master/manifests/dota.json -Only functions the deriver could stand behind are emitted: `status: verified` **or `lower-bound`** (the -declaration passes registers the callee never reads and contradicts it in none — safe to call, and -marked as such in every output), a receiver settled by evidence (the declaration names it, a -live-validated vtable slot proves it, or the measurement independently agrees), and every parameter -mappable onto an ABI class. A function whose return **nobody -declared** is still emitted — otherwise Dota would lose 2,304 of its 3,732 call sites — but it is marked as such in every -output (prose in the generated source, `ret_declared` / `retDeclared` in the data), and the value is -documented as the raw return register rather than a typed result. +### Descriptions + +**Every call site is emitted with a sentence saying what the function is FOR**, wherever that target's +readers hover: a C# XML ``, so IntelliSense shows it; a comment above the C++ typedef; a +`description` field in the data formats. The prototype keeps a home of its own — a `` in C#, the +identity line in the header — so nothing is lost to make room. That is every emittable call site: 2,073 on +CS2, 2,326 on Dota. + +**Each one says whose sentence it is, and that is not decoration.** Some are Valve's own, read out of a +registry in the binary (717 CS2 / 774 Dota); the rest are this project's reading of the build, and the two +carry very different weight. So every generated source prints the origin beside the text, the data formats +carry it as an id (`valve` / `derived` / `generated`), and `moddota` — which deliberately mirrors a shape the +Dota ecosystem already publishes — keeps ours under keys of our own name rather than in the `description` +field their toolchain renders as Valve's word. + +**Valve's text always wins.** Where the binary documents a function, that is what ships; a generated +description only ever fills a gap, so the two can never disagree in an output. Between Valve's own two +registries the script one wins: a console registration's help text documents the COMMAND an operator types, +while a script binding documents the function. In the `.d.ts`, a member Valve documents reads exactly as it +did before — bare, the way the published types do — and only a gap Valve left is filled and marked. + +`cs-sdk` and `netvars` render the schema, which is classes and field offsets. There are no functions in them +to describe, so they carry none. + +### What the call sites will and won't emit + +Only functions the deriver could stand behind: `status: verified` **or `lower-bound`** (the declaration passes +registers the callee never reads and contradicts it in none — safe to call, and marked as such in every +output), a receiver settled by evidence (the declaration names it, a live-validated vtable slot proves it, or +the measurement independently agrees), and every parameter mappable onto an ABI class. A function whose return +**nobody declared** is still emitted — otherwise Dota would lose 2,304 of its 3,732 call sites — but it is +marked as such in every output (`ret_declared` / `retDeclared` in the data formats, prose in the generated +source), and the value is documented as the raw return register rather than a typed result. + +**The two locator forms are not interchangeable, and every output distinguishes them.** A signature resolves to +one address; a vtable slot is entered through the object, so the framework reaches it by a different call +entirely — `VirtualFunctionVoid(instance, slot)` rather than `GameData.GetSignature(key)`, `GetVFuncIndex` +rather than `GetAddress`, `(*(void***)self)[idx]` rather than a scanned pointer. Roughly a quarter of the +call sites are vtable-located. + +**A few entries carry BOTH**, which is worth knowing if you consume the gamedata rather than these call +sites: `model::Entry` allows it and five CS2 `core` entries use it. Both locators are live-validated +independently, and `validated: true` means both passed — an entry whose signature checked out but whose slot +could not be reached ships `null`, never `true`. The call-site emitters here pick one form per function, so +this only affects what you read out of the artifact directly. + +**The receiver is always in the type list.** Where the declaration came from an Itanium-mangled symbol `this` +is invisible, so it is prepended, spelled from the function's own class (`CBaseEntity*`, not `void*`) and +marked `[this]` in the C++ header. It is a real register in the call frame — leaving it out shifts every +argument by one. + +**Two things `moddota` states honestly rather than guesses.** Parameters are declared `...args: any[]`, +because the registry does not carry them — types appear only inside Valve's prose descriptions, inconsistently, +in about a fifth of entries. It is visibly ugly on purpose: nobody should mistake these for complete +declarations, and inventing plausible arity would emit declarations that lie rather than abstain. And +`available` is always `server`, because a dedicated server never maps `libclient`, so this derivation cannot +see the client side at all. ## Confidence tier -The gamedata formats (the `--from` ones) take a `--tier`, cumulative and defaulting to `high_confidence`: +The locator half takes a `--tier`, cumulative and defaulting to `high_confidence`: | `--tier` | includes | |---|---| @@ -135,10 +167,40 @@ The gamedata formats (the `--from` ones) take a `--tier`, cumulative and default ```sh # only the rock-solid set: -source2rosetta-gen --from gamedata-cs2.json --format cssharp --tier core --out gamedata.json +source2rosetta-gen --from rosetta-cs2.json --format cssharp --tier core --out ./csharp ``` -The schema formats (`cs-sdk`, `netvars`) ignore `--tier`. +The schema and script-API formats ignore `--tier`. + +## What is in the artifact that `gen` does not render + +`rosetta-.json` is plain JSON and readable as-is, and it carries more than these formats consume: the +Pulse binding registry (typed signatures, call policy, and a callable shim per binding), entity outputs, +map classname → C++ class, ConVars with decoded flags, and the declared rows that belong to no function here +(`surfaces.unjoined`). Those have no loader to render them into — read them directly. The per-function +descriptions are in there too, and they DO reach the outputs, but only for the ~2,000 functions that become +call sites; the artifact describes about twice as many. See the [artifacts section](../../README.md#artifacts-schemas--output-formats). + +## If you derived the artifact yourself + +Skip this if you downloaded the artifact — it is about `source2rosetta produce`, not about `gen`. + +The releases are derived against a **running server**, which is where two whole surfaces come from. Run +`produce` without `--game-dir` and it derives what it can offline, honestly, and states the rest as absent — +so `gen` gets an artifact that is real but smaller, and three things follow: + +- **`cs-sdk`, `netvars` and `moddota` have nothing to render**, and say so rather than writing an empty file. + The schema's field TYPES are runtime-resolved, and a VScript binding's owning class is reached through a + register loaded from memory, so neither is readable from the file alone. All three group by one or the + other. +- **No call site is reached through a vtable.** A slot is only recorded once live validation has confirmed it + is really a vtable slot and not a carried member offset, so an offline run states no slot rather than guess + one. Roughly a quarter of a live manifest's call sites are vtable-located; an offline one has none. Same + shape, fewer entries — worth knowing before diffing two outputs made different ways. +- **Nothing has been checked against a running server.** `validated` is `null` on every record rather than a + verdict, and the locator half drops only what live validation confidently REJECTED — so an offline artifact + keeps entries a live one would have thrown out. The tiers still mean what they mean; they just have not + been tested. --- diff --git a/crates/source2rosetta-core/src/bin/source2rosetta-gen.rs b/crates/source2rosetta-core/src/bin/source2rosetta-gen.rs index a6a7857..4255e54 100644 --- a/crates/source2rosetta-core/src/bin/source2rosetta-gen.rs +++ b/crates/source2rosetta-core/src/bin/source2rosetta-gen.rs @@ -1,107 +1,211 @@ -//! `source2rosetta-gen` — the standalone generator. Reads the published monolith (`gamedata-.json` -//! from `source2rosetta produce`) and renders it into any framework's gamedata format at a chosen confidence -//! tier. +//! `source2rosetta-gen` — the standalone generator. Reads the published `rosetta-.json` and writes +//! the files one consumer needs: a framework's gamedata plus the typed call sites that resolve through it, +//! a typed schema SDK, or the script API the Dota ecosystem publishes. //! //! It touches only the `model` + `render` layers — no ELF reader, no ptrace, no disassembler — so a consumer -//! who "just wants the files" downloads one monolith + this small, rarely-changing binary and generates +//! who "just wants the files" downloads one artifact and this small, rarely-changing binary and generates //! whatever their framework needs locally, instead of every format being pre-baked into releases. It lives in //! the `source2rosetta-core` crate (serde-only), so it stays genuinely lean. use anyhow::{Context, Result, bail}; use clap::Parser; use source2rosetta_core::{model, render}; -use std::path::PathBuf; +use std::path::{Path, PathBuf}; #[derive(Parser)] #[command( name = "source2rosetta-gen", version, - about = "Render a source2rosetta monolith into a framework gamedata format" + about = "Render a source2rosetta release into the files your framework reads" )] struct Cli { - /// The monolith `gamedata-.json` (for a GAMEDATA --format: cssharp/metamod/modsharp/swiftly/plugify/model). + /// The published `rosetta-.json` — one artifact holding every surface. #[arg(long)] - from: Option, - /// The typed `netvars-.json` (for a SCHEMA --format: cs-sdk/netvars). - #[arg(long)] - netvars: Option, - /// The prototype manifest `abi-.json` — renders CALL SHAPES (declared parameter and return - /// types, verified against the build) instead of locators. Reuses the framework --format ids: the - /// INPUT chooses what is rendered, so `--abi … --format cssharp` emits typed call sites while - /// `--from … --format cssharp` emits the gamedata those calls resolve through. - #[arg(long)] - abi: Option, - /// Output format. GAMEDATA (needs --from): cssharp | metamod | modsharp | swiftly | plugify | model. - /// SCHEMA (needs --netvars): cs-sdk (typed C# SDK) | netvars (flat offset map). ABI (needs --abi): - /// cssharp | metamod | modsharp | swiftly | plugify. cssharp = the `//`-bannered CS# combined file; - /// the metamod gamedata format also covers SourceMod (the VDF `.games.txt`), while its ABI format is - /// a C++ header, because Metamod plugins are C++ and declare prototypes in source. + from: PathBuf, + /// Who the output is for, and it writes every file that consumer reads. FRAMEWORKS get a gamedata + /// file and the typed call sites that resolve through it: cssharp | metamod (also SourceMod's VDF) | + /// modsharp | swiftly | plugify. SCHEMA: cs-sdk (typed C# SDK) | netvars (flat offset map). SCRIPT + /// API: moddota, which writes both shapes that ecosystem publishes (`api.json` + `api.d.ts`). Plus + /// `flat`, a format-neutral name -> locator map. #[arg(long, default_value = "cssharp")] format: String, - /// Confidence tier for a gamedata format (cumulative): core | high_confidence | experimental. Defaults to - /// `high_confidence` (core + the promoted names). Ignored by schema formats. + /// Confidence tier for the locator half, cumulative: core | high_confidence | experimental. Defaults to + /// `high_confidence` (core + the promoted names). Ignored by the schema and script-API formats. #[arg(long, default_value = "high_confidence")] tier: String, - /// Write here (default: stdout). + /// Directory to write into (default: the working directory). A format writes more than one file, so + /// this names a DIRECTORY rather than a file — the names are the ones each framework expects. + #[arg(long, default_value = ".")] + out: PathBuf, + /// Render even where the consumer is not known to run on this artifact's game. What that claim rests + /// on is in `render::GAME_SUPPORT`; it is read out of somebody else's source and they do add games, + /// so it declines by default rather than refusing outright. #[arg(long)] - out: Option, + force: bool, +} + +/// One file to write: the name the consuming framework expects, and what goes in it. +struct Out { + name: String, + text: String, + /// What this file is, for the line printed after writing it. + what: &'static str, } fn main() -> Result<()> { let cli = Cli::parse(); let fmt = cli.format.as_str(); - // The INPUT selects the emitter family, which is why `cssharp` can name three different outputs. - let text = if let Some(path) = cli.abi.as_ref() { - let man: model::AbiManifest = serde_json::from_str(&std::fs::read_to_string(path)?) - .with_context(|| format!("parse abi manifest json {}", path.display()))?; - let e = render::abi_by_id(fmt).with_context(|| { - format!( - "unknown ABI --format `{fmt}` (known: {})", - render::ABI_FORMAT_IDS.join(" | ") - ) - })?; - e.render(&man) - } else if render::SCHEMA_FORMAT_IDS.contains(&fmt) { - // schema formats render the typed netvars (class -> field -> offset/type), not the gamedata monolith. - let path = cli.netvars.as_ref().context( - "a schema --format (cs-sdk | netvars) requires --netvars .json>", - )?; - let schema: model::Schema = serde_json::from_str(&std::fs::read_to_string(path)?) - .with_context(|| format!("parse netvars json {}", path.display()))?; - render::schema_by_id(fmt) - .expect("known schema format") - .render(&schema) - } else { - let path = cli - .from - .as_ref() - .context("a gamedata --format requires --from .json>")?; - let tier = model::TierSelect::from_id(&cli.tier).with_context(|| { - format!( - "unknown --tier {:?} (want one of: {})", - cli.tier, - model::TIER_IDS.join(" | ") - ) - })?; - let mono: model::Monolith = serde_json::from_str(&std::fs::read_to_string(path)?) - .with_context(|| format!("parse monolith json {}", path.display()))?; - match fmt { - // cssharp is the bannered combined file (guaranteed + extrapolated sections), not a flat map. - "cssharp" => render::render_monolith_cssharp(&mono, tier), - f @ ("metamod" | "modsharp" | "swiftly" | "plugify" | "model") => render::by_id(f) - .expect("known flat format") - .render(&mono.select(tier)), - other => bail!( - "unknown --format {other:?} (gamedata: cssharp|metamod|modsharp|swiftly|plugify|model; \ - schema: cs-sdk|netvars)" - ), + let text = std::fs::read_to_string(&cli.from) + .with_context(|| format!("read {}", cli.from.display()))?; + let r: model::Rosetta = serde_json::from_str(&text) + .with_context(|| format!("parse {} as a rosetta artifact", cli.from.display()))?; + let tier = model::TierSelect::from_id(&cli.tier).with_context(|| { + format!( + "unknown --tier {:?} (want one of: {})", + cli.tier, + model::TIER_IDS.join(" | ") + ) + })?; + + // Checked before anything is rendered: a file that cannot load on the game it was made for is worse + // than no file, and the one thing worse than that is one written silently. + if let Some(mismatch) = render::game_mismatch(fmt, &r.meta.game_key) { + if !cli.force { + bail!("{mismatch}\n Pass --force to render it anyway."); } + eprintln!("warning: {mismatch}\n Rendering anyway (--force)."); + } + + let outputs = match fmt { + // A framework gets the pair: WHERE the functions are, and HOW to call them. They were two + // invocations against two files; one artifact makes them one command, and a consumer who has the + // locators without the call sites has half of what it takes to make a call. + f @ ("cssharp" | "metamod" | "modsharp" | "swiftly" | "plugify") => { + let gd = match f { + // cssharp is the bannered combined file (guaranteed + extrapolated sections), not a flat map. + "cssharp" => render::render_monolith_cssharp(&r.to_monolith(), tier), + _ => render::by_id(f) + .expect("known flat format") + .render(&r.gamedata(tier)), + }; + let calls = render::abi_by_id(f) + .expect("known abi format") + .render(&r.abi_manifest()); + let (gd_name, calls_name) = match f { + "cssharp" => ("gamedata.json".into(), "RosettaFunctions.cs"), + "metamod" => ( + format!("{}.games.txt", r.meta.game_key), + "rosetta_prototypes.h", + ), + "modsharp" => ("gamedata.json".into(), "RosettaCalls.cs"), + _ => ("gamedata.json".into(), "prototypes.json"), + }; + vec![ + Out { + name: gd_name, + text: gd, + what: "locators", + }, + Out { + name: calls_name.into(), + text: calls, + what: "typed call sites", + }, + ] + } + "flat" => vec![Out { + name: "gamedata-flat.json".into(), + text: render::by_id("model") + .expect("known flat format") + .render(&r.gamedata(tier)), + what: "locators, format-neutral", + }], + f @ ("cs-sdk" | "netvars") => { + // Field types are runtime-resolved, so an offline build states no schema at all. Saying so is + // better than writing an empty SDK that compiles and describes nothing. + let schema = r.typed_schema().context( + "this artifact's `schema` is null, so the schema formats have nothing to render — field \ + TYPES are resolved at runtime and are not in the file. Every PUBLISHED artifact carries \ + one, so this is a local OFFLINE derive: re-run `produce` with --game-dir, or take the \ + artifact from a release.", + )?; + let text = render::schema_by_id(f) + .expect("known schema format") + .render(&schema); + vec![Out { + name: if f == "cs-sdk" { + "Schema.cs".into() + } else { + "netvars.json".into() + }, + text, + what: "typed schema", + }] + } + // One consumer, two files, for the same reason a framework gets two: the ModDota ecosystem's + // toolchain renders from the JSON, while an author working against the published packages reads + // the declarations. Emitting one of them is answering half the question. + "moddota" => { + let vscript = r.vscript(); + // Both shapes group members by owning class, and the class is only readable from a running + // server — so an offline artifact renders nothing, and an empty file would look like an + // answer rather than a missing input. The two ways of having nothing to render are worth + // telling apart: a game with no script VM at all is not a build that was run offline. + if vscript.is_empty() { + bail!( + "this artifact carries no VScript bindings at all, so there is no script API to \ + render. Only Dota 2 and CS2 expose one — check you passed the right artifact." + ); + } + if vscript.iter().all(|v| v.class.is_none()) { + bail!( + "this artifact has {} VScript bindings and no owning class on any of them, and both \ + shapes group members BY class. The owning class is only readable from a running \ + server, and every PUBLISHED artifact carries it, so this is a local OFFLINE derive: \ + re-run `produce` with --game-dir, or take the artifact from a release.", + vscript.len() + ); + } + let schema = r.typed_schema(); + let render_as = |id: &str| { + render::bindings_by_id(id) + .expect("known bindings format") + .render(&vscript, schema.as_ref()) + }; + vec![ + Out { + name: "api.json".into(), + text: render_as("api-json"), + what: "script API, ModDota `dota-data` shape", + }, + Out { + name: "api.d.ts".into(), + text: render_as("dts"), + what: "script API, TypeScript declarations", + }, + ] + } + other => bail!( + "unknown --format {other:?} (want one of: {})", + render::FORMAT_IDS.join(" | "), + ), }; - match cli.out { - Some(p) => std::fs::write(&p, text).with_context(|| format!("write {}", p.display()))?, - None => println!("{text}"), + write_all(&cli.out, &outputs) +} + +fn write_all(dir: &Path, outputs: &[Out]) -> Result<()> { + std::fs::create_dir_all(dir).with_context(|| format!("create {}", dir.display()))?; + for o in outputs { + let p = dir.join(&o.name); + std::fs::write(&p, &o.text).with_context(|| format!("write {}", p.display()))?; + println!( + "{} ({}, {} KB)", + p.display(), + o.what, + o.text.len().div_ceil(1024) + ); } Ok(()) } diff --git a/crates/source2rosetta-core/src/model.rs b/crates/source2rosetta-core/src/model.rs index aafa885..587584c 100644 --- a/crates/source2rosetta-core/src/model.rs +++ b/crates/source2rosetta-core/src/model.rs @@ -12,17 +12,44 @@ pub struct Sig { pub linux: String, // space-hex pattern with `?` wildcards, e.g. "55 48 89 ? E5" } -/// One gamedata function: a vtable-method offset, a scan signature, or (rarely) both. +/// One gamedata function: a vtable-method offset, a scan signature, or (rarely) both — plus, where we +/// have them, string ANCHORS that locate the same function a different way. #[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct Entry { #[serde(default, skip_serializing_if = "Option::is_none")] pub signature: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub offset: Option, // vtable slot index (or a carried member offset) + /// For a vtable-OFFSET locator: the class whose vtable the slot was measured on. + /// + /// Part of the locator, not decoration — a slot index alone locates nothing, since it is only meaningful + /// relative to a particular class's vtable. + /// + /// It is the entry name's own class, stated explicitly: the deriver keys its slot timelines and + /// alignment hops by the name's class and chains through that one, so "the class the offset was + /// chained through" and "the class in the name" are one fact rather than two. Directly folded offsets + /// (the multilib ground-truth path) carry no class at all and leave the consumer to split the name. + /// So a reader may treat this as a convenience copy — never as a second, independent attribution. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub class: Option, + /// Distinctive string literals this function references, each unique to it within its library. + /// + /// NOT a locator competing with the signature and the offset — a supplement with a DIFFERENT failure + /// mode. A byte signature is a snapshot of one build's codegen; a string survives a recompile that + /// moves instructions. So a consumer that can resolve anchors (ModSharp's `refs.strings`) has a + /// locator that keeps working across the window between Valve shipping a build and us republishing, + /// which is exactly when a byte pattern is most likely to have drifted. + /// + /// Emitted alongside the signature, never instead of it: the two are independent, and a consumer + /// choosing between them is better served by having both than by our picking one. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub anchors: Vec, } impl Entry { - /// A signature-only locator (the deriver's sig-XOR-offset invariant as a constructor). + /// A signature-only locator. A convenience for the common shape, NOT an invariant — an entry may carry + /// a signature and an offset at once (the struct doc says so, and real `core` entries do), so anything + /// judging an entry must check every locator it holds rather than the first one it finds. pub fn signature(library: impl Into, linux: impl Into) -> Entry { Entry { signature: Some(Sig { @@ -30,6 +57,8 @@ impl Entry { linux: linux.into(), }), offset: None, + class: None, + anchors: Vec::new(), } } @@ -38,6 +67,8 @@ impl Entry { Entry { signature: None, offset: Some(linux), + class: None, + anchors: Vec::new(), } } } @@ -84,6 +115,11 @@ pub enum FlagReason { Unresolved, /// The sig SHIPPED, but its ABI prototype shape drifted from the model consensus (review the prototype). AbiDrift, + /// A signature DID resolve, and the address it resolved to is provably a different function — the + /// binary names it something else and the code operates on another class. Distinct from `SigDrifted` + /// because it calls for the opposite response: a drifted entry may simply reappear next build, while + /// this one says the catalogue's own signature is finding a decoy and the entry needs a new locator. + NameContradicted, } impl FlagReason { @@ -95,6 +131,7 @@ impl FlagReason { FlagReason::OffsetLowConf => "offset-low-conf", FlagReason::Unresolved => "unresolved", FlagReason::AbiDrift => "abi-drift", + FlagReason::NameContradicted => "name-contradicted", } } } @@ -136,6 +173,30 @@ impl Gamedata { self.entries.entry(name.into()).or_default().offset = Some(linux); } + /// Record the class a vtable-offset locator is relative to. + pub fn set_class(&mut self, name: impl Into, class: impl Into) { + self.entries.entry(name.into()).or_default().class = Some(class.into()); + } + + /// Attach string anchors to `name`, creating the entry if the derivation reached it by no other route. + /// + /// Deduplicated and order-preserving: the catalogue can carry the same anchor twice across variants, + /// and the emitted list is part of a byte-reproducible artifact, so it must not depend on how many + /// times a source repeated itself. + pub fn add_anchors>( + &mut self, + name: impl Into, + anchors: impl IntoIterator, + ) { + let e = self.entries.entry(name.into()).or_default(); + for a in anchors { + let a = a.into(); + if !a.is_empty() && !e.anchors.contains(&a) { + e.anchors.push(a); + } + } + } + pub fn len(&self) -> usize { self.entries.len() } @@ -146,9 +207,10 @@ impl Gamedata { } // =========================================================================================== -// The monolith model — the shipped `gamedata-.json`. Four confidence tiers with provenance -// + live-validation folded inline; `source2rosetta-gen` renders it into any framework format, and it is -// equally readable as-is by a consumer. A `MonoEntry` EMBEDS `Entry`, so the locator shape stays +// The tiered catalogue — WHERE each named function is. Four confidence tiers with provenance +// + live-validation folded inline. It is the locator half of what `merge` folds into the shipped +// `rosetta-.json`, where each entry becomes one [`FunctionRecord`]. +// A `MonoEntry` EMBEDS `Entry`, so the locator shape stays // single-sourced on `render::locator_value` and never diverges. Lib-agnostic: an entry carries its // `library` in the signature locator, so the monolith spans every derived library, not just libserver. // =========================================================================================== @@ -297,9 +359,6 @@ impl Provenance { pub struct MonoEntry { #[serde(flatten)] pub locator: Entry, - /// experimental offsets only: the vtable class the slot lives on (a reader's eyeball check). - #[serde(default, skip_serializing_if = "Option::is_none")] - pub class: Option, /// The argument footprint read out of THIS build's machine code — see [`AbiShape`]. Absent when the /// function's address wasn't resolvable offline. #[serde(default, skip_serializing_if = "Option::is_none")] @@ -308,6 +367,28 @@ pub struct MonoEntry { /// Live-validation verdict: `Some(true)` passed, `Some(false)` dropped confident-bad, `None` unvalidated. #[serde(default)] pub validated: Option, + /// The OTHER shipped names that locate this same function — key-sorted, never including this entry's own + /// name, and empty for the ~95% of entries that are the only name for their target. + /// + /// Several names on one function is normal and not a defect: the catalogue is assembled from independent + /// sources that spell the same function differently (`CreateEntityByName`, `UTIL::CreateEntityByName` + /// and `CGameEntitySystem::CreateEntityByName` are one address), and dropping all but one would discard + /// whichever spelling a given consumer's existing code already uses. What was missing is that the + /// artifact never SAID so, which left a reader unable to tell an alias from two genuinely different + /// functions — and left anything generating per-function documentation writing several unrelated + /// accounts of one target. + /// + /// **Scope: `core` + `high_confidence`, across the two tiers rather than within each.** `experimental` is + /// excluded because its names are unverified guesses, so a shared target there is not evidence of a + /// shared meaning — that band states the converse relation (one name guessed at several addresses) + /// through `provenance.collision`. + /// + /// **A bare-slot entry is never grouped**, and that is a real gap rather than an absence of aliases: an + /// `offset` with no `class` names no vtable, so two of them carrying slot 3 are not evidence of anything. + /// Grouping them would put every unbound slot-3 entry in one bucket — 1,080 CS2 names in 70 fictitious + /// groups, measured. Only class-bound offsets and signatures are grouped. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub aliases: Vec, } /// A function's SysV-AMD64 argument footprint, read out of the target binary rather than declared: how many @@ -365,11 +446,22 @@ pub struct MonoMeta { /// own field (volatile metadata is kept OUT of this byte-reproducible monolith). pub version: String, pub counts: Counts, + /// How many distinct functions carry more than one shipped name, and how many names that accounts for + /// — the two halves of [`MonoEntry::aliases`] seen from the release's side. Counted over + /// `core` + `high_confidence` together, since a group routinely spans the two tiers. + /// + /// Worth reading before treating the tier counts as a function count: on CS2 roughly 5% of the resolved + /// surface is several names on one target, so `counts.core + counts.high_confidence` over-counts + /// FUNCTIONS by about that much while being exactly right about NAMES, which is what it says. + #[serde(default)] + pub alias_groups: usize, + #[serde(default)] + pub aliased_names: usize, } -/// The full derived gamedata for one build — the shipped `gamedata-.json`. Four confidence tiers, each -/// a key-sorted map. `source2rosetta-gen` renders it into any framework format; a consumer can equally read it -/// directly, gating `experimental` behind a runtime toggle off each entry's tier. +/// The full derived gamedata for one build — four confidence tiers, each a key-sorted map. [`merge`] +/// flattens it into the shipped artifact's `functions`, where the tier a name came from rides on the +/// record instead of deciding which map it lives in. #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] pub struct Monolith { pub meta: MonoMeta, @@ -437,8 +529,7 @@ impl Monolith { } // =========================================================================================== -// The binding registry — the shipped `bindings-.json`. What the binary DECLARES about its own -// callable surface, as opposed to what the derivation infers about it: Valve registers every Pulse +// The binding registry — what the binary DECLARES about its own callable surface, as opposed to what the derivation infers about it: Valve registers every Pulse // binding and entity-IO input with a name, author-facing documentation, and call metadata, and this is // that data read back out. Kept OUT of the monolith on purpose — the monolith answers "where is this // function", this answers "what may I do with it", and only the first belongs in a gamedata file. @@ -499,9 +590,48 @@ pub struct Binding { pub typed: bool, /// Address of the binding's DESCRIPTOR ACCESSOR in this build — a lazy-init singleton returning the /// static descriptor, not the bound function. It is the anchor a runtime walks to reach the - /// descriptor (and, through it, the real entry point); it is NOT a locator for the named method, and - /// no shipped gamedata entry points at it. + /// descriptor; it is NOT a locator for the named method, and no shipped gamedata entry points at it. + /// For an address that IS callable, see [`Binding::shim`]. pub descriptor: String, + /// Address of the binding's INVOCATION SHIM in this build — the record's third code pointer, and + /// unlike `descriptor` a real entry point. One per binding, never shared. + /// + /// Calling it dispatches through Valve's own marshalling, which honours the DECLARED parameter types + /// in `params`: a value written into the argument blob is consumed according to its `PulseValueType_t`, + /// so a caller cannot smuggle a mistyped argument past it. Absent when the record's slot holds no + /// executable code. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub shim: Option, + /// How to call [`Binding::shim`], and what a host must supply. Absent when there is no shim. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub call: Option, +} + +/// The invocation shim's calling contract: fixed across every binding, with a per-binding statement of +/// which slots that particular shim reads. +/// +/// The signature is **seven integer arguments returning int**. Slot 5 (`r8`) is an array of POINTERS to the +/// argument values, element *k* at `+8+8k`. Slot 7 (the first stack slot) is the output sink. Slot 4 +/// (`rcx`) is a Pulse host-service context, which is VM-owned. The return is `0` on dispatch and `-2` when +/// an entity-handle argument fails to resolve. +#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ShimCall { + /// What a host must supply beyond the argument array, decoded from `reads`: + /// + /// * `args-only` — nothing else. The remaining slots may be null; **validated by calling every + /// eligible binding in both games.** This is the callable tier. + /// * `output-sink` — it returns a value, so it writes through a register-file object a host does not + /// have. Read the state through the `schema` section instead; the Pulse getters are redundant + /// with schema fields. + /// * `pulse-context` — needs a live `CPulseExecCursor` / graph instance. Not host-callable. + /// * `other-slots` — reads an argument slot whose role is not established (the `CPulseCell_*` + /// family, which are graph NODE implementations rather than API bindings). Not host-callable. + pub needs: String, + /// The argument slots this shim was measured to read, named in SysV order — the raw fact `needs` is + /// decoded from, kept beside it so a build that changes the contract can be re-read rather than + /// silently mis-labelled. The same rule `flags_raw` follows. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub reads: Vec, } /// One Pulse parameter or return value, as the binding declares it. @@ -513,7 +643,7 @@ pub struct PulseParam { /// The author-facing parameter name — `_Target` for the receiver, `retval` for a return. pub name: String, /// The `PulseValueType_t` enumerator, as the binary states it. Join it to the `enums` section of - /// `netvars-.json` for the spelling; the raw value is kept because that is the fact. + /// the `schema` section's `enums` for the spelling; the raw value is kept because that is the fact. #[serde(rename = "type")] pub ty: i32, /// The schema type the value refers to, where the binding NAMES one — which enum a @@ -587,6 +717,30 @@ pub struct ConsoleCommand { pub addr: String, } +/// One ConVar the module registers — the configuration half of the console surface. +/// +/// Emitted for the METADATA, not as a locator: a consumer finds a convar by name at runtime +/// (`ICvar::FindConVar`) with no gamedata at all, so the name alone would add nothing. The flags are the +/// payload — `cheat`, `replicated`, `release` are engine-DECLARED authority, and a host deciding what a +/// module may change is better served by what the engine says than by a hand-maintained allowlist. +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +pub struct ConVar { + pub name: String, + pub library: String, + #[serde(default, skip_serializing_if = "String::is_empty")] + pub description: String, + /// FCVAR bits with a measured meaning — the same space console commands use. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub flags: Vec, + /// The raw flags word. Empty when this registrar had no identifiable flags argument, which is honest + /// about the gap rather than reporting a zero that would read as "no flags set". + #[serde(default, skip_serializing_if = "String::is_empty")] + pub flags_raw: String, + /// Address of the ConVar object. It lives in `.bss`, so it holds nothing on disk — it is the anchor a + /// runtime walks to the live value, and what tells two registrations of one name apart. + pub addr: String, +} + /// One entity-IO output: an event an entity fires, and where its subscriber list lives on the instance. #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] pub struct EntityOutput { @@ -607,12 +761,13 @@ pub struct EntityOutput { /// NB the member's TYPE is not carried here: the offline schema reader recovers names and offsets but /// not types (those are runtime-resolved), and a handful of outputs are not the plain 24-byte /// `CEntityIOOutput` — `CLogicCase::m_OnCase` is `CEntityIOOutput[32]`. Join `class` + `member` - /// against `netvars-.json` for the type before striding one. + /// against the `schema` section for the type before striding one. #[serde(default, skip_serializing_if = "Option::is_none")] pub class: Option, } -/// The declared callable surface for one build — the shipped `bindings-.json`. +/// The declared callable surface for one build. [`merge`] folds the function-keyed parts of it onto +/// the functions they describe and keeps the rest under [`Surfaces`]. #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] pub struct Bindings { pub meta: BindingsMeta, @@ -625,7 +780,7 @@ pub struct Bindings { #[serde(default, skip_serializing_if = "Vec::is_empty")] pub entity_outputs: Vec, /// Map classname -> the C++ class it constructs (`func_door` -> `CBaseDoor`). The join between the - /// vocabulary a level designer writes and the classes `netvars-.json` describes. No addresses: + /// vocabulary a level designer writes and the classes the `schema` section describes. No addresses: /// the factory record binds names to names, not to a function. #[serde(default, skip_serializing_if = "BTreeMap::is_empty")] pub entity_classes: BTreeMap, @@ -633,6 +788,66 @@ pub struct Bindings { /// there is no honest key to map them by either. #[serde(default, skip_serializing_if = "Vec::is_empty")] pub commands: Vec, + /// ConVars, a LIST for the same reason: one name can be registered by more than one library. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub convars: Vec, + /// VScript bindings — the surface Valve exposes to Lua, keyed by the SCRIPT-facing name a content + /// author types. A LIST rather than a map because a name is only unique per class, and the owning + /// class is not recoverable offline. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub vscript: Vec, +} + +/// One function Valve exposes to the script VM. +/// +/// The fourth surface the binary documents about itself, and the only one that pairs a script-facing +/// name with a C++ name, an English description AND a return type in one record. It is disjoint from +/// everything else shipped here: measured against the catalogue, not one of the 1,652 Dota +/// implementations shares an address with a catalogued entry, and no name is shared either — a +/// `Script_TakeDamage` is a script-facing WRAPPER, a different function from the `TakeDamage` it wraps. +/// So these are additive, never a second account of something already described. +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +pub struct VScriptBinding { + /// What a Lua author calls (`TakeDamage`). + pub name: String, + /// The class that owns this member (`CDOTA_BaseNPC`). + /// + /// **Live-only, and absent from an offline build.** The class descriptor reaches the registration + /// through a register loaded from memory rather than a `lea`, so constant propagation recovers it for + /// none of the bindings; a running server resolves it through the record's owner pointer. This is the + /// same shape as a schema field's TYPE, which is a null placeholder on disk and is why an offline run + /// ships no typed netvars either. + /// + /// Consumers that group by class — `api.json`, the `.d.ts` the Dota ecosystem publishes — need this + /// and cannot be rendered from a full build's output alone if it is missing. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub class: Option, + /// The C++ binding this resolves to (`Script_TakeDamage`) — and the key under which the + /// implementation is folded into the catalogue, where it exists as a locator. + pub cpp: String, + pub library: String, + /// Valve's own English description, where the registration supplies one. + #[serde(default, skip_serializing_if = "String::is_empty")] + pub description: String, + /// The return type, decoded. Absent when the raw word is outside the corroborated set. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub ret: Option, + /// The raw return-type word, kept beside the decoding so a build that renumbers `ScriptDataType_t` + /// can be re-read rather than silently mis-labelled — the rule `flags_raw` already follows. + pub ret_raw: u16, + /// The implementation address, or the vtable slot when the registration binds a virtual member. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub addr: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub vtable_slot: Option, + /// The prose for the function this binding resolves to — see [`FunctionRecord::doc`]. + /// + /// **Never on disk**, in either direction: it is joined at VIEW time by [`Rosetta::vscript`], which + /// reads it off the record the row was folded onto. That is the whole point of carrying it on the + /// row rather than looking it up by name in an emitter: an UNJOINED row bears a name that belongs + /// to another module's function, so a name lookup would hand it prose about code it is not. + #[serde(skip)] + pub doc: Option, } /// The binding registry's intrinsic identity (no wall-clock field, same rationale as [`MonoMeta`]). @@ -644,6 +859,9 @@ pub struct BindingsMeta { /// Of those, how many carry a recovered typed signature. #[serde(default)] pub pulse_typed: usize, + /// Of those, how many carry a HOST-CALLABLE invocation shim (`call.needs == "args-only"`). + #[serde(default)] + pub pulse_callable: usize, pub entity_inputs: usize, #[serde(default)] pub entity_outputs: usize, @@ -651,6 +869,20 @@ pub struct BindingsMeta { pub entity_classes: usize, #[serde(default)] pub commands: usize, + #[serde(default)] + pub convars: usize, + /// VScript bindings recovered. + #[serde(default)] + pub vscript: usize, + /// Of those, how many were attributed to an owning class. Zero on an offline build by construction — + /// the class is only readable from a running server. + #[serde(default)] + pub vscript_classed: usize, + /// Of those, how many folded into the catalogue as a locator. Lower than `vscript` by the + /// bindings whose implementation did not resolve and the handful whose C++ name is registered at + /// more than one address — dropped, not guessed, exactly as the datadesc handlers are. + #[serde(default)] + pub vscript_located: usize, } impl Bindings { @@ -664,8 +896,7 @@ impl Bindings { } // =========================================================================================== -// The prototype manifest — the shipped `abi-.json`. What a function TAKES, which the gamedata -// deliberately does not answer: a locator says where a function is, a prototype says how to call it, and +// The prototype manifest — what a function TAKES, which a locator deliberately does not answer: a locator says where a function is, a prototype says how to call it, and // the two have different sources and different lifetimes. Declarations are static and human-sourced; // the VERDICT on each one is re-measured against every build. // =========================================================================================== @@ -716,7 +947,9 @@ impl AbiStatus { /// One function's declared prototype and the verdict this build gives it. #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] pub struct AbiEntry { - /// Which shipped tier the function is in. + /// Which shipped tier the function is in. Cleared when folded onto a [`FunctionRecord`], which + /// states it already. + #[serde(default, skip_serializing_if = "String::is_empty")] pub tier: String, /// `exact` — the declaration names this function; `bare-name` — it names the same METHOD on some /// class, claimed only because exactly one declaration bears that name and a measurement could @@ -764,9 +997,23 @@ pub struct AbiEntry { /// a smaller emittable set, never a guessed receiver. #[serde(default, skip_serializing_if = "Option::is_none")] pub vtable: Option, + /// The prose for this function — see [`FunctionRecord::doc`]. **Never on disk**: joined at VIEW + /// time by [`Rosetta::abi_manifest`], off the record this prototype belongs to, so that the call + /// sites a framework generates can carry it into an editor's tooltip. + #[serde(skip)] + pub doc: Option, } impl AbiEntry { + /// Drop what the function record states for itself. The tier and the measured footprint the verdict + /// was reached against are both fields of the record this is folded onto — carrying them here too + /// would give one fact two homes, and two homes is how they come to disagree. + fn into_record_prototype(mut self) -> AbiEntry { + self.tier.clear(); + self.derived = None; + self + } + /// An entry with only the fields every verdict carries — the base for functional-update construction. pub fn blank() -> Self { Self { @@ -782,6 +1029,7 @@ impl AbiEntry { note: None, overloads: None, vtable: None, + doc: None, } } } @@ -795,7 +1043,8 @@ pub struct AbiMeta { pub counts: BTreeMap, } -/// The shipped `abi-.json`. +/// Every declared prototype this build could judge — [`merge`] folds each onto its function as +/// [`FunctionRecord::prototype`]. #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] pub struct AbiManifest { pub meta: AbiMeta, @@ -816,7 +1065,7 @@ pub struct Field { } /// How a schema field holds its value — a closed runtime domain (Source-2 `CSchemaType` category). -/// Serializes to lowercase tokens, the values `netvars-.json` consumers expect. +/// Serializes to lowercase tokens, the values a schema consumer expects. #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)] #[serde(rename_all = "snake_case")] pub enum FieldKind { @@ -905,7 +1154,7 @@ pub struct EnumDef { pub values: Vec, } -/// The typed schema — the shipped `netvars-.json`. Merges field offsets with runtime types: +/// The typed schema, ships as the artifact's `schema` section. Merges field offsets with runtime types: /// class -> field -> [`Field`], plus the enum vocabulary those fields refer to. #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] pub struct Schema { @@ -939,6 +1188,1066 @@ pub struct SchemaMeta { pub types: usize, } +// =========================================================================================== +// The merged release artifact — the shipped `rosetta-.json`. ONE record per function, joining +// what the four derivation stages each know about it: where it is, what its machine code was measured +// to take, what a declaration says it takes, what the binary declares may be done with it, and what it +// means. Those are separate STAGES with separate confidence, not separate artifacts: keyed by name, +// they describe one thing, and a consumer answering "may I call this, and how" needed all four open at +// once to find out. +// +// The split that survives is between what is FUNCTION-KEYED and what is not. A Pulse binding names no +// C++ function, an entity output is a member rather than a method, and a classname maps names to names +// — none of those has a function record to live on, so they stay whole under `surfaces`. +// =========================================================================================== + +/// Which shipped tier a function record came from — the section names of the tiered catalogue, kept as +/// a per-record field now that the tiers are no longer separate maps. +#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum Section { + Core, + HighConfidence, + Experimental, +} + +impl Section { + /// The section's id, the same string the serialization emits. + pub fn as_str(self) -> &'static str { + match self { + Section::Core => "core", + Section::HighConfidence => "high_confidence", + Section::Experimental => "experimental", + } + } +} + +/// What a function is FOR, in plain language, for a reader who has the locator and still does not know +/// what the function does. +/// +/// Keyed on the NAME rather than any locator, and deliberately SIGNATURE-FREE: arity, types and verdicts +/// live in [`FunctionRecord::prototype`] and are joined at render time, so a prototype changing under a +/// new build cannot make a description wrong. +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +pub struct Description { + pub text: String, + /// How the text was arrived at — `derived` where the surrounding facts fix the meaning mechanically, + /// `generated` otherwise. Valve's own prose is NOT carried here: it rides the binding it came with, + /// and duplicating it would create a second place for one fact to go stale. + pub source: String, +} + +/// One function's prose as an emitter prints it: the text, and where it came from. +/// +/// Distinct from [`Description`] because it is a RESOLVED view over every place prose can live. A +/// `Description` is what this artifact authored; a `Doc` may equally be Valve's own text, lifted off the +/// binding that carried it. `source` says which, and every emitter prints it beside the text — a plugin +/// author acting on a sentence must never have to guess whether Valve wrote it or this project did. +#[derive(Clone, Debug)] +pub struct Doc { + /// Collapsed to ONE line (see [`one_line`]): every target embeds this in a comment, and two of the + /// three comment syntaxes involved end at a newline. + pub text: String, + /// [`Doc::VALVE`], or the authored [`Description::source`] id. + pub source: String, +} + +impl Doc { + /// The `source` of text the binary itself carries. Not a value [`Description::source`] ever holds — + /// Valve's prose rides its binding — so it cannot collide with an authored id. + pub const VALVE: &'static str = "valve"; +} + +/// Collapse every whitespace run to a single space. +/// +/// Load-bearing rather than cosmetic: 78 CS2 and 82 Dota descriptions contain a newline, and both the +/// C# `///` and the C++ `//` comment forms END at one — an unflattened description would put the rest +/// of Valve's sentence into the generated source as code. +pub(crate) fn one_line(s: &str) -> String { + s.split_whitespace().collect::>().join(" ") +} + +/// What the binary itself declares may be done with this function, where it declares anything at all. +/// +/// Internally tagged, because the three cases carry genuinely different fields and a consumer switches on +/// which one it got: an entity-IO handler answers a name a map fires, a console handler answers a command +/// an operator types, and a VScript binding is the same function exposed to the script VM under another +/// name with Valve's own documentation attached. +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +#[serde(tag = "kind", rename_all = "kebab-case")] +pub enum FunctionBinding { + EntityInput { + /// The input name entity IO addresses — `Kill`, `Enable`, `SetSpeed`. + input: String, + /// The owning class where the datadesc array's field descriptors identified one. + class: Option, + }, + Command { + command: String, + /// Valve's own help text, `null` where the registration passes none. + description: Option, + /// FCVAR bits with a measured meaning, `null` where the word sets none of them. + flags: Option>, + /// The raw flags word, kept beside the decoding so a build that repurposes a bit can be re-read. + flags_raw: String, + /// How the registration passed its callback — `direct`, `interface`, `member`. + callback_form: String, + }, + Vscript { + /// What a Lua author types, as opposed to the C++ name this record is keyed by. + script_name: String, + class: Option, + description: Option, + ret: Option, + ret_raw: u16, + }, +} + +/// One function, everything the release knows about it. +/// +/// The locator is flattened in exactly as the tiered catalogue flattened it, so a consumer that only +/// wants an address reads the same shape as before. Everything after it is a different KIND of fact, and +/// the field names say which: `measured` is read out of this build's machine code, `prototype` is a human +/// declaration judged against that measurement, `binding` is the binary's own declaration about the +/// function, and `description` is authored prose. +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +pub struct FunctionRecord { + pub tier: Section, + #[serde(flatten)] + pub locator: Entry, + /// The SysV argument footprint read out of this build — see [`AbiShape`]. Absent when the address + /// was not resolvable offline. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub measured: Option, + /// Live-validation verdict, and it is THREE-VALUED: `true` passed, `false` dropped confident-bad, + /// `null` not checked here. Always emitted, never skipped — `null` is a statement (an offline build, + /// a library the vanilla server does not map, a non-vtable class) and an absent key would leave a + /// reader unable to tell it from a field this artifact forgot. + #[serde(default)] + pub validated: Option, + /// The other shipped names for this same function — see [`MonoEntry::aliases`]. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub aliases: Vec, + pub provenance: Provenance, + /// The declared prototype and this build's verdict on it, where one was declared. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub prototype: Option, + /// What the binary declares may be done with this function — a LIST, because one function can be + /// several of them: `AddOutput` is registered on three classes at once, and a console name can be + /// registered by more than one library. Keeping only the last would assert one class as the class. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub bindings: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub description: Option, +} + +impl FunctionRecord { + /// The one piece of prose to print above this function, resolved across every place prose can be. + /// + /// **Valve's own text always wins.** It is a statement by the people who wrote the function, read + /// out of the binary's own registries; [`Description`] is this project's reading of the build, and a + /// reading has no business overriding the source. So a generated description FILLS A GAP and never + /// displaces one — which also means the two can never disagree in a shipped output. + /// + /// Between Valve's two registries the VScript one wins, because the two describe different things: a + /// script binding's description documents the FUNCTION, while a console registration's help text + /// documents the COMMAND that reaches it ("`sv_cheats <0/1>` — enable cheats") and is written for an + /// operator typing it, not a caller. + /// + /// `None` where nothing describes the function at all, which is the majority: 5,287 of 8,361 CS2 + /// records. An emitter renders those exactly as it did before descriptions existed. + pub fn doc(&self) -> Option { + // Empty is not documented: a registration that passes an empty help string has said nothing, + // and skipping it here is what lets the search fall through to the next binding — and then to + // the generated text — instead of stopping on a blank. + let valve = |want_vscript: bool| { + self.bindings.iter().find_map(|b| { + match b { + FunctionBinding::Vscript { description, .. } if want_vscript => { + description.as_deref() + } + FunctionBinding::Command { description, .. } if !want_vscript => { + description.as_deref() + } + _ => None, + } + .filter(|d| !d.is_empty()) + }) + }; + if let Some(text) = valve(true).or_else(|| valve(false)) { + return Some(Doc { + text: one_line(text), + source: Doc::VALVE.to_string(), + }); + } + self.description.as_ref().map(|d| Doc { + text: one_line(&d.text), + source: d.source.clone(), + }) + } +} + +/// The typed schema, as a section of the merged artifact. +/// +/// **Live-only.** Field types are runtime-resolved, so an offline build has no schema to state — which is +/// why [`Rosetta::schema`] is an explicit `null` rather than an absent key: absence would be +/// indistinguishable from a build that resolved zero classes. +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +pub struct SchemaSection { + pub classes: BTreeMap>, + pub bases: Option>>, + pub enums: Option>, + pub types: Option>, + pub meta: Option, +} + +impl From for SchemaSection { + fn from(s: Schema) -> Self { + fn opt(m: BTreeMap) -> Option> { + (!m.is_empty()).then_some(m) + } + SchemaSection { + classes: s.classes, + bases: opt(s.bases), + enums: opt(s.enums), + types: opt(s.types), + meta: Some(s.meta), + } + } +} + +/// The declared surfaces that are NOT function-keyed, so cannot fold into a function record. +/// +/// Each is here for its own reason rather than as a leftovers bin: a Pulse binding does not name a C++ +/// function at all (its `shim` is an entry point into Valve's marshalling, not the bound method), an +/// entity output is a member offset rather than a method, a classname binds one name to another, a +/// ConVar is configuration rather than code, and an unlocated VScript binding is documentation for a +/// function this build could not place. +#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)] +pub struct Surfaces { + #[serde(default)] + pub pulse: BTreeMap, + #[serde(default)] + pub entity_outputs: Vec, + #[serde(default)] + pub entity_classes: BTreeMap, + #[serde(default)] + pub convars: Vec, + /// Declared rows that belong to no function record here. See [`Unjoined`]. + #[serde(default)] + pub unjoined: Unjoined, +} + +/// What the binary declares about functions this build does not describe — the other side of the +/// function-keyed joins, kept rather than dropped so the merge loses nothing the deriver read. +/// +/// Two things put a row here, and they are different in kind. Either **nothing located it**: the +/// implementation did not resolve, or the handler's name was ambiguous and was dropped rather than +/// guessed. Or **the name belongs to another module's function**: a console name registered by two +/// libraries, or a script name registered in three, is several functions, while the catalogue holds one +/// entry under that name — so the rows from the other modules describe code this artifact does not +/// locate, and asserting them onto the one record it does would be a claim about the wrong function. +/// +/// Each row keeps its own `library` and `addr`, which is what tells the two cases apart. +#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)] +pub struct Unjoined { + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub entity_inputs: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub commands: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub vscript: Vec, +} + +/// How many records each join reached — reported so a collapse in any one of them is visible in the +/// artifact rather than only in a derive log. +#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)] +pub struct Joined { + pub prototypes: usize, + pub bindings: JoinedBindings, + pub descriptions: usize, +} + +#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)] +pub struct JoinedBindings { + #[serde(rename = "entity-input")] + pub entity_input: usize, + pub command: usize, + pub vscript: usize, +} + +/// The merged artifact's identity — the catalogue's own release identity plus what the merge joined. +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +pub struct RosettaMeta { + pub game_key: String, + pub game: String, + pub source_build: String, + pub version: String, + pub counts: Counts, + pub alias_groups: usize, + pub aliased_names: usize, + pub merged: bool, + pub joined: Joined, +} + +/// The shipped `rosetta-.json` — one file, one record per function. +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +pub struct Rosetta { + pub meta: RosettaMeta, + pub functions: BTreeMap, + /// Catalogued but not produced this build — no locator, so not a function record. + pub unresolved: BTreeMap, + /// `None` on an offline build, serialized as an explicit `null`. See [`SchemaSection`]. + pub schema: Option, + pub surfaces: Surfaces, +} + +impl Rosetta { + /// The locators alone, at a confidence tier — what a framework's LOADER resolves through. + /// + /// Drops entries live validation confidently rejected, the same rule the tiered catalogue applied: + /// a `validated: false` entry is one the running server disagreed with, and shipping it into a + /// loader would hand a consumer an address the deriver already knows is wrong. + pub fn gamedata(&self, select: TierSelect) -> Gamedata { + let keep = |t: Section| match select { + TierSelect::Core => t == Section::Core, + TierSelect::HighConfidence => t != Section::Experimental, + TierSelect::Experimental => true, + }; + Gamedata { + entries: self + .functions + .iter() + .filter(|(_, r)| keep(r.tier) && r.validated != Some(false)) + .map(|(n, r)| (n.clone(), r.locator.clone())) + .collect(), + game_key: self.meta.game_key.clone(), + } + } + + /// The tiered catalogue view — the shape the CS# combined renderer works from, which needs the tiers + /// as separate sections in order to banner them differently. + pub fn to_monolith(&self) -> Monolith { + let mut m = Monolith { + meta: MonoMeta { + game_key: self.meta.game_key.clone(), + game: self.meta.game.clone(), + source_build: self.meta.source_build.clone(), + version: self.meta.version.clone(), + counts: self.meta.counts.clone(), + alias_groups: self.meta.alias_groups, + aliased_names: self.meta.aliased_names, + }, + core: BTreeMap::new(), + high_confidence: BTreeMap::new(), + experimental: BTreeMap::new(), + unresolved: self.unresolved.clone(), + }; + for (name, r) in &self.functions { + let section = match r.tier { + Section::Core => &mut m.core, + Section::HighConfidence => &mut m.high_confidence, + Section::Experimental => &mut m.experimental, + }; + section.insert( + name.clone(), + MonoEntry { + locator: r.locator.clone(), + abi: r.measured.clone(), + provenance: r.provenance.clone(), + validated: r.validated, + aliases: r.aliases.clone(), + }, + ); + } + m + } + + /// The declared prototypes, as the manifest the call-site emitters consume. + /// + /// `tier` and `derived` are restored from the record, which is where the merge moved them — the + /// receiver test in `render::callable_shapes` reads the measured footprint, so a view that dropped + /// it would quietly emit fewer call sites than the data supports. `doc` is joined the same way, and + /// is what puts a sentence in a plugin author's editor tooltip rather than only in the artifact. + pub fn abi_manifest(&self) -> AbiManifest { + AbiManifest { + meta: AbiMeta { + game_key: self.meta.game_key.clone(), + source_build: self.meta.source_build.clone(), + counts: BTreeMap::new(), + }, + functions: self + .functions + .iter() + .filter_map(|(n, r)| { + let p = r.prototype.as_ref()?; + Some(( + n.clone(), + AbiEntry { + tier: r.tier.as_str().to_string(), + derived: r.measured.clone(), + doc: r.doc(), + ..p.clone() + }, + )) + }) + .collect(), + } + } + + /// The VScript registry, whole: the members folded onto functions plus the ones that joined nowhere. + /// + /// Both belong in a rendered API — a member Valve documents is part of the surface a script author + /// sees whether or not this build located its implementation. + /// + /// A folded row also picks up its function's [`doc`](FunctionRecord::doc); an unjoined one does not, + /// and must not. Its C++ name may be a name another module's function also bears, so prose looked up + /// by that name would describe code this row is not — the same trap the merge itself refuses. + pub fn vscript(&self) -> Vec { + let mut out: Vec = self + .functions + .iter() + .flat_map(|(cpp, r)| { + r.bindings.iter().filter_map(move |b| match b { + FunctionBinding::Vscript { + script_name, + class, + description, + ret, + ret_raw, + } => Some(VScriptBinding { + name: script_name.clone(), + class: class.clone(), + cpp: cpp.clone(), + library: r + .locator + .signature + .as_ref() + .map(|s| s.library.clone()) + .unwrap_or_default(), + description: description.clone().unwrap_or_default(), + ret: ret.clone(), + ret_raw: *ret_raw, + addr: r.provenance.addr.clone(), + vtable_slot: None, + doc: r.doc(), + }), + _ => None, + }) + }) + .collect(); + out.extend(self.surfaces.unjoined.vscript.iter().cloned()); + out + } + + /// The typed schema as its own model — `None` on an offline build, where there is no schema to state. + pub fn typed_schema(&self) -> Option { + let s = self.schema.as_ref()?; + Some(Schema { + meta: s.meta.clone().unwrap_or(SchemaMeta { + game_key: self.meta.game_key.clone(), + source_build: self.meta.source_build.clone(), + typed: 0, + untyped: 0, + enums: 0, + types: 0, + }), + classes: s.classes.clone(), + bases: s.bases.clone().unwrap_or_default(), + enums: s.enums.clone().unwrap_or_default(), + types: s.types.clone().unwrap_or_default(), + }) + } +} + +/// Fold the derivation's four outputs into one artifact. +/// +/// A pure function of the models — it reads nothing from disk and infers nothing new, so every field in +/// the result is one a stage already produced. That is what makes the shape checkable against an +/// independent merge of the same inputs. +/// +/// Joins are by NAME, and a record that finds no home is not silently dropped: an unjoinable VScript +/// row lands in [`Surfaces::unjoined`], so the merge is lossless: every declared row is either on the +/// function it describes or stated as a surface, and [`Joined`] counts which. +pub fn merge( + mono: Monolith, + abi: Option, + bindings: Option, + schema: Option, + descriptions: BTreeMap, +) -> Rosetta { + let Monolith { + meta, + core, + high_confidence, + experimental, + unresolved, + } = mono; + + let mut functions: BTreeMap = BTreeMap::new(); + for (tier, section) in [ + (Section::Core, core), + (Section::HighConfidence, high_confidence), + (Section::Experimental, experimental), + ] { + for (name, e) in section { + // Most-confident tier first, and FIRST WRITER WINS. The tiers are disjoint upstream, so this + // never fires — but if one ever did carry a name twice, keeping the first means a `core` + // function cannot be relabelled as an `experimental` guess by iteration order alone. + functions.entry(name).or_insert(FunctionRecord { + tier, + locator: e.locator, + measured: e.abi, + validated: e.validated, + aliases: e.aliases, + provenance: e.provenance, + prototype: None, + bindings: Vec::new(), + description: None, + }); + } + } + + let mut joined = Joined::default(); + + // The DECLARED prototype beside the MEASURED footprint: two different kinds of fact about one + // function, and the verdict on the first is reached against the second. + if let Some(abi) = abi { + for (name, row) in abi.functions { + if let Some(rec) = functions.get_mut(&name) { + rec.prototype = Some(row.into_record_prototype()); + joined.prototypes += 1; + } + } + } + + let mut surfaces = Surfaces::default(); + if let Some(b) = bindings { + // A name is only unique WITHIN a module: `AddOutput` is registered in three libraries and + // `cl_particles_dumplist` in two, each a different function, while the catalogue holds one entry + // under that name. Attaching every registration to that one record would assert bindings that + // belong to code it does not locate — the bare-name trap, from the other direction. So a row is + // attached only when the record cannot contradict it: same library, or a record whose locator is + // a vtable slot and therefore names no library at all. + let joins = |rec: &FunctionRecord, lib: &str| { + rec.locator + .signature + .as_ref() + .is_none_or(|sig| sig.library == lib) + }; + for r in b.entity_inputs { + let key = match &r.class { + Some(c) => format!("{c}::{}", r.handler), + None => r.handler.clone(), + }; + match functions.get_mut(&key).filter(|rec| joins(rec, &r.library)) { + Some(rec) => { + rec.bindings.push(FunctionBinding::EntityInput { + input: r.input.clone(), + class: r.class.clone(), + }); + joined.bindings.entity_input += 1; + } + None => surfaces.unjoined.entity_inputs.push(r), + } + } + for c in b.commands { + let key = format!("ConCommand::{}", c.name); + match functions.get_mut(&key).filter(|rec| joins(rec, &c.library)) { + Some(rec) => { + rec.bindings.push(FunctionBinding::Command { + command: c.name, + description: none_if_empty(c.description), + flags: (!c.flags.is_empty()).then_some(c.flags), + flags_raw: c.flags_raw, + callback_form: c.form, + }); + joined.bindings.command += 1; + } + None => surfaces.unjoined.commands.push(c), + } + } + for v in b.vscript { + match functions + .get_mut(&v.cpp) + .filter(|rec| joins(rec, &v.library)) + { + Some(rec) => { + rec.bindings.push(FunctionBinding::Vscript { + script_name: v.name, + class: v.class, + description: none_if_empty(v.description), + ret: v.ret, + ret_raw: v.ret_raw, + }); + joined.bindings.vscript += 1; + } + None => surfaces.unjoined.vscript.push(v), + } + } + surfaces.pulse = b.pulse; + surfaces.entity_outputs = b.entity_outputs; + surfaces.entity_classes = b.entity_classes; + surfaces.convars = b.convars; + } + + for (name, d) in descriptions { + if let Some(rec) = functions.get_mut(&name) { + rec.description = Some(d); + joined.descriptions += 1; + } + } + + Rosetta { + meta: RosettaMeta { + game_key: meta.game_key, + game: meta.game, + source_build: meta.source_build, + version: meta.version, + counts: meta.counts, + alias_groups: meta.alias_groups, + aliased_names: meta.aliased_names, + merged: true, + joined, + }, + functions, + unresolved, + schema: schema.map(SchemaSection::from), + surfaces, + } +} + +/// An empty string is the artifact's way of saying a source supplied nothing; the merged record says so +/// with `null` instead, so a reader never has to know which spelling of absence a given surface used. +fn none_if_empty(s: String) -> Option { + (!s.is_empty()).then_some(s) +} + +#[cfg(test)] +mod merge_tests { + use super::*; + use serde_json::json; + + /// Fixtures are built by DESERIALIZING the artifact shapes, so a test states what a reader sees on + /// disk rather than which constructor the deriver happened to use. + fn from serde::Deserialize<'de>>(v: serde_json::Value) -> T { + serde_json::from_value(v).expect("fixture parses as the artifact shape") + } + + /// The keys of a serialized object, IN THE ORDER WRITTEN. `serde_json::Value` cannot answer this — + /// its map is key-sorted — and the order is part of what the artifact promises, so it is read back + /// off the text the way a consumer diffing two releases would see it. + fn field_order(json: &str) -> Vec { + let (mut keys, mut depth, mut in_str, mut esc, mut cur) = + (Vec::new(), 0i32, false, false, String::new()); + for c in json.chars() { + if in_str { + match c { + _ if esc => esc = false, + '\\' => esc = true, + '"' => in_str = false, + _ if depth == 1 => cur.push(c), + _ => {} + } + continue; + } + match c { + '"' => { + in_str = true; + cur.clear(); + } + ':' if depth == 1 && !cur.is_empty() => keys.push(std::mem::take(&mut cur)), + '{' | '[' => depth += 1, + '}' | ']' => depth -= 1, + _ => {} + } + } + keys + } + + fn mono(entries: serde_json::Value) -> Monolith { + from(json!({ + "meta": { "game_key": "csgo", "game": "CS2", "source_build": "b", "version": "cs2-1-0", + "counts": { "core": 1, "high_confidence": 1, "experimental": 0, "unresolved": 0 } }, + "core": entries, + "high_confidence": {}, "experimental": {}, "unresolved": {}, + })) + } + + #[test] + fn merge_folds_every_stage_onto_one_record() { + let m = mono(json!({ + "ConCommand::bot_add": { + "signature": { "library": "server", "linux": "55 48" }, + "abi": { "int": 2, "float": 0, "ret": "ret=int" }, + "provenance": { "tier": "valve-table" }, + "validated": true, + } + })); + let abi: AbiManifest = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "counts": {} }, + "functions": { "ConCommand::bot_add": { + "tier": "core", "matched_by": "engine-contract", "status": "verified", + "params": ["CCommandContext*"], "ret": "void" } }, + })); + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, + "entity_inputs": [], + "commands": [{ "name": "bot_add", "library": "server", "description": "adds a bot", + "flags": ["release"], "flags_raw": "0x4", "form": "direct", + "addr": "0x1" }], + })); + let desc: BTreeMap = from(json!({ + "ConCommand::bot_add": { "text": "Adds a bot.", "source": "generated" } + })); + + let r = merge(m, Some(abi), Some(bindings), None, desc); + assert_eq!(r.meta.joined.prototypes, 1); + assert_eq!(r.meta.joined.bindings.command, 1); + assert_eq!(r.meta.joined.descriptions, 1); + + // The locator stays flattened, and every other stage is a named field beside it — which is the + // whole shape claim: one record, four kinds of fact, each labelled by where it came from. + let rec_json = serde_json::to_string(&r.functions["ConCommand::bot_add"]).unwrap(); + assert_eq!( + field_order(&rec_json), + [ + "tier", + "signature", + "measured", + "validated", + "provenance", + "prototype", + "bindings", + "description" + ] + ); + let v = serde_json::to_value(&r).unwrap(); + let rec = &v["functions"]["ConCommand::bot_add"]; + assert_eq!(rec["tier"], "core"); + assert_eq!(rec["measured"]["int"], 2); + assert_eq!(rec["prototype"]["status"], "verified"); + assert_eq!(rec["bindings"][0]["kind"], "command"); + assert_eq!(rec["bindings"][0]["command"], "bot_add"); + // the prototype sheds what the record already says + assert!(rec["prototype"].get("tier").is_none()); + assert!(rec["prototype"].get("derived").is_none()); + assert_eq!(rec["description"]["source"], "generated"); + assert!(v["schema"].is_null()); // offline: an explicit null, never an absent key + } + + #[test] + fn a_source_that_supplied_nothing_reads_as_null_not_as_empty() { + let m = mono(json!({ "ConCommand::x": { "offset": 3, "provenance": { "tier": "core" } } })); + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, "entity_inputs": [], + "commands": [{ "name": "x", "library": "server", "flags_raw": "0x0", "form": "direct", + "addr": "0x1" }], + })); + let v = + serde_json::to_value(merge(m, None, Some(bindings), None, BTreeMap::new())).unwrap(); + let b = &v["functions"]["ConCommand::x"]["bindings"][0]; + assert!(b["description"].is_null()); + assert!(b["flags"].is_null()); + assert_eq!(b["flags_raw"], "0x0"); + } + + #[test] + fn a_binding_from_another_library_is_not_asserted_onto_this_function() { + // One name, three registrations, three different functions — the catalogue holds the `server` + // one. The other two describe code this build does not locate, so they must not become claims + // about the function it does. + let m = mono(json!({ "AddOutput": { + "signature": { "library": "server", "linux": "55" }, + "provenance": { "tier": "core" } } })); + let row = |lib: &str| { + json!({ "name": "AddOutput", "cpp": "AddOutput", "class": "CNativeOutputs", + "library": lib, "ret_raw": 0 }) + }; + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, "entity_inputs": [], + "vscript": [row("server"), row("engine2"), row("worldrenderer")], + })); + let r = merge(m, None, Some(bindings), None, BTreeMap::new()); + assert_eq!(r.meta.joined.bindings.vscript, 1); + assert_eq!(r.functions["AddOutput"].bindings.len(), 1); + assert_eq!(r.surfaces.unjoined.vscript.len(), 2); + } + + #[test] + fn the_views_hand_each_emitter_what_it_reads() { + let mut m = mono(json!({ + "A::keep": { "signature": { "library": "server", "linux": "55" }, + "abi": { "int": 2, "float": 0, "ret": "ret=int" }, + "provenance": { "tier": "core" }, "validated": true }, + "A::rejected": { "offset": 9, "provenance": { "tier": "core" }, "validated": false }, + })); + // a guess, which `core` must not include + m.experimental.insert( + "A::guess".into(), + from(json!({ "offset": 4, "provenance": { "tier": "low" }, "validated": null })), + ); + let abi: AbiManifest = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "counts": {} }, + "functions": { "A::keep": { "tier": "core", "matched_by": "exact", "status": "verified", + "params": ["int"] } }, + })); + let r = merge(m, Some(abi), None, None, BTreeMap::new()); + + // the locator half: tier-filtered, and an entry live validation rejected is not a locator + let core = r.gamedata(TierSelect::Core); + assert_eq!(core.entries.keys().collect::>(), ["A::keep"]); + assert_eq!( + r.gamedata(TierSelect::Experimental).entries.len(), + 2 // keep + guess; the rejected one stays out at every tier + ); + + // the prototype half: the two fields the merge moved onto the record are restored, because the + // receiver test in `render::callable_shapes` reads the measurement + let man = r.abi_manifest(); + let e = &man.functions["A::keep"]; + assert_eq!(e.tier, "core"); + assert_eq!(e.derived.as_ref().map(|d| d.int), Some(2)); + assert_eq!(man.meta.game_key, "csgo"); + } + + #[test] + fn the_script_api_view_carries_the_members_that_joined_and_the_ones_that_did_not() { + let m = mono( + json!({ "Script_Kill": { "signature": { "library": "server", "linux": "55" }, + "provenance": { "tier": "core", "addr": "0x1" } } }), + ); + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, "entity_inputs": [], + "vscript": [ + { "name": "Kill", "cpp": "Script_Kill", "class": "CBaseEntity", "library": "server", + "description": "Kills it", "ret": "void", "ret_raw": 0 }, + { "name": "Gone", "cpp": "Script_Gone", "class": "CBaseEntity", "library": "server", + "ret_raw": 0 }, + ], + })); + let r = merge(m, None, Some(bindings), None, BTreeMap::new()); + let vs = r.vscript(); + assert_eq!(vs.len(), 2); // one on its function, one unjoined — both are surface a script sees + let joined = vs.iter().find(|v| v.cpp == "Script_Kill").unwrap(); + assert_eq!(joined.name, "Kill"); + assert_eq!(joined.description, "Kills it"); + assert_eq!(joined.library, "server"); // taken from the record's own locator + assert!(vs.iter().any(|v| v.cpp == "Script_Gone")); + assert!(r.typed_schema().is_none()); // offline: nothing to render a schema from + } + + #[test] + fn valves_own_text_always_wins_and_a_generated_one_only_fills_a_gap() { + let vs = |cpp: &str, desc: &str| { + json!({ "name": "N", "cpp": cpp, "class": "C", "library": "server", + "description": desc, "ret_raw": 0 }) + }; + let m = mono(json!({ + "ConCommand::documented": { "offset": 1, "provenance": { "tier": "core" } }, + "ConCommand::help_only": { "offset": 2, "provenance": { "tier": "core" } }, + "ConCommand::ours": { "offset": 3, "provenance": { "tier": "core" } }, + "ConCommand::silent": { "offset": 4, "provenance": { "tier": "core" } }, + })); + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, "entity_inputs": [], + // Both registries describe the first one. A console help string documents the COMMAND an + // operator types; the script registry documents the FUNCTION, so it is the one that wins. + "commands": [ + { "name": "documented", "library": "server", "flags_raw": "0x0", "form": "direct", + "addr": "0x1", "description": "type `documented 1` to do the thing" }, + { "name": "help_only", "library": "server", "flags_raw": "0x0", "form": "direct", + "addr": "0x2", "description": "Valve's help text" }, + ], + "vscript": [ + // The first binding carries nothing: an empty registration has said nothing, so the + // search must fall THROUGH it rather than stop on a blank. + vs("ConCommand::documented", ""), + vs("ConCommand::documented", "Valve's script prose"), + ], + })); + let desc: BTreeMap = from(json!({ + "ConCommand::documented": { "text": "ours, and outranked", "source": "generated" }, + "ConCommand::help_only": { "text": "ours, and outranked", "source": "generated" }, + "ConCommand::ours": { "text": "a\nreading\tof this build", "source": "generated" }, + })); + let r = merge(m, None, Some(bindings), None, desc); + let doc = |n: &str| r.functions[n].doc(); + + let d = doc("ConCommand::documented").unwrap(); + assert_eq!(d.text, "Valve's script prose"); + assert_eq!(d.source, Doc::VALVE); + let d = doc("ConCommand::help_only").unwrap(); + assert_eq!(d.text, "Valve's help text"); + assert_eq!(d.source, Doc::VALVE); + // Ours fills a gap, keeps its own source id, and arrives as ONE line whatever it was authored + // as — every target embeds it in a comment, and two of the three end at a newline. + let d = doc("ConCommand::ours").unwrap(); + assert_eq!(d.text, "a reading of this build"); + assert_eq!(d.source, "generated"); + // Nothing describes it, which is the majority case: an emitter renders it as it always did. + assert!(doc("ConCommand::silent").is_none()); + } + + #[test] + fn prose_reaches_the_emitters_by_the_record_it_belongs_to_never_by_its_name() { + // The same trap the merge itself refuses, one layer up: an UNJOINED row bears a name that + // belongs to another module's function, so a view that looked prose up by name would hand it a + // sentence about code it is not. + let m = mono( + json!({ "GetName": { "signature": { "library": "server", "linux": "55" }, + "provenance": { "tier": "core", "addr": "0x1" } } }), + ); + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, "entity_inputs": [], + "vscript": [ + { "name": "GetName", "cpp": "GetName", "class": "C", "library": "server", + "ret_raw": 0 }, + { "name": "GetName", "cpp": "GetName", "class": "C", "library": "engine2", + "ret_raw": 0 }, + ], + })); + let desc: BTreeMap = from(json!({ + "GetName": { "text": "the server one", "source": "generated" } + })); + let r = merge(m, None, Some(bindings), None, desc); + + let vs = r.vscript(); + let joined = vs.iter().find(|v| v.library == "server").unwrap(); + assert_eq!( + joined.doc.as_ref().map(|d| d.text.as_str()), + Some("the server one") + ); + let elsewhere = vs.iter().find(|v| v.library == "engine2").unwrap(); + assert!(elsewhere.doc.is_none()); + + // The prototype view has no such hazard — it is keyed by the record — so it carries the prose. + let m2 = mono(json!({ "A::k": { "offset": 1, "provenance": { "tier": "core" } } })); + let abi: AbiManifest = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "counts": {} }, + "functions": { "A::k": { "tier": "core", "matched_by": "exact", "status": "verified" } }, + })); + let desc2: BTreeMap = + from(json!({ "A::k": { "text": "t", "source": "derived" } })); + let man = merge(m2, Some(abi), None, None, desc2).abi_manifest(); + assert_eq!( + man.functions["A::k"] + .doc + .as_ref() + .map(|d| d.source.as_str()), + Some("derived") + ); + } + + #[test] + fn the_resolved_prose_is_a_view_and_never_reaches_the_artifact() { + // `doc` is joined at view time from facts the artifact already states. Serializing it would + // give one sentence two homes, and two homes is how they come to disagree. + let m = mono(json!({ "A::k": { "offset": 1, "provenance": { "tier": "core" } } })); + let abi: AbiManifest = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "counts": {} }, + "functions": { "A::k": { "tier": "core", "matched_by": "exact", "status": "verified" } }, + })); + let desc: BTreeMap = + from(json!({ "A::k": { "text": "t", "source": "generated" } })); + let r = merge(m, Some(abi), None, None, desc); + let v = serde_json::to_value(&r).unwrap(); + assert!(v["functions"]["A::k"]["prototype"].get("doc").is_none()); + assert_eq!(v["functions"]["A::k"]["description"]["text"], "t"); + // and the view still produces it from what WAS written + let back: Rosetta = serde_json::from_value(v).unwrap(); + assert_eq!(back.abi_manifest().functions["A::k"].doc.is_some(), true); + } + + #[test] + fn every_declared_row_lands_exactly_once() { + // The merge must not be a filter: a row either describes a function this build ships, or it is + // stated as a surface. Nothing the deriver read may fall out between the two. + let m = mono( + json!({ "ConCommand::a": { "signature": { "library": "server", "linux": "55" }, + "provenance": { "tier": "core" } } }), + ); + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, + "entity_inputs": [{ "input": "Kill", "handler": "nosuchfunction", "library": "server", + "addr": "0x1" }], + "commands": [ + { "name": "a", "library": "server", "flags_raw": "0x0", "form": "direct", "addr": "0x1" }, + { "name": "a", "library": "engine2", "flags_raw": "0x0", "form": "direct", "addr": "0x2" }, + { "name": "b", "library": "server", "flags_raw": "0x0", "form": "direct", "addr": "0x3" }, + ], + "vscript": [{ "name": "K", "cpp": "nope", "library": "server", "ret_raw": 0 }], + })); + let r = merge(m, None, Some(bindings), None, BTreeMap::new()); + let (j, u) = (&r.meta.joined.bindings, &r.surfaces.unjoined); + assert_eq!((j.entity_input, u.entity_inputs.len()), (0, 1)); + assert_eq!((j.command, u.commands.len()), (1, 2)); // one joined; the other library's + the unknown + assert_eq!((j.vscript, u.vscript.len()), (0, 1)); + } + + #[test] + fn a_vtable_located_record_cannot_contradict_a_library_so_it_keeps_the_binding() { + // A slot names no library, so there is nothing to check the row against — and refusing on + // absent evidence would drop bindings for every offset-located function. + let m = mono(json!({ "A::b": { "offset": 3, "provenance": { "tier": "core" } } })); + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, + "entity_inputs": [{ "input": "Kill", "class": "A", "handler": "b", + "library": "engine2", "addr": "0x1" }], + })); + let r = merge(m, None, Some(bindings), None, BTreeMap::new()); + assert_eq!(r.functions["A::b"].bindings.len(), 1); + } + + #[test] + fn a_binding_with_no_function_record_survives_as_a_surface() { + let m = mono(json!({ "A::b": { "offset": 3, "provenance": { "tier": "core" } } })); + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, "entity_inputs": [], + "vscript": [{ "name": "Kill", "cpp": "Script_Kill", "library": "server", "ret_raw": 0 }], + })); + let r = merge(m, None, Some(bindings), None, BTreeMap::new()); + assert_eq!(r.meta.joined.bindings.vscript, 0); + assert_eq!(r.surfaces.unjoined.vscript.len(), 1); + assert_eq!(r.surfaces.unjoined.vscript[0].cpp, "Script_Kill"); + } + + #[test] + fn the_artifact_reads_back_as_what_was_written() { + let m = mono(json!({ "A::b": { + "signature": { "library": "server", "linux": "55" }, + "provenance": { "tier": "core" }, "aliases": ["UTIL::b"] } })); + let bindings: Bindings = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "pulse": 0, "entity_inputs": 0 }, + "pulse": {}, + "entity_inputs": [{ "input": "Kill", "class": "A", "handler": "b", "library": "server", + "addr": "0x1" }], + })); + let schema: Schema = from(json!({ + "meta": { "game_key": "csgo", "source_build": "b", "typed": 1, "untyped": 0 }, + "classes": { "A": { "m_i": { "offset": 4, "size": 4, "name_hash": 7 } } }, + })); + let r = merge(m, None, Some(bindings), Some(schema), BTreeMap::new()); + let back: Rosetta = serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap(); + assert_eq!(back.functions["A::b"].tier, Section::Core); + assert_eq!(back.functions["A::b"].aliases, ["UTIL::b"]); + assert!(matches!( + back.functions["A::b"].bindings[..], + [FunctionBinding::EntityInput { .. }] + )); + assert_eq!(back.schema.unwrap().classes["A"]["m_i"].offset, 4); + } +} + #[cfg(test)] mod monolith_tests { use super::*; @@ -949,14 +2258,16 @@ mod monolith_tests { locator: Entry { signature: None, offset: Some(158), + class: None, + anchors: Vec::new(), }, - class: None, abi: None, provenance: Provenance { source: Some("catalogue".into()), ..Provenance::with_tier(Tier::Core) }, validated: Some(true), + aliases: Vec::new(), }; let v = serde_json::to_value(&e).unwrap(); assert_eq!(v["offset"], 158); // locator flattened to the top level @@ -973,8 +2284,9 @@ mod monolith_tests { locator: Entry { signature: None, offset: Some(40), + class: Some("CFoo".into()), + anchors: Vec::new(), }, - class: Some("CFoo".into()), abi: None, provenance: Provenance { confidence: Some("low".into()), @@ -984,6 +2296,7 @@ mod monolith_tests { ..Provenance::with_tier(Tier::Low) }, validated: None, + aliases: Vec::new(), }; let v = serde_json::to_value(&e).unwrap(); assert_eq!(v["class"], "CFoo"); @@ -1006,6 +2319,8 @@ mod monolith_tests { experimental: 0, unresolved: 1, }, + alias_groups: 0, + aliased_names: 0, }, core: BTreeMap::new(), high_confidence: BTreeMap::new(), @@ -1021,14 +2336,16 @@ mod monolith_tests { linux: "55 48 89 E5".into(), }), offset: None, + class: None, + anchors: Vec::new(), }, - class: None, abi: None, provenance: Provenance { source: Some("catalogue".into()), ..Provenance::with_tier(Tier::Core) }, validated: Some(true), + aliases: Vec::new(), }, ); m.unresolved.insert( diff --git a/crates/source2rosetta-core/src/render.rs b/crates/source2rosetta-core/src/render.rs index 7a057a0..e1f3a66 100644 --- a/crates/source2rosetta-core/src/render.rs +++ b/crates/source2rosetta-core/src/render.rs @@ -3,8 +3,11 @@ //! derivation never changes. This module depends only on `model` + serde, NOT on the deriver, so a //! standalone `source2rosetta-gen` binary can link just this to turn a published model JSON into files. -use crate::model::{Entry, Gamedata, MonoEntry, Monolith, Schema, Tier, TierSelect}; +use crate::model::{ + self, Entry, Gamedata, MonoEntry, Monolith, Schema, Tier, TierSelect, VScriptBinding, one_line, +}; use serde_json::{Map, Value, json}; +use std::collections::BTreeMap; /// Render the monolith as the CounterStrikeSharp combined `gamedata.json`: the guaranteed `core` section, a /// `//` banner, then the extrapolated section (the tiers `select` includes beyond core), both key-sorted with @@ -153,7 +156,15 @@ pub fn entry_from_value(v: &Value) -> Entry { .get("offsets") .and_then(|o| o.get("linux")) .and_then(Value::as_i64); - Entry { signature, offset } + // The cssharp locator shape has no anchor field, so a round-tripped entry carries none. That is a + // boundary, not a loss: every caller of this function reads `.offset` off the result, and the anchor + // path to an emitter runs through `Monolith::select`, which copies the whole `Entry`. + Entry { + signature, + offset, + class: None, + anchors: Vec::new(), + } } /// Look up an emitter by its `--format` id. @@ -169,8 +180,9 @@ pub fn by_id(id: &str) -> Option> { } } -/// Every `--format` id `by_id` accepts — for help text and error messages (keep in sync with `by_id`). -pub const FORMAT_IDS: &[&str] = &[ +/// Every gamedata emitter id `by_id` accepts (keep in sync with it), named like its three sibling +/// families. NOT the `--format` list — see [`FORMAT_IDS`], which names CONSUMERS rather than emitters. +pub const GAMEDATA_FORMAT_IDS: &[&str] = &[ "cssharp", "metamod", "modsharp", "swiftly", "plugify", "model", ]; @@ -275,13 +287,32 @@ impl GamedataEmitter for ModSharp { let (mut addresses, mut vfuncs) = (Map::new(), Map::new()); for (name, e) in &gd.entries { if let Some(s) = &e.signature { - addresses.insert( - name.clone(), - json!({ "library": s.library, "linux": s.linux }), - ); + let mut row = Map::new(); + row.insert("library".into(), Value::String(s.library.clone())); + row.insert("linux".into(), Value::String(s.linux.clone())); + // ModSharp's own `refs` feature: a string this function references, which its loader + // resolves per build. Emitted BESIDE `linux` exactly as their hand-written gamedata does, + // so a build whose byte pattern drifted can still be located. + if !e.anchors.is_empty() { + row.insert("refs".into(), json!({ "strings": e.anchors })); + } + addresses.insert(name.clone(), Value::Object(row)); } if let Some(o) = e.offset { - vfuncs.insert(name.clone(), json!({ "linux": o })); + let mut row = Map::new(); + row.insert("linux".into(), json!(o)); + // `refs.vtable` is ModSharp's own key for "the class whose vtable holds this slot", and a + // slot index without it is not a locator at all. + if let Some(c) = &e.class { + row.insert("refs".into(), json!({ "vtable": c })); + } + vfuncs.insert(name.clone(), Value::Object(row)); + } + // An anchor with no signature is still a usable locator for ModSharp — `refs` alone is how + // several of their own entries are written. Dropping these would discard the only thing we + // know about a function whose byte pattern did not resolve. + if e.signature.is_none() && !e.anchors.is_empty() { + addresses.insert(name.clone(), json!({ "refs": { "strings": e.anchors } })); } } let doc = json!({ "Addresses": addresses, "VFuncs": vfuncs }); @@ -405,10 +436,17 @@ impl SchemaEmitter for CsSdk { let m = &s.meta; let mut out = String::new(); out.push_str(&format!( + // The artifact is named by the GAME TOKEN (`cs2`), which the schema does not carry — it knows + // its content key (`csgo`). So the command is spelled generically rather than interpolated + // into something that does not exist. "// source2rosetta — {} build {}. Source-2 SchemaSystem field offsets.\n\ - // {} classes, {} typed fields, {} enums. Regenerate: source2rosetta-gen --netvars netvars-{}.json --format cs-sdk\n\ + // {} classes, {} typed fields, {} enums. Regenerate: source2rosetta-gen --from rosetta-.json --format cs-sdk\n\ namespace Source2.Schema;\n", - m.game_key, m.source_build, s.classes.len(), m.typed, s.enums.len(), m.game_key + m.game_key, + m.source_build, + s.classes.len(), + m.typed, + s.enums.len() )); // Enums first: a field offset is only half the story, and the C# side wants the type in scope // before the classes that reference it. Emitted with the engine's own underlying width, so a @@ -727,6 +765,10 @@ pub struct CallShape<'a> { /// the signatures section at all. pub vtable: Option, pub provenance: &'a [String], + /// What the function is FOR, where anything says — see [`model::FunctionRecord::doc`]. The one + /// field here that is not about the call frame, and the reason a generated call site is readable: + /// an author hovering `CBaseEntity_Kill` sees a sentence rather than a type list. + pub doc: Option<&'a model::Doc>, } impl CallShape<'_> { @@ -850,6 +892,7 @@ pub fn callable_shapes(m: &crate::model::AbiManifest) -> Vec> { lower_bound, vtable: e.vtable, provenance: &e.provenance, + doc: e.doc.as_ref(), }); } out @@ -886,6 +929,24 @@ const LOWER_BOUND: &str = "ARGUMENTS ARE A LOWER BOUND — the callee reads fewe passes, so a trailing argument may be ignored; calling through it is safe, the extra register is \ simply unread"; +/// What every emitter says about where a description came from. One wording per source, for the same +/// reason as the two constants above: five outputs must not describe one fact differently. +/// +/// The marker is load-bearing, not decoration. Most of a shipped artifact's prose is this project's own +/// reading of the build rather than Valve's, and the two carry very different weight — an author acting +/// on a sentence has to know which they are reading. An id this does not recognise is printed VERBATIM +/// rather than quietly presented as Valve's. +fn doc_origin(source: &str) -> String { + match source { + model::Doc::VALVE => "Valve's own text, read from the registry in the binary".into(), + "derived" => { + "source2rosetta's, DERIVED — fixed by the surrounding facts, not Valve's".into() + } + "generated" => "source2rosetta's, GENERATED — a reading of this build, not Valve's".into(), + other => format!("source2rosetta's, source `{other}` — not Valve's"), + } +} + /// Escape text destined for a C# XML doc comment. /// /// Not cosmetic: the prototypes this carries are full of characters XML reserves. A `CAI_Concept&` @@ -913,6 +974,46 @@ fn source_banner(m: &crate::model::AbiManifest, comment: &str) -> String { ) } +/// The head of the C# XML doc block above one generated call site — everything above the caveats. +/// +/// **The description takes the `` and the prototype moves down to a ``**, because an +/// editor shows the summary first and "what does this thing do" is what an author hovering a +/// `MemoryFunctionVoid` is asking. With no description the shape is exactly what it was +/// before descriptions existed: the prototype IS the summary, and the block is one line. +/// +/// Shared with ModSharp rather than written twice — the two targets differ in what they generate and +/// not in how a function is documented, and two copies of an XML doc block is how they come to disagree. +fn cs_doc_head(c: &CallShape) -> String { + match c.doc { + Some(d) => format!( + " /// {}\n \ + /// {}\n \ + /// Description: {}.", + xml(&d.text), + xml(&c.prototype()), + // Escaped like everything else here: the fixed wordings need none, but an artifact's own + // `source` id ends up in this line verbatim, and one `<` in it is a malformed comment. + xml(&doc_origin(&d.source)), + ), + None => format!(" /// {}", xml(&c.prototype())), + } +} + +/// The caveat remarks that follow it: what this artifact will not let a call site pretend about itself. +fn cs_doc_caveats(c: &CallShape) -> String { + let mut s = String::new(); + if c.ret == Ret::Undeclared { + s.push_str(&format!( + "\n /// {UNDECLARED_RETURN} (measured class: {}).", + xml(c.ret_source) + )); + } + if c.lower_bound { + s.push_str(&format!("\n /// {LOWER_BOUND}.")); + } + s +} + /// CounterStrikeSharp: a C# source file of `MemoryFunction*` fields bound to the gamedata key. /// /// It has to be SOURCE, not data: the argument list is the generic parameter list of @@ -952,17 +1053,6 @@ impl AbiEmitter for CsSharpAbi { "FunctionWithReturn" } }; - let mut caveat = if c.ret == Ret::Undeclared { - format!( - "\n /// {UNDECLARED_RETURN} (measured class: {}).", - xml(c.ret_source) - ) - } else { - String::new() - }; - if c.lower_bound { - caveat.push_str(&format!("\n /// {LOWER_BOUND}.")); - } // The two binding forms are not interchangeable. A signature resolves to ONE address and // can be a static field; a vtable slot is per-object — `VirtualFunction*` takes the // instance and reads the slot out of that object's own vtable — so it has to be a factory @@ -999,11 +1089,10 @@ impl AbiEmitter for CsSharpAbi { None => "signature".to_string(), }; s.push_str(&format!( - " /// {}\n \ - /// verified · {how} · {}{}\n{}", - xml(&c.prototype()), + "{}\n /// verified · {how} · {}{}\n{}", + cs_doc_head(&c), c.provenance.join(", "), - caveat, + cs_doc_caveats(&c), binding, )); } @@ -1070,6 +1159,16 @@ impl AbiEmitter for MetamodAbi { }) .collect::>() .join(", "); + // The prose goes ABOVE the identity line, which is where a C++ reader expects a member's + // documentation and where a `//` comment is safe: the text is one line by construction + // (`model::one_line`), so nothing after it can fall out of the comment and into the header. + if let Some(d) = c.doc { + s.push_str(&format!( + "// {}\n// Description: {}.\n", + d.text, + doc_origin(&d.source) + )); + } s.push_str(&format!( "// {} · verified · {}{}\nusing {}_t = {} (*)({});\n", c.key, @@ -1114,24 +1213,7 @@ impl AbiEmitter for ModSharpAbi { s.push_str("using Sharp.Shared;\nusing Sharp.Shared.Attributes;\nusing Sharp.Shared.Calls;\n\nnamespace Sharp.Generated;\n\n"); let shapes = callable_shapes(m); - let doc = |c: &CallShape| { - let mut caveat = if c.ret == Ret::Undeclared { - format!( - "\n /// {UNDECLARED_RETURN} (measured class: {}).", - xml(c.ret_source) - ) - } else { - String::new() - }; - if c.lower_bound { - caveat.push_str(&format!("\n /// {LOWER_BOUND}.")); - } - format!( - " /// {}{}\n", - xml(&c.prototype()), - caveat - ) - }; + let doc = |c: &CallShape| format!("{}{}\n", cs_doc_head(c), cs_doc_caveats(c)); let ret_cs = |c: &CallShape| match c.ret { Ret::Void => "void", Ret::Declared(r) => r.cs(), @@ -1251,6 +1333,11 @@ impl AbiEmitter for SwiftlyAbi { doc.insert( c.key.to_string(), json!({ + // The prose, and the id saying whose it is — the machine-readable form of the + // marker the generated-source targets print in words. A consumer rendering this + // into its own docs needs to be able to attribute it. + "description": c.doc.map(|d| d.text.clone()), + "description_source": c.doc.map(|d| d.source.clone()), "args": c.params.iter().map(|t| t.swiftly()).collect::(), "ret": match c.ret { Ret::Void => 'v', @@ -1311,6 +1398,9 @@ impl AbiEmitter for PlugifyAbi { fns.insert( c.key.to_string(), json!({ + // As for Swiftly: the text plus whose it is, so a consumer can attribute it. + "description": c.doc.map(|d| d.text.clone()), + "descriptionSource": c.doc.map(|d| d.source.clone()), "paramTypes": c.params.iter().map(|t| plg(*t)).collect::>(), "retType": match c.ret { Ret::Void => "void", @@ -1334,6 +1424,294 @@ impl AbiEmitter for PlugifyAbi { } } +// ============================ VSCRIPT / BINDINGS emitters ============================ + +/// An emitter over `bindings-.json`'s VScript section. +/// +/// A separate family from the gamedata, schema and ABI emitters because it renders a different INPUT: +/// the script-facing surface, grouped by the class that owns it. Both targets here exist to feed the +/// Dota custom-game ecosystem, which already has a toolchain for exactly this shape. +pub trait BindingsEmitter { + fn id(&self) -> &'static str; + /// `schema` supplies the class BASE CHAIN, which the binding registry does not carry. With it, `.d.ts` + /// emits `interface X extends Y` the way the ecosystem's published types do; without it, every + /// interface is flat but still correct — an offline artifact has no schema, and that is the only case + /// where it is absent. + fn render(&self, vscript: &[VScriptBinding], schema: Option<&Schema>) -> String; +} + +/// The base class to declare an `extends` against, but ONLY when we also emit an interface for it. +/// +/// A dangling `extends` would make the file unusable on its own, and self-contained is the safer default: +/// an author merging this beside the ecosystem's packages loses nothing, while an author using it alone +/// would otherwise get an unresolved reference. The base graph comes from the typed schema, so it is +/// present exactly when the artifact carries a schema, i.e. when it came from a full build. +fn vs_base<'a>( + cls: &str, + schema: Option<&'a Schema>, + emitted: &BTreeMap<&str, Vec<&VScriptBinding>>, +) -> Option<&'a str> { + schema? + .bases + .get(cls)? + .first() + .map(|b| b.name.as_str()) + .filter(|b| emitted.contains_key(b)) +} + +/// Group the VScript bindings by owning class, dropping the ones that have none. +/// +/// `class` is live-only (see `VScriptBinding::class`), so an OFFLINE build renders nothing here. That is +/// the honest outcome rather than a bug: both output formats declare members under their interface, and a +/// flat list of function names is not a thing either consumer can use. +fn vscript_by_class(vscript: &[VScriptBinding]) -> BTreeMap<&str, Vec<&VScriptBinding>> { + let mut out: BTreeMap<&str, Vec<&VScriptBinding>> = BTreeMap::new(); + for v in vscript { + if let Some(c) = v.class.as_deref() { + out.entry(c).or_default().push(v); + } + } + for v in out.values_mut() { + // By the C++ name as well as the script one: a script name is NOT unique on a class — + // `CBodyComponent::SetMaterialGroup` is two different implementations, and `ConnectOutput` is + // three — so sorting on the script name alone leaves their order decided by the order the + // registry happened to be read in, and the rendered API stops being reproducible. + v.sort_by(|a, b| (&a.name, &a.cpp).cmp(&(&b.name, &b.cpp))); + } + out +} + +/// One member per script-facing name, preferring the row Valve documented — see the call site. +fn dedup_by_script_name<'a>(members: &[&'a VScriptBinding]) -> Vec<&'a VScriptBinding> { + let mut out: Vec<&VScriptBinding> = Vec::with_capacity(members.len()); + for m in members { + match out.last_mut() { + Some(prev) if prev.name == m.name => { + if prev.description.is_empty() && !m.description.is_empty() { + *prev = m; + } + } + _ => out.push(m), + } + } + out +} + +/// Escape text destined for a `/** … */` doc comment. +/// +/// Two hazards, both present in shipped data: a `*/` inside the text ENDS the comment early (3 Dota +/// descriptions contain one), and a newline drops the rest of the sentence out of the `*`-continued +/// block the format expects (82 do). +fn jsdoc(s: &str) -> String { + one_line(s).replace("*/", "*\\/") +} + +/// The script return type as its TypeScript spelling. +/// +/// Lua has one number type, so every numeric `ScriptDataType_t` collapses to `number` — the distinction +/// between `int`, `float` and `uint` is real in the binary and meaningless in the target language, and +/// preserving it would produce declarations that do not typecheck against the ecosystem's own types. +fn vs_ts_type(ret: Option<&str>) -> &'static str { + match ret { + Some("void") | None => "void", + Some("bool") => "boolean", + Some("int") | Some("uint") | Some("float") => "number", + Some("string") => "string", + Some("Vector") => "Vector", + Some("QAngle") => "QAngle", + Some("handle") | Some("ehandle") => "CBaseEntity", + Some("table") => "object", + _ => "any", + } +} + +/// `api.json` — the shape ModDota's `dota-data` publishes and its `TypeScriptDeclarations` renders from. +/// +/// Emitting THIS rather than declarations directly is deliberate: their toolchain already turns this +/// shape into typed `.d.ts` packages, so matching it means the ecosystem's existing pipeline produces +/// up-to-date output instead of a parallel artifact competing with it. +/// +/// Two fields are honestly absent. Parameter lists, because the registry does not carry them — types +/// appear only inside Valve's prose descriptions, inconsistently, in about a fifth of entries. And +/// `available`, because a dedicated server never maps `libclient`, so this derivation cannot see the +/// client side at all and claiming `both` would be an assertion about something never read. +pub struct VScriptApiJson; + +impl BindingsEmitter for VScriptApiJson { + fn id(&self) -> &'static str { + "api-json" + } + fn render(&self, vscript: &[VScriptBinding], _schema: Option<&Schema>) -> String { + let mut classes: Vec = Vec::new(); + for (cls, members) in vscript_by_class(vscript) { + let ms: Vec = members + .iter() + .map(|m| { + let mut o = serde_json::Map::new(); + o.insert("kind".into(), json!("function")); + o.insert("name".into(), json!(m.name)); + o.insert("available".into(), json!("server")); + if !m.description.is_empty() { + o.insert("description".into(), json!(m.description)); + } else if let Some(d) = &m.doc { + // Under a key of OUR name, never theirs. `description` is Valve's field in + // their shape and their toolchain renders it as Valve's word; putting this + // project's reading of the build there would launder it into their published + // types as something Valve wrote. + o.insert("rosetta_description".into(), json!(d.text)); + o.insert("rosetta_description_source".into(), json!(d.source)); + } + o.insert("returns".into(), json!([m.ret.clone().unwrap_or_default()])); + o.insert("args".into(), json!([])); + // Ours and not theirs: the C++ binding this resolves to, which is the key the same + // function appears under in `gamedata-.json`. + o.insert("cpp".into(), json!(m.cpp)); + Value::Object(o) + }) + .collect(); + classes.push(json!({ "kind": "class", "name": cls, "members": ms })); + } + serde_json::to_string_pretty(&Value::Array(classes)).unwrap_or_default() + } +} + +/// `.d.ts` — TypeScript declarations in the style the Dota ecosystem's published types use. +/// +/// For authors working against the packages as shipped rather than regenerating them. Members are +/// declared on an interface per class, with Valve's own description as the doc comment — which is the +/// point: hovering a function in an editor shows what Valve wrote about it. +/// +/// Parameters are declared `...args: any[]` because the registry does not state them. That is deliberately +/// ugly: it is visible in every signature, so nobody mistakes this for a complete declaration, and it +/// still typechecks. Inventing plausible parameter lists would be worse than saying nothing. +pub struct VScriptDts; + +impl BindingsEmitter for VScriptDts { + fn id(&self) -> &'static str { + "dts" + } + fn render(&self, vscript: &[VScriptBinding], schema: Option<&Schema>) -> String { + let mut s = String::new(); + s.push_str("/** @noSelfInFile */\n"); + s.push_str("// Generated by source2rosetta-gen from rosetta-.json — do not edit.\n"); + s.push_str( + "// Return types are Valve's own, read from the script VM's registry. Parameter lists are\n\ + // NOT in that registry, so every member takes `...args: any[]`: the arity is unknown, and\n\ + // guessing it would produce declarations that lie rather than declarations that abstain.\n\n", + ); + let grouped = vscript_by_class(vscript); + for (cls, members) in &grouped { + match vs_base(cls, schema, &grouped) { + Some(base) => s.push_str(&format!("declare interface {cls} extends {base} {{\n")), + None => s.push_str(&format!("declare interface {cls} {{\n")), + } + // One line per SCRIPT-facing name. Where a class registers a name twice — two C++ + // implementations behind one script member — an author still sees one member, so declaring + // it twice adds a redundant overload and no information. The row carrying Valve's + // description wins; `api-json` keeps both, because it states the `cpp` that tells them apart. + for m in dedup_by_script_name(members) { + // Valve's own description if the registration carried one — that is the point of this + // format, and it renders bare, the way the ecosystem's published types do. Where Valve + // documents nothing, this project's own reading fills the gap and SAYS SO: a hover + // tooltip is exactly where an unmarked sentence would be taken for Valve's word. + if !m.description.is_empty() { + s.push_str(&format!(" /** {} */\n", jsdoc(&m.description))); + } else if let Some(d) = &m.doc { + s.push_str(&format!( + " /** {}\n * ({}.) */\n", + jsdoc(&d.text), + doc_origin(&d.source) + )); + } + s.push_str(&format!( + " {}(...args: any[]): {};\n", + m.name, + vs_ts_type(m.ret.as_deref()) + )); + } + s.push_str("}\n\n"); + } + s + } +} + +/// Look up a bindings emitter by its `--format` id. +pub fn bindings_by_id(id: &str) -> Option> { + match id { + "api-json" => Some(Box::new(VScriptApiJson)), + "dts" => Some(Box::new(VScriptDts)), + _ => None, + } +} + +/// Every bindings emitter id `bindings_by_id` accepts (keep in sync with it). +/// +/// NOT a `--format` list: both of these are rendered by the single `moddota` format, because they are +/// one consumer's two files — their toolchain reads the JSON and their authors read the declarations. +pub const BINDINGS_FORMAT_IDS: &[&str] = &["api-json", "dts"]; + +/// Every `--format` `gen` accepts, in the order its help lists them. +/// +/// A format names WHO the output is for, not which file it is, so one of them can write several files: +/// a framework gets the gamedata its loader resolves through plus the typed call sites that go through +/// it, and `moddota` gets both of the shapes that ecosystem publishes. +pub const FORMAT_IDS: &[&str] = &[ + "cssharp", "metamod", "modsharp", "swiftly", "plugify", "cs-sdk", "netvars", "moddota", "flat", +]; + +/// Where a format's consumer is known not to run on a game, and the evidence for saying so. +/// +/// **A warning rather than a rule.** Each entry is a claim about somebody else's project, read out of +/// their source at one point in time, and third-party projects add games. So `gen` declines by default +/// and takes `--force`: being wrong here costs a flag, never an outcome. +/// +/// What earns an entry is a framework that resolves its own binaries through a FIXED game directory, +/// which is a thing its own source states rather than a thing this project infers. Two do: +/// CounterStrikeSharp and Swiftly. +/// +/// **ModSharp is deliberately absent**, though it is equally CS2-first in its paths +/// (`../../csgo/steam.inf`): its gamedata carries no game key at all — flat `Addresses` / `VFuncs`, +/// keyed only by platform — so the file rendered here is byte-for-byte the same whatever game the build +/// targets. The two multi-game targets are absent for the opposite reason: Metamod takes Dota 2 as a +/// first-class SDK and Plugify is built per game (`S2SDK_GAME_NAME`), and BOTH key their gamedata by the +/// game directory, which is what `meta.game_key` already carries. +pub const GAME_SUPPORT: &[(&str, &[&str], &str)] = &[ + ( + "cssharp", + &["csgo"], + "CounterStrikeSharp resolves its binaries out of `/csgo/bin/` (src/core/memory.h)", + ), + ( + "swiftly", + &["csgo"], + "Swiftly initialises against the `csgo` game directory (src/core/entrypoint.cpp)", + ), +]; + +/// What is wrong with rendering `format` from a `game_key` artifact, or `None` where nothing is. +/// +/// Names the formats that DO cover the game, because the useful thing to tell someone holding a Dota +/// artifact is not that this one is a dead end but which ones are not. +pub fn game_mismatch(format: &str, game_key: &str) -> Option { + let (_, _, why) = GAME_SUPPORT + .iter() + .find(|(f, games, _)| *f == format && !games.contains(&game_key))?; + let covered: Vec<&str> = FORMAT_IDS + .iter() + .copied() + .filter(|f| { + !GAME_SUPPORT + .iter() + .any(|(id, games, _)| id == f && !games.contains(&game_key)) + }) + .collect(); + Some(format!( + "`{format}` is for a consumer that does not run on this game. {why}, and this artifact is \ + `{game_key}`.\n Formats that do cover `{game_key}`: {}", + covered.join(", ") + )) +} + #[cfg(test)] mod tests { use super::*; @@ -1598,6 +1976,138 @@ mod tests { ); } + #[test] + fn a_description_reaches_every_call_site_format_and_says_whose_it_is() { + let doc = |text: &str, source: &str| crate::model::Doc { + text: text.into(), + source: source.into(), + }; + let mut e = abi_entry(&["A*", "int"], true, "void", 2); + e.doc = Some(doc("Kills the entity.", "generated")); + let m = manifest(&[("A::M", e)]); + + for out in [CsSharpAbi.render(&m), ModSharpAbi.render(&m)] { + // The prose takes the summary — an editor shows that first, and it is what an author + // hovering a generic type list is asking for — and the prototype keeps a home of its own. + assert!( + out.contains("Kills the entity."), + "{out}" + ); + assert!( + out.contains("A::M(A*, int) -> void"), + "{out}" + ); + assert!(out.contains("GENERATED — a reading of this build, not Valve's")); + } + let mm = MetamodAbi.render(&m); + assert!(mm.contains("// Kills the entity.\n// Description: source2rosetta's, GENERATED")); + assert!( + SwiftlyAbi + .render(&m) + .contains("\"description_source\": \"generated\"") + ); + assert!( + PlugifyAbi + .render(&m) + .contains("\"descriptionSource\": \"generated\"") + ); + + // Valve's own text is attributed to Valve, in the same place, by the same one wording. + let mut e = abi_entry(&["A*", "int"], true, "void", 2); + e.doc = Some(doc("Valve wrote this.", crate::model::Doc::VALVE)); + let valve = CsSharpAbi.render(&manifest(&[("A::M", e)])); + assert!(valve.contains("Valve wrote this.")); + assert!( + valve.contains("Description: Valve's own text, read from the registry in the binary.") + ); + + // An id nothing here knows is printed verbatim rather than passed off as Valve's — the same + // rule `flags_raw` follows for a bit whose meaning this build cannot state. + let mut e = abi_entry(&["A*", "int"], true, "void", 2); + e.doc = Some(doc("t", "handwritten")); + let odd = CsSharpAbi.render(&manifest(&[("A::M", e)])); + assert!(odd.contains("source `handwritten` — not Valve's"), "{odd}"); + + // And with nothing to say, the block is exactly what it was before descriptions existed. + let bare = CsSharpAbi.render(&manifest(&[("A::M", abi_entry(&["A*"], true, "void", 1))])); + assert!(bare.contains("A::M(A*) -> void")); + assert!(!bare.contains("Description:")); + } + + #[test] + fn a_description_cannot_break_out_of_the_comment_it_is_printed_in() { + // Real shipped text carries all three hazards: XML metacharacters (~100 descriptions per + // game), a newline (78), and `*/` (3 in Dota). + let mut e = abi_entry(&["A*"], true, "void", 1); + e.doc = Some(crate::model::Doc { + text: crate::model::one_line("a & c\nsecond line */ end"), + source: "generated".into(), + }); + let m = manifest(&[("A::M", e)]); + for out in [CsSharpAbi.render(&m), ModSharpAbi.render(&m)] { + assert!( + out.contains("a <b> & c second line */ end"), + "{out}" + ); + } + // A `//` comment ends at a newline, so every prose line in the C++ header must be one line. + for line in MetamodAbi.render(&m).lines() { + assert!( + line.starts_with("//") || !line.contains("second line"), + "{line}" + ); + } + } + + #[test] + fn the_script_api_fills_a_gap_valve_left_and_never_overwrites_one() { + let member = |name: &str, valve: &str, doc: Option<&str>| VScriptBinding { + name: name.into(), + class: Some("CBaseEntity".into()), + cpp: format!("Script_{name}"), + library: "server".into(), + description: valve.into(), + ret: Some("void".into()), + ret_raw: 0, + addr: None, + vtable_slot: None, + doc: doc.map(|t| crate::model::Doc { + text: t.into(), + source: "generated".into(), + }), + }; + let vs = vec![ + member("Kill", "Valve's own.", Some("ours, and outranked")), + member("Quiet", "", Some("Ours: it does a thing. */")), + member("Silent", "", None), + ]; + + let dts = VScriptDts.render(&vs, None); + assert!(dts.contains("/** Valve's own. */"), "{dts}"); + assert!(!dts.contains("outranked"), "{dts}"); + // Ours is marked where it lands, because a hover tooltip is exactly where an unattributed + // sentence gets taken for Valve's word. And `*/` inside it must not end the comment. + assert!( + dts.contains("/** Ours: it does a thing. *\\/\n * (source2rosetta's, GENERATED") + ); + // A member nothing describes gets no comment at all — an empty one would read as "documented, + // and it says nothing". (Counting the indented form: the file's own `@noSelfInFile` banner is + // a doc comment too.) + assert!(dts.contains(" Silent(...args: any[]): void;")); + assert_eq!(dts.matches(" /**").count(), 2); + + // `api.json` is ModDota's shape: `description` is Valve's field, so ours goes under a key of + // our own name rather than being laundered into their published types as Valve's word. + let api: Value = serde_json::from_str(&VScriptApiJson.render(&vs, None)).unwrap(); + let ms = &api[0]["members"]; + assert_eq!(ms[0]["description"], "Valve's own."); + assert!(ms[0].get("rosetta_description").is_none()); + assert!(ms[1].get("description").is_none()); + assert_eq!(ms[1]["rosetta_description"], "Ours: it does a thing. */"); + assert_eq!(ms[1]["rosetta_description_source"], "generated"); + assert!(ms[2].get("rosetta_description").is_none()); + } + #[test] fn a_declared_return_that_cannot_be_represented_drops_the_function() { // `Vector` by value is a real declaration this cannot express — dropping it is not the same as @@ -1635,10 +2145,14 @@ mod tests { linux: "55 48 ? E5".into(), }), offset: None, + class: None, + anchors: Vec::new(), }; let off = Entry { signature: None, offset: Some(158), + class: None, + anchors: Vec::new(), }; assert_eq!(entry_from_value(&locator_value(&sig)), sig); assert_eq!(entry_from_value(&locator_value(&off)), off); @@ -1707,10 +2221,60 @@ mod tests { #[test] fn every_format_id_resolves_and_renders() { - for id in FORMAT_IDS { + for id in GAMEDATA_FORMAT_IDS { let em = by_id(id).unwrap_or_else(|| panic!("by_id({id}) is None")); assert!(!em.render(&sample()).is_empty(), "{id} rendered empty"); } + // Every `--format` has to be reachable through one of the four emitter families, or `gen` + // advertises an id it then rejects. `moddota` is the one that maps to a family rather than to + // an emitter: it is a CONSUMER with two files, which is why the CLI list is not a registry. + for id in FORMAT_IDS { + let known = by_id(id).is_some() + || schema_by_id(id).is_some() + || abi_by_id(id).is_some() + || *id == "moddota" + || *id == "flat"; + assert!(known, "--format {id} resolves to no emitter"); + } + for id in BINDINGS_FORMAT_IDS { + assert!(bindings_by_id(id).is_some(), "bindings_by_id({id}) is None"); + } + } + + #[test] + fn a_consumer_that_does_not_run_on_this_game_is_named_and_so_are_the_ones_that_do() { + // CounterStrikeSharp resolves its own binaries out of `/csgo/bin/`, so Dota locators in + // its shape describe a file that can never load. Saying which formats DO cover the game is the + // useful half: someone holding a Dota artifact needs a way forward, not just a closed door. + let m = game_mismatch("cssharp", "dota").expect("cssharp does not run on dota"); + assert!(m.contains("CounterStrikeSharp"), "{m}"); + assert!( + m.contains("metamod") && m.contains("moddota") && m.contains("plugify"), + "{m}" + ); + assert!( + !m.contains("swiftly"), + "swiftly does not cover dota either: {m}" + ); + assert!(game_mismatch("cssharp", "csgo").is_none()); + + // Multi-game by evidence: Metamod takes Dota 2 as a first-class SDK, Plugify is built per game, + // and both key their gamedata by the game directory — which is what `game_key` already carries. + for f in ["metamod", "plugify", "moddota", "flat", "cs-sdk", "netvars"] { + assert!(game_mismatch(f, "dota").is_none(), "{f} should cover dota"); + } + // ModSharp is CS2-FIRST but not CS2-only in the shape rendered here: its gamedata carries no + // game key at all, so the file is the same whatever game the build targets. + assert!(game_mismatch("modsharp", "dota").is_none()); + + // Every id the table constrains has to be a format that exists, or the constraint silently + // applies to nothing. + for (id, _, _) in GAME_SUPPORT { + assert!( + FORMAT_IDS.contains(id), + "GAME_SUPPORT names unknown format {id}" + ); + } } #[test] diff --git a/fuzz/fuzz_targets/fuzz_concmd.rs b/fuzz/fuzz_targets/fuzz_concmd.rs index 97e635c..40e3759 100644 --- a/fuzz/fuzz_targets/fuzz_concmd.rs +++ b/fuzz/fuzz_targets/fuzz_concmd.rs @@ -8,6 +8,10 @@ //! It also exercises the two indirections that resolve a callback (a static object's first virtual, and //! a constructor-stored member) against pointers the file chose, which is the same untrusted-chase shape //! the Valve table readers had to be hardened for. +//! +//! CONVAR extraction rides the same pass and is fuzzed here with it. It adds two things worth attacking: +//! a per-registrar delegation walk (bounded call/tail-jump decoding at a file-chosen address) and a +//! statistical argument-slot choice, both driven entirely by bytes the file controls. use libfuzzer_sys::fuzz_target; use source2rosetta::concmd; use source2rosetta::elf::CodeImage; @@ -36,6 +40,40 @@ fuzz_target!(|data: &[u8]| { assert!(named.len() <= 12, "more flag names than there are flag bits"); let _ = (c.description.len(), c.form.describe(), c.flags); } + // ---- ConVars: same pass, different registrar test ---- + let cvs = concmd::convars(&img, "server"); + for c in &cvs { + // The name gate is the only thing separating a convar registration from any other call that + // happens to pass a string, so it must hold on every row. + assert!( + !c.name.is_empty() && c.name.len() <= 64, + "an implausible convar name was recorded: {:?}", + c.name + ); + // Flags are optional (a registrar with no identifiable slot reports none), but when present the + // decode is a pure bit test over a table of 9 and cannot exceed it. + if !c.flags_raw.is_empty() { + let raw = u64::from_str_radix(c.flags_raw.trim_start_matches("0x"), 16) + .expect("flags_raw is written as hex by this reader"); + assert!(raw <= u64::from(u32::MAX), "a convar flags word exceeded 32 bits"); + assert_eq!( + c.flags.len(), + concmd::convar_flag_names(raw).len(), + "decoded flag names disagree with the raw word for {:?}", + c.name + ); + } else { + assert!(c.flags.is_empty(), "flag names without a raw word for {:?}", c.name); + } + let _ = (c.description.len(), c.addr.len(), c.library.len()); + } + // ConVars are deduped on (name, object address) for the same reason commands are. + let mut cseen: Vec<(&str, &str)> = cvs.iter().map(|c| (c.name.as_str(), c.addr.as_str())).collect(); + let cbefore = cseen.len(); + cseen.sort_unstable(); + cseen.dedup(); + assert_eq!(cbefore, cseen.len(), "a duplicate (name, object) convar survived"); + // Commands are deduped on (name, address), so no pair may survive twice. let mut seen: Vec<(&str, u64)> = cmds.iter().map(|c| (c.name.as_str(), c.handler)).collect(); let before = seen.len(); diff --git a/fuzz/fuzz_targets/fuzz_pulse.rs b/fuzz/fuzz_targets/fuzz_pulse.rs index 12c666d..1dbaadc 100644 --- a/fuzz/fuzz_targets/fuzz_pulse.rs +++ b/fuzz/fuzz_targets/fuzz_pulse.rs @@ -16,6 +16,20 @@ fuzz_target!(|data: &[u8]| { return; }; let bindings = valvetab::pulse_bindings(&img); + // The invocation shim's read-measurement walks a file-chosen address with its own span arithmetic, + // and its verdict is emitted as `call.needs`, so it must degrade rather than panic or over-claim. + for b in &bindings { + if b.shim == 0 { + continue; + } + if let Some(r) = pulse::shim_reads(&img, b.shim) { + assert!(r.reads.len() <= 7, "more argument slots than the shim has"); + assert!( + matches!(r.needs(), "args-only" | "output-sink" | "pulse-context" | "other-slots"), + "needs() left its closed vocabulary" + ); + } + } let pairs: Vec<(u64, u64)> = bindings .iter() .take(64) diff --git a/fuzz/fuzz_targets/fuzz_rtti.rs b/fuzz/fuzz_targets/fuzz_rtti.rs index 819caf9..bd522a6 100644 --- a/fuzz/fuzz_targets/fuzz_rtti.rs +++ b/fuzz/fuzz_targets/fuzz_rtti.rs @@ -12,7 +12,7 @@ fuzz_target!(|data: &[u8]| { }; let vts = rtti::enumerate_vtables(&img, 128); for cv in vts.iter().take(32) { - let _ = (&cv.name, &cv.mangled, cv.offset_to_top, cv.slots.len()); + let _ = (&cv.name, cv.offset_to_top, cv.slots.len()); } // The by-name lookup path (mangling + candidate walk) on a name pulled from the input itself. if let Some(name) = vts.first().map(|c| c.name.clone()) { diff --git a/fuzz/fuzz_targets/fuzz_schema.rs b/fuzz/fuzz_targets/fuzz_schema.rs index ea433d9..6098c57 100644 --- a/fuzz/fuzz_targets/fuzz_schema.rs +++ b/fuzz/fuzz_targets/fuzz_schema.rs @@ -15,13 +15,16 @@ fuzz_target!(|data: &[u8]| { // width/count word, and an enumerator array whose length that word supplies. A crafted count is the // sharp edge — it drives the per-enumerator read loop — so the reader must bound it rather than // trust it. - for e in schema::enumerate_enums(&img) { + let classes = schema::enumerate_schema(&img); + // The enum walk takes the classes because a class FIELD descriptor is byte-compatible with an enum + // binding — so a crafted image can aim the field-array spans it derives from them anywhere too. + for e in schema::enumerate_enums(&img, &classes) { let _ = (e.name.len(), e.size, e.align); for (n, v) in &e.values { let _ = (n.len(), *v); } } - for c in schema::enumerate_schema(&img) { + for c in &classes { let _ = c.primary_base(); for f in &c.fields { let _ = (f.offset, f.name.len()); diff --git a/fuzz/fuzz_targets/fuzz_xref.rs b/fuzz/fuzz_targets/fuzz_xref.rs index 9d3b157..f96e515 100644 --- a/fuzz/fuzz_targets/fuzz_xref.rs +++ b/fuzz/fuzz_targets/fuzz_xref.rs @@ -11,8 +11,8 @@ fuzz_target!(|data: &[u8]| { return; }; let xr = xref::XrefIndex::build(&img); - // Exercise the lookups over a bounded set of the discovered call targets — none may panic. - for &t in xr.call_targets().iter().take(64) { + // Exercise the lookups over a bounded set of the discovered function entries — none may panic. + for &t in xr.entries().iter().take(64) { let _ = xr.referrers(t); let _ = xr.refs_to(t); let _ = xr.containing_func(t); diff --git a/mappings/semantics-cs2.json b/mappings/semantics-cs2.json new file mode 100644 index 0000000..635496f --- /dev/null +++ b/mappings/semantics-cs2.json @@ -0,0 +1,12312 @@ +{ + "meta": { + "game": "cs2", + "source_build": "game", + "described": 3074, + "named": 3987, + "by_source": { + "derived": 716, + "generated": 2358 + }, + "valve_described_elsewhere": 913, + "note": "Keyed on NAME, which is stable across builds. Descriptions are SIGNATURE-FREE: arity, types and verdicts join from abi-.json at render time. Valve's own text always wins and is NOT duplicated here \u2014 see bindings-.json." + }, + "descriptions": { + "AG2_OnResourceChanged": { + "text": "Reacts to an AG2 animation-graph resource changing, recreating the graph instance for the affected entity and logging that entity's index and name. Its log string is the direct evidence; useful to know when hot-reloading graph assets, though the conditions that trigger the recreate are unverified.", + "source": "generated" + }, + "AG2_OnResourcePreReload": { + "text": "Prepares for an AG2 graph resource reload by deleting the entity's existing graph instance, logging which entity lost its instance. The log string carries this directly; what else is torn down alongside the graph instance is not established.", + "source": "generated" + }, + "AccumulateElapsedTime": { + "text": "Adds a number of seconds to a running elapsed-time total and logs both the amount added and the new total. Read from the name and that log line; which timer or subsystem owns the accumulator is not established.", + "source": "generated" + }, + "AddDamage": { + "text": "Adds an amount of damage to something that accumulates it, such as a damage record or an entity's running damage total. This is a name-level reading with no string anchor, so what holds the total and how the addition is applied stay unverified.", + "source": "generated" + }, + "AddStackKV3": { + "text": "Pushes a KeyValues3 block onto a stack the sound system maintains, the shape of thing used when walking or building nested KV3 data. Read from the name in libsoundsystem; the stack's owner and the block's lifetime are unverified.", + "source": "generated" + }, + "AirAccelerate": { + "text": "Applies acceleration to an airborne player, the routine that governs air control and how much speed a strafe can add. Read from the name and its Source-movement lineage; also shipped as CCSPlayer_MovementServices::AirAccelerate, the usual hook point for changing air-strafe or surf behaviour.", + "source": "generated" + }, + "AirMove": { + "text": "Runs the airborne branch of player movement, applying the wish direction while the player is off the ground; it carries the string anchor PreSource1AirMove, marking the older Source-1 air-movement path kept in CS2. Also shipped as CCSPlayer_MovementServices::AirMove.", + "source": "generated" + }, + "AppSystemCreateInterfaceFn": { + "text": "Acts as the app-system framework's CreateInterface factory, resolving interfaces exposed by a loaded engine module so other code can obtain them. Read from the name in libengine2; the lookup and versioning rules it applies are not established.", + "source": "generated" + }, + "ApplyBreakCommandListToPieces": { + "text": "Applies a breakable object's list of break commands to the pieces produced when it shatters, driving what each resulting gib does. The name and its verbatim string anchor support this; the command set and the piece representation are not established.", + "source": "generated" + }, + "AreTeamsPlayingSwitchedSides": { + "text": "Reports whether the teams have swapped sides, as happens across the halftime switch, letting a mod map current team numbers back to starting sides. Read from the name and the CCSGameRules::AreTeamsPlayingSwitchedSides alias; no prototype is derived, so the conditions that set this state are unverified.", + "source": "generated" + }, + "AssignSharedChangeCallbackIndex": { + "text": "Assigns the index that identifies a shared change callback in the network system's change-notification bookkeeping. Read from the name in libnetworksystem; what the index is attached to, and how it is resolved later, are unverified.", + "source": "generated" + }, + "AttackState::GetName": { + "text": "Purpose is not established beyond returning some name string for the bot's attack state, most plausibly for state-machine debug output. The owning class AttackState is implied by the name, not recorded in the data.", + "source": "generated" + }, + "AttackState::OnExit": { + "text": "Runs the teardown for the bot's attack state when that state is left, and ships with the literal 'AttackState:OnExit()' that matches state-machine trace output. Read from that anchor plus the name; what it actually releases or resets is not derived.", + "source": "generated" + }, + "BotChatterInterface::KilledMyEnemy": { + "text": "Handles the bot chatter case where the enemy this bot was engaging died to someone else, and carries the literal 'KilledMyEnemy' as its concept token. Useful when suppressing or reskinning bot radio lines; the conditions that qualify a kill are not derived.", + "source": "generated" + }, + "BotFollowMeme::Interpret": { + "text": "Applies a broadcast 'follow me' chatter meme to a receiving bot, turning the request into that bot's own behaviour or intent. The owning class BotFollowMeme is implied by the name, not the data, and what the interpretation changes is unverified.", + "source": "generated" + }, + "BotHostageBeingTakenMeme::Interpret": { + "text": "Applies a 'hostage is being taken' chatter meme to a receiving bot so it can react to the reported hostage grab. The owning class BotHostageBeingTakenMeme is implied by the name, not the data, and the resulting behaviour change is unverified.", + "source": "generated" + }, + "BotNavIgnore": { + "text": "Marks something for bots to skip while navigating, excluding an area or entity from bot pathing. The reading comes from the name alone, so whether it sets a flag, answers a query, or backs a console command is not established.", + "source": "generated" + }, + "BreakCreateParticle": { + "text": "Spawns the particle effect that accompanies a breaking object, the visual burst seen when a breakable shatters. The name and matching string anchor support this; which particle system is chosen and where it is placed are not established.", + "source": "generated" + }, + "BreakJointByName": { + "text": "Breaks one specific joint on a jointed model, identified by that joint's name, which is how a single piece of a breakable or ragdoll gets detached. Read from the name and its verbatim anchor; the joint namespace and the physics consequences are not established.", + "source": "generated" + }, + "BuildComponentRecursive": { + "text": "Builds a component together with its nested child components, constructing a whole subtree in one pass. Read from the name and its verbatim string anchor; what counts as a component here, and what ends the recursion, are not established.", + "source": "generated" + }, + "BuyState::GetName": { + "text": "Purpose is not established beyond returning some name string for the bot's buy state, most plausibly for state-machine debug output. The owning class BuyState is implied by the name, not recorded in the data.", + "source": "generated" + }, + "BuyState::OnExit": { + "text": "Runs the teardown for the bot buying state when the bot leaves it. The owning class BuyState is implied by the name rather than recorded in the data, so what it finalises about the bot's loadout is unverified.", + "source": "generated" + }, + "BuyState::OnUpdate": { + "text": "Drives the bot's per-update buying behaviour and emits '%s bot spawned outside of a buy zone (%d, %d, %d)' when the bot cannot shop where it stands. Worth knowing when debugging custom maps where bots never buy; the purchase decision logic itself is not derived.", + "source": "generated" + }, + "CAI_ChangeHintGroup::InputActivate": { + "text": "Handles the `Activate` entity-IO input on `CAI_ChangeHintGroup`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAI_Expresser::CAI_Expresser": { + "text": "Constructs the expresser that drives an NPC's speech, bringing up its cooldown tables (m_conceptCooldowns, m_ruleCooldowns), talk-time bookkeeping such as m_flStopTalkTime, and the m_pOuter back-pointer to the owning entity. Read from the name and the class fields; the initial values it writes are not derived.", + "source": "generated" + }, + "CAI_Expresser::NoteSpeaking": { + "text": "Records that the owner has started speaking and extends the talk-time window accordingly, printing ' NoteSpeaking( %f, %f ) (stop at %f)' with the resulting stop time. The window it maintains is visible in m_flStopTalkTime and m_flStopTalkTimeWithoutDelay; the arithmetic is not derived.", + "source": "generated" + }, + "CAI_Expresser::SpeakAutoGeneratedScene": { + "text": "Speaks a line by building a scene on the fly around a sound or response name instead of using an authored scene file, logging 'SpeakAutoGeneratedScene( %s, %f) %f'. Gating state such as m_flBlockedTalkTime and m_bAllowSpeakingInterrupts is relevant here; the generation details are not derived.", + "source": "generated" + }, + "CAI_Expresser::SpeakRawScene": { + "text": "Plays an authored scene directly as the NPC's speech, logging 'SpeakRawScene( %s, %f) %f' with the scene name and timing. Read from that anchor and the name; whether the request is queued or dropped relates to fields like m_flQueuedSpeechTime and m_bAllowSpeakingInterrupts, which is unverified.", + "source": "generated" + }, + "CAI_ExpresserWithFollowup::SpeakDispatchResponse": { + "text": "Speaks a response selected by the response system and dispatches the follow-up line attached to it, working with response objects of the kind this batch references (CRR_Response, CResponseCriteriaSet). The owning class is implied by the name, not the data, so the follow-up mechanics are unverified.", + "source": "generated" + }, + "CAI_ScriptedSequence::CancelScript": { + "text": "Aborts a running scripted sequence and releases its actor, emitting 'Cancelling script: %s' with the script name. Useful when tracking down NPCs wedged in map scripts; what actor state is restored on cancel is not derived.", + "source": "generated" + }, + "CAI_ScriptedSequence::DelayStart": { + "text": "Holds a scripted sequence waiting until its participants are ready, tracking a not-ready count that its debug line ' (%d): Exited DelayStart() with m_nNotReadySequenceCount of: %d.' reports. Read from that anchor and the name; the readiness rules and the delay duration are not derived.", + "source": "generated" + }, + "CAK47::SecondaryAttack": { + "text": "Implements the AK-47's secondary-fire branch, the alternate-attack path for that weapon. The class CAK47 is implied by the name, not the data, and what the alternate fire does on this build is unverified \u2014 worth hooking if you are adding per-weapon alt-fire behaviour.", + "source": "generated" + }, + "CAggregateSceneObject::OnBeginRenderingFrame": { + "text": "Prepares an aggregated scene object at the start of a rendering frame, refreshing the per-frame state its batched geometry needs. Read from the name and its home in libscenesystem; no prototype or field data is derived, so the refreshed state is unverified.", + "source": "generated" + }, + "CAggregateSceneObjectDesc::Draw": { + "text": "Issues the draw for a single aggregate scene-object description, submitting the geometry that description covers. The owning class CAggregateSceneObjectDesc is implied by the name, not the data, and the submission path is unverified.", + "source": "generated" + }, + "CAmbientGeneric::GetDataDescMap": { + "text": "Returns the data description map for the ambient sound entity \u2014 the table describing its keyvalues and its inputs, among them CAmbientGeneric::InputPlaySound and CAmbientGeneric::InputVolume. The class is implied by the name, not the data; use it as the entry point when enumerating that entity's mapper-facing surface.", + "source": "generated" + }, + "CAmbientGeneric::InputFadeIn": { + "text": "Handles the `FadeIn` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputFadeOut": { + "text": "Handles the `FadeOut` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputPitch": { + "text": "Handles the `Pitch` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputPlaySound": { + "text": "Handles the `PlaySound` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputStopSound": { + "text": "Handles the `StopSound` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputToggleSound": { + "text": "Handles the `ToggleSound` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputVolume": { + "text": "Handles the `Volume` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::RampThink": { + "text": "Steps the ambient sound's volume and pitch ramp over time while the sound runs, moving the current values toward their targets. Relevant state sits in m_dpv, m_fActive and m_fLooping; read from the name, with the ramp rate and stop condition not derived.", + "source": "generated" + }, + "CAnimData::AppendDataChannels": { + "text": "Adds data channels to an animation data block, extending the per-channel storage that holds its compressed animation streams. The content it extends is visible in m_animArray, m_decoderArray and m_segmentArray; read from the name, so the append semantics and growth behaviour are unverified.", + "source": "generated" + }, + "CAnimGraphController::PreGraphUpdate": { + "text": "Performs the animation-graph controller's pre-update pass, staging parameters and inputs for the graph evaluation of the current tick, and ships with the literal 'PreGraphUpdate'. Read from that anchor and the name \u2014 exactly what it stages is not derived.", + "source": "generated" + }, + "CAnimGraphGameSystem::AnimTickUpdate": { + "text": "Runs the animation-graph game system's per-tick animation update for server-side animating entities, carrying the literal 'AnimTickUpdate' (the shape of a profiling or telemetry label). Read from the name and anchor; the entity set it covers and its timing are unverified.", + "source": "generated" + }, + "CAnimGraphGameSystem::OnServerPrePackEntities": { + "text": "Handles the server's pre-pack-entities event for the animation-graph game system, settling animation state before entity data is packed for networking. The class CAnimGraphGameSystem is implied by the name, not the data, and the work performed there is unverified.", + "source": "generated" + }, + "CAnimationSystem::FrameUpdate": { + "text": "Advances the animation system by one frame, servicing its per-frame animation work. The owning class CAnimationSystem is implied by the name rather than the data, so the scope of that update is unverified.", + "source": "generated" + }, + "CAnimationSystemUtils::CreateAnimationHelper": { + "text": "Creates an animation helper object for a caller that needs animation services against some target. The owning class CAnimationSystemUtils is implied by the name, not the data, so both the ownership and what the helper wraps should be treated as unverified.", + "source": "generated" + }, + "CAnimationSystemUtils::DestroyAnimationHelper": { + "text": "Destroys an animation helper obtained from this utility interface and releases what it holds. The owning class CAnimationSystemUtils is implied by the name, not the data, and the teardown details are unverified.", + "source": "generated" + }, + "CAnimationSystemUtils::~CAnimationSystemUtils": { + "text": "Destructor for the animation-system utility interface; purpose beyond tearing the object down is not established. The class is implied by the name, not the data.", + "source": "generated" + }, + "CAppSystemDict::ConnectInterfaces": { + "text": "Connects the registered app systems in the dictionary to the interfaces they require, resolving factory-provided pointers as the process brings its modules up. Read from the name and its home in libtier0; no prototype is derived, so the resolution rules and failure handling are unverified.", + "source": "generated" + }, + "CAppSystemDict::LoadSystemAndDependencies": { + "text": "Loads a named app system along with the systems it depends on, pulling in the modules needed to make it usable. Read from the name and its home in libengine2; the lookup order, dependency discovery and failure behaviour are not derived.", + "source": "generated" + }, + "CAsyncFileSystem::RunCallbackAndMarkComplete": { + "text": "Invokes the completion callback for a finished asynchronous file request and marks that request complete. Read from the name and its home in libfilesystem_stdio; the threading context and how the request is represented are not derived.", + "source": "generated" + }, + "CAttributeContainer::GetItem": { + "text": "Returns the economy item the attribute container holds \u2014 its m_Item member, an item-view object of the kind this batch references (CEconItemView). The class CAttributeContainer is implied by the name, not the data; this is the usual handle for reading a weapon or equipment item's attributes.", + "source": "generated" + }, + "CAttributeList::SetOrAddAttributeValueByName": { + "text": "Sets an econ attribute on the list by attribute name, creating the entry when the list does not already carry it, and writes into m_Attributes. Also shipped under the bare name SetOrAddAttributeValueByName; this is the practical hook for changing item or weapon attribute values at runtime.", + "source": "generated" + }, + "CBarnLight::SetStyle": { + "text": "Sets the light style on a barn light \u2014 the named pattern that drives its animated brightness, the state visible in `m_LightStyleString` and `m_flLightStyleStartTime`. Anchored by the string `SetStyle` and otherwise read from the name, so the accepted style encoding and when the change takes effect are unverified.", + "source": "generated" + }, + "CBarnLight::Think_ApplyLightStylesToTargets": { + "text": "Pushes the current light-style state out to the light's style targets on a periodic think, the work behind `m_LightStyleTargets` and `m_LightStyleEvents`. The `CBarnLight` class is implied by the name rather than established by the slot data, so the think interval and what a target receives are a name-level reading.", + "source": "generated" + }, + "CBaseAnimGraphController::SequenceDuration": { + "text": "Reports the playback length of an animation sequence, complaining with `CBaseAnimGraphController::SequenceDuration( %d ) out of range` when the sequence index is invalid. Handy with `m_hSequence` and `m_flPlaybackRate` when timing logic against an animation; the range check is evidenced by the anchor, the rest read from the name.", + "source": "generated" + }, + "CBaseAnimGraphController::SetSequence": { + "text": "Selects the controller's active animation sequence, the state reflected in `m_hSequence` and `m_flSeqStartTime`. The `CBaseAnimGraphController` class is implied by the name, not established by the slot data, so whether it restarts the cycle or blends is unverified.", + "source": "generated" + }, + "CBaseButton::DrawDebugTextOverlays": { + "text": "Emits the button's developer debug-text overlay lines, the on-screen dump a mapper uses to inspect state such as `m_nState` and `m_bLocked` while testing. The `CBaseButton` class is implied by the name, and the exact contents of the overlay are a name-level reading.", + "source": "generated" + }, + "CBaseButton::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CBaseButton`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseButton::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CBaseButton`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseButton::InputLock": { + "text": "Handles the `Lock` entity-IO input on `CBaseButton`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseButton::InputPress": { + "text": "Handles the `Press` entity-IO input on `CBaseButton`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseButton::InputPressIn": { + "text": "Handles the `PressIn` entity-IO input on `CBaseButton`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseButton::InputPressOut": { + "text": "Handles the `PressOut` entity-IO input on `CBaseButton`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseButton::InputUnlock": { + "text": "Handles the `Unlock` entity-IO input on `CBaseButton`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseClientUIEntity::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CBaseClientUIEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseClientUIEntity::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CBaseClientUIEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseCombatCharacter::GiveAmmo": { + "text": "Grants ammunition into a combat character's reserve pool \u2014 the server-side path for topping players and NPCs up on ammo rather than handing them a weapon. Read from the name and its `CBaseCombatCharacter` binding; the amount actually granted, and any clamping against a carry limit, is not established here.", + "source": "generated" + }, + "CBaseCombatCharacter::InputSetRelationship": { + "text": "Handles the `SetRelationship` entity-IO input on `CBaseCombatCharacter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseCombatCharacter::UpdateLastKnownNav": { + "text": "Refreshes the character's cached last-known navigation location, the bookkeeping that lets AI and nav queries recall where it last stood on the mesh; related to `m_nNavHullIdx` and `m_eHull`. Anchored by the string `UpdateLastKnownNav` and read from the name, so the update conditions are unverified.", + "source": "generated" + }, + "CBaseDMStart::IsTriggered": { + "text": "Tests whether this deathmatch spawn point is currently enabled, which is what a mapper gates through `m_Master`. The `CBaseDMStart` class is implied by the name, so the precise activation condition is a reading of the name plus that field rather than a verified check.", + "source": "generated" + }, + "CBaseDoor::GetDataDescMap": { + "text": "Exposes the door's data description map \u2014 the table describing its saved fields, keyvalues and inputs \u2014 which is what generic entity tooling reads to enumerate them. The `CBaseDoor` class is implied by the name, not established by the slot data.", + "source": "generated" + }, + "CBaseDoor::InputClose": { + "text": "Handles the `Close` entity-IO input on `CBaseDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseDoor::InputLock": { + "text": "Handles the `Lock` entity-IO input on `CBaseDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseDoor::InputOpen": { + "text": "Handles the `Open` entity-IO input on `CBaseDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseDoor::InputSetNoNPCs": { + "text": "Handles the `SetNoNPCs` entity-IO input on `CBaseDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseDoor::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CBaseDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseDoor::InputSetToggleState": { + "text": "Handles the `SetToggleState` entity-IO input on `CBaseDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseDoor::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CBaseDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseDoor::InputUnlock": { + "text": "Handles the `Unlock` entity-IO input on `CBaseDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseEntity::AbsVelocity": { + "text": "Reads the entity's absolute world-space velocity, the motion tracked in m_vecAbsVelocity, rather than a parent-relative or base velocity; it also ships under the name GetAbsVelocity. Read from the name and the class's velocity fields, so exactly which field it sources is inferred, not verified.", + "source": "generated" + }, + "CBaseEntity::AcceptInput": { + "text": "Delivers a named entity input, the map-I/O mechanism Hammer and scripts drive, to this entity so it acts on it; also shipped as CEntityInstance::AcceptInput. Read from the name; which input names are accepted and how they are handled is not established by this data.", + "source": "generated" + }, + "CBaseEntity::ApplyAbsVelocityImpulse": { + "text": "Adds an instantaneous impulse to the entity's absolute velocity, a one-step way to knock back or launch something instead of writing m_vecAbsVelocity yourself each tick. Read from the name and that field; whether mass scales the impulse, and the units used, are unverified.", + "source": "generated" + }, + "CBaseEntity::ChangeTeam": { + "text": "Moves the entity onto a different team, updating the team number carried in m_iTeamNum together with whatever bookkeeping a team change entails. The CBaseEntity class is implied by the name rather than established by the data, and the side effects beyond the team number are unverified.", + "source": "generated" + }, + "CBaseEntity::ClearNavIgnoreContentsThink": { + "text": "Clears the entity's nav-ignore contents state from a think pass, so navigation stops treating that entity's contents as ignorable. Read from the name alone at low confidence; the exact state cleared and the think context it runs in are unverified.", + "source": "generated" + }, + "CBaseEntity::CreateEntityByName": { + "text": "Creates a new entity instance from a class-name string, the usual way to spawn entities from code, and also ships as CGameEntitySystem::CreateEntityByName, CreateEntityByName and UTIL::CreateEntityByName. Read from the name; whether the new entity arrives already spawned or still needs initialising is not established here.", + "source": "generated" + }, + "CBaseEntity::EmitSoundFilter": { + "text": "Plays a sound on the entity for a caller-supplied recipient filter instead of a default audience, which is what you want for team-only or single-player cues; also shipped as EmitSound. Read from the name; the filter form and how the sound is identified are unverified.", + "source": "generated" + }, + "CBaseEntity::EmitSoundParams": { + "text": "Plays a sound on the entity using an explicit parameter set, such as volume and pitch overrides, rather than the sound entry's defaults; also shipped as ScriptEmitSoundParams. Read from the name and that script alias, so the parameters actually exposed are unverified.", + "source": "generated" + }, + "CBaseEntity::EnableHammerUniqueId": { + "text": "Turns on use of the entity's Hammer unique identifier, the level-editor ID surfaced in m_sUniqueHammerID, so map-authored entities stay identifiable at runtime. Read from the name and that field; what the toggle changes, and its scope, are unverified.", + "source": "generated" + }, + "CBaseEntity::Event_Killed": { + "text": "Handles the entity's death event and the bookkeeping around it, the hook to target when observing or altering kills, alongside m_lifeState and the m_OnKilled output. The CBaseEntity class is implied by the name rather than shown by the data, and what the event carries is unverified.", + "source": "generated" + }, + "CBaseEntity::GetEyeAngles": { + "text": "Gives the entity's eye or view angles, the orientation used for aiming and view-direction maths rather than the entity's model angles. The CBaseEntity class is implied by the name rather than established by the data, and the frame of reference of the value is unverified.", + "source": "generated" + }, + "CBaseEntity::GetEyePosition": { + "text": "Gives the entity's eye position, the world-space point to use as a view or line-of-sight origin rather than the entity's origin. The CBaseEntity class is implied by the name rather than established by the data, and how the eye offset is derived is unverified.", + "source": "generated" + }, + "CBaseEntity::ImpactTrace": { + "text": "Applies this entity's response to a bullet or trace impact, the decal and effect work driven by a trace result striking it. The CBaseEntity class is implied by the name rather than established by the data, and the effects produced and any physics response are unverified.", + "source": "generated" + }, + "CBaseEntity::InputEnable": { + "text": "Enables the entity in response to the map input of that name, the runtime switch for turning a map-placed entity on. Read from the name alone at low confidence; what enabling changes for a given entity type is unverified.", + "source": "generated" + }, + "CBaseEntity::InputSetParentAttachment": { + "text": "Parents the entity onto a named attachment point of its parent in response to the map input of that name, so it rides that attachment. Read from the name; whether it snaps onto the attachment or keeps the current offset, the distinction CBaseEntity::InputSetParentAttachmentMaintainOffset names, is unverified.", + "source": "generated" + }, + "CBaseEntity::InputSetParentAttachmentMaintainOffset": { + "text": "Parents the entity to a named attachment point while preserving its current offset from that point instead of snapping onto it, the behaviour named by its SetParentAttachmentMaintainOffset input string. Also shipped as InputSetParentAttachmentMaintainOffset; how the offset is captured and maintained is unverified.", + "source": "generated" + }, + "CBaseEntity::IsPlayerController": { + "text": "Reports whether this entity is a player controller, the type test to run before treating an entity as controller-side rather than pawn-side. The CBaseEntity class is implied by the name rather than established by the data, and the criteria the test applies are unverified.", + "source": "generated" + }, + "CBaseEntity::IsPlayerPawn": { + "text": "Reports whether this entity is a player pawn, the in-world body a class such as CCSPlayerPawn represents, so pawns can be filtered out of a general entity list. The CBaseEntity class is implied by the name rather than established by the data, and the test's criteria are unverified.", + "source": "generated" + }, + "CBaseEntity::IsWeapon": { + "text": "Reports whether this entity is a weapon, the type test for picking weapon entities out of a general entity sweep. The CBaseEntity class is implied by the name rather than established by the data, and what qualifies as a weapon here is unverified.", + "source": "generated" + }, + "CBaseEntity::PerformInvalidatePhysicsRecursive": { + "text": "Invalidates cached physics state for the entity and, per its name, its children, the refresh needed after a transform or hierarchy change so stale collision and movement data is not reused; the PerformInvalidatePhysicsRecursive string is present verbatim. Confidence is low, and which cached values are dropped is unverified.", + "source": "generated" + }, + "CBaseEntity::PhysicsPushRotate": { + "text": "Rotates a moving physics pusher and carries the entities it pushes around with it; the warning text 'Pushing rotation hard!' lives in this code, pointing at the case where a blocked push is forced through. Confidence is low, and the blocking behaviour and which entities get pushed are unverified.", + "source": "generated" + }, + "CBaseEntity::Precache": { + "text": "Loads the assets an entity type needs, such as models, sounds and particles, before it is used, so a custom entity's resources exist by the time it appears. The CBaseEntity class is implied by the name rather than established by the data, and what any given subclass precaches is not established here.", + "source": "generated" + }, + "CBaseEntity::SUB_FadeOut": { + "text": "Fades the entity out over time, the cleanup helper for making something disappear gradually instead of vanishing in a single frame. Read from the name alone at low confidence; the fade duration, the render effect used, and whether it also removes the entity are unverified.", + "source": "generated" + }, + "CBaseEntity::SetAbsAngles": { + "text": "Sets the entity's absolute world-space orientation, the write to use when placing or re-aiming an entity outside its parent's frame; also shipped as ScriptSetAbsAngles. Read from the name; whether child transforms or physics state are re-derived along with the angles is unverified.", + "source": "generated" + }, + "CBaseEntity::SetAbsOrigin": { + "text": "Sets the entity's absolute world-space position, the direct placement write behind teleport-like moves and spawn positioning; also shipped as SetAbsOrigin. Read from the name; whether collision state or the parent hierarchy is updated alongside the position is not established here.", + "source": "generated" + }, + "CBaseEntity::SetAbsVelocity": { + "text": "Sets the entity's absolute world-space velocity outright, replacing existing motion rather than adding to it the way an impulse does; the value corresponds to m_vecAbsVelocity, and it also ships as SetAbsVelocity. Whether m_vecBaseVelocity or the networked velocity are updated with it is unverified.", + "source": "generated" + }, + "CBaseEntity::SetGravityScale": { + "text": "Scales how strongly gravity pulls on this entity, the per-entity dial for floaty or heavy movement without touching the global gravity setting; also shipped as SetGravityScale. Read from the name; the neutral value and the interaction with the entity's move type are unverified.", + "source": "generated" + }, + "CBaseEntity::SetGroundEntity": { + "text": "Sets what this entity is standing on, the handle tracked in m_hGroundEntity together with the ground body recorded in m_nGroundBodyIndex; also shipped as SetGroundEntity. Read from the name and those fields, so the flag and friction side effects of the change are unverified.", + "source": "generated" + }, + "CBaseEntity::SetMass": { + "text": "Sets the mass of the entity's physics representation, and its error text 'Tried to call SetMass() on %s but it has no physics.' shows it expects the entity to own a physics object and complains when it does not. Also shipped as CBreakable::InputSetMass; confidence is low, and the units and any clamping are unverified.", + "source": "generated" + }, + "CBaseEntity::SetMoveType": { + "text": "Sets the entity's movement mode, the m_MoveType value selecting how the engine moves it, along with the collision behaviour that accompanies the mode. Read from the name and that field; the accepted values, and whether m_nPreviouslySetMoveType or m_nActualMoveType are maintained here, are unverified.", + "source": "generated" + }, + "CBaseEntity::SetOwner": { + "text": "Sets the entity's owner, the handle in m_hOwnerEntity used for attributing projectiles and for owner-based collision exclusion. The CBaseEntity class is implied by the name rather than established by the data, and the collision and damage-attribution consequences are unverified.", + "source": "generated" + }, + "CBaseEntity::SetParent": { + "text": "Attaches the entity to a parent so it inherits that parent's transform, the operation behind following, mounted and carried entities. Read from the name; whether an attachment point or an existing offset is preserved, which CBaseEntity::InputSetParentAttachment covers separately, is unverified.", + "source": "generated" + }, + "CBaseEntity::Spawn": { + "text": "Brings the entity into play, running the per-class initialisation that turns a freshly created entity into a live one with its keyvalues applied. The CBaseEntity class is implied by the name rather than established by the data, and the initialisation a given subclass performs is not established here.", + "source": "generated" + }, + "CBaseEntity::StartTouch": { + "text": "Handles the moment another entity begins touching this one, the entry hook for trigger-style volumes as distinct from the continuing contact CBaseEntity::Touch names. The CBaseEntity class is implied by the name rather than established by the data, and the touching entity's role in the handler is unverified.", + "source": "generated" + }, + "CBaseEntity::StopSound": { + "text": "Stops a sound currently playing on the entity \u2014 the stop side of `CBaseEntity::EmitSoundParams` and `CBaseEntity::EmitSoundFilter`. Read from the name; the data does not establish how the target sound is selected, so treat matching by name, channel, or handle as unverified.", + "source": "generated" + }, + "CBaseEntity::TakeDamage": { + "text": "Applies incoming damage to the entity \u2014 the embedded anchor `CBaseEntity::TakeDamageOld:` ties this code to the class's damage path. Pair it with m_iHealth, m_bTakesDamage, m_nTakeDamageFlags and m_hDamageFilter; the anchor names an older variant, so exactly which behaviour ships here is unverified.", + "source": "generated" + }, + "CBaseEntity::Teleport": { + "text": "Moves the entity instantly to a new origin and angles, and can reset its velocity, rather than sweeping it through the world \u2014 the tool for respawns and repositioning. The owning class is implied by the name rather than established by the data, so the exact fields it writes are unverified.", + "source": "generated" + }, + "CBaseEntity::Touch": { + "text": "Handles the entity's ongoing contact with another entity, the recurring touch case rather than the first-contact one named by `CBaseEntity::StartTouch`; m_pfnTouch holds the touch handler a modder would swap. The class is implied by the name rather than carried in the data, so the exact contact conditions are unverified.", + "source": "generated" + }, + "CBaseEntity::UpdateWaterState": { + "text": "Recomputes the entity's submersion state \u2014 whether it sits in water or slime and to what degree \u2014 refreshing that bookkeeping as the entity moves. Read from the name alongside m_nWaterTouch and m_nSlimeTouch; no prototype is derived, so the precise fields written and the triggering conditions are unverified.", + "source": "generated" + }, + "CBaseFileSystem::Close": { + "text": "Closes a file handle obtained from the filesystem, releasing its descriptor and buffers. The `CBaseFileSystem` class is implied by the name; a plugin that opens files with `CBaseFileSystem::Open` needs this to avoid leaking handles across a long-lived server session.", + "source": "generated" + }, + "CBaseFileSystem::FileExists": { + "text": "Reports whether a file is present at a path within the filesystem's search paths, without opening it \u2014 the cheap existence probe before loading a config or map-specific data. The `CBaseFileSystem` class is implied by the name, and the search-path semantics are a name-level reading.", + "source": "generated" + }, + "CBaseFileSystem::FindFirstHelper": { + "text": "Begins a wildcard directory search and produces the first match plus the handle for continuing enumeration with `CBaseFileSystem::FindNext`. The `Helper` in the name marks it as the shared internal worker behind the public find-first surface; match ordering and path filtering are unverified.", + "source": "generated" + }, + "CBaseFileSystem::FindNext": { + "text": "Advances an in-progress wildcard search to the next matching file, the iteration step for walking a directory's contents. Read from the name; whether directories appear among the matches, and how exhaustion is signalled, are not established by this data.", + "source": "generated" + }, + "CBaseFileSystem::GetFileTime": { + "text": "Reports a file's modification timestamp, the value to compare when deciding whether a cached config or asset has gone stale and needs reloading. The `CBaseFileSystem` class is implied by the name; the timestamp's epoch and the handling of missing files are a name-level reading.", + "source": "generated" + }, + "CBaseFileSystem::GetPathTime": { + "text": "Reports the modification time associated with a path, useful for invalidating a cache keyed on a whole search path rather than one file. Read from the name, so which of several search-path hits it reflects, and the units of the value, are unverified.", + "source": "generated" + }, + "CBaseFileSystem::IsOk": { + "text": "Reports whether an open file handle is still in a good state, the error check to consult before trusting data taken from it. The `CBaseFileSystem` class is implied by the name; whether reaching end-of-file counts as not-ok is not established here.", + "source": "generated" + }, + "CBaseFileSystem::Open": { + "text": "Opens a file by path and yields the handle the other filesystem entry points operate on \u2014 the way into reading or writing server-side files from a plugin. Read from the name; the accepted access modes and how a path resolves across search paths are unverified.", + "source": "generated" + }, + "CBaseFileSystem::Read": { + "text": "Pulls bytes from an open file handle into a caller-supplied buffer, advancing the stream position. The `CBaseFileSystem` class is implied by the name; how a short read is reported, and how it relates to `CBaseFileSystem::IsOk`, are a name-level reading.", + "source": "generated" + }, + "CBaseFileSystem::ReadEx": { + "text": "Reads file data with the extra control the `Ex` suffix implies \u2014 an extended form of `CBaseFileSystem::Read` for callers needing more say over buffering than the plain read offers. Read from the name, so what the extension actually controls is not established by this data.", + "source": "generated" + }, + "CBaseFileSystem::Seek": { + "text": "Moves the read/write position within an open file handle, letting a plugin jump to a record or re-read a header instead of streaming from the start. The `CBaseFileSystem` class is implied by the name; the accepted seek origins are a name-level reading.", + "source": "generated" + }, + "CBaseFileSystem::Size": { + "text": "Reports the byte length of a file, the figure to size a buffer against before pulling one in whole. The `CBaseFileSystem` class is implied by the name; whether it answers for an open handle, a bare path, or both is not established here.", + "source": "generated" + }, + "CBaseFileSystem::Tell": { + "text": "Reports the current read/write offset within an open file handle \u2014 the counterpart to seeking, useful for noting a position to come back to. The `CBaseFileSystem` class is implied by the name, and the origin the offset is measured from is a name-level reading.", + "source": "generated" + }, + "CBaseFileSystem::Write": { + "text": "Puts caller-supplied bytes into an open file handle, the route a plugin takes to persist logs, stats or generated configuration. The `CBaseFileSystem` class is implied by the name; whether writes are buffered until the handle closes, and how failures surface, are not established here.", + "source": "generated" + }, + "CBaseFilter::InputTestActivator": { + "text": "Handles the `TestActivator` entity-IO input on `CBaseFilter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseFilter::PassesFilterImpl": { + "text": "Decides whether a candidate entity passes this filter \u2014 the `Impl` half of the test, with `m_bNegated` inverting the verdict and `m_OnPass`/`m_OnFail` carrying it out to map logic. The `CBaseFilter` class is implied by the name, so the pass condition is a name-and-field reading.", + "source": "generated" + }, + "CBaseGameStats::Event_LevelInit": { + "text": "Records the stats system's level-start event, emitting `CBaseGameStats::Event_LevelInit [%s]` with the level identifier. A natural hook for beginning per-map stat accumulation; the anchor establishes the logging, while anything else it tallies is not established here.", + "source": "generated" + }, + "CBaseGameStats::Event_LevelShutdown": { + "text": "Records the stats system's level-teardown event, the level-init counterpart and the point where per-map totals would be finalised. The `CBaseGameStats` class is implied by the name, so what statistics it actually writes out is a name-level reading.", + "source": "generated" + }, + "CBaseGameStats::Event_MapChange": { + "text": "Records a map change in the game stats system, the marker separating one map's accumulated statistics from the next. Read from the name; whether it carries the outgoing map, the incoming one, or both is not established by this data.", + "source": "generated" + }, + "CBaseGameStats::Event_PlayerConnected": { + "text": "Records a player connecting, emitting `CBaseGameStats::Event_PlayerConnected [%s]` with the player's identifier. A useful hook for opening per-player session tracking; the anchor establishes the logging, but what is persisted beyond that line is not established here.", + "source": "generated" + }, + "CBaseGameStats::Event_PlayerDisconnected": { + "text": "Records a player leaving, emitting `CBaseGameStats::Event_PlayerDisconnected [%s]` with the player's identifier \u2014 the natural place to close out that session's accumulated stats. The anchor establishes the logging; whether disconnect reason or session length is also captured is not established here.", + "source": "generated" + }, + "CBaseGameStats::Event_PlayerKilled": { + "text": "Records a player's death from the victim's side, emitting `CBaseGameStats::Event_PlayerKilled [%s] [%dth death]`. The anchor establishes both the victim identifier and a running per-player death tally, so a cumulative count is being kept; what else the entry stores is not established here.", + "source": "generated" + }, + "CBaseGameStats::Event_PlayerKilledOther": { + "text": "Records a kill from the attacker's side, emitting `CBaseGameStats::Event_PlayerKilledOther [%s] killed [%s]` with killer and victim identifiers. The anchor establishes that both parties are captured; whether weapon, position or damage detail is recorded alongside them is not established here.", + "source": "generated" + }, + "CBaseGameStats_Driver::Event_LevelShutdown": { + "text": "Marks the end of a level for the game-statistics driver, a hook where per-map stats are wrapped up as the map tears down. The class is implied by the name, and no prototype is derived, so what it records or flushes is unverified.", + "source": "generated" + }, + "CBaseGameStats_Driver::Event_LoadGame": { + "text": "Notifies the game-statistics driver that a saved game has been loaded, so stat tracking can pick up restored state. The class is implied by the name, and no prototype is derived, so what it resets or resumes is unverified.", + "source": "generated" + }, + "CBaseGameStats_Driver::Event_SaveGame": { + "text": "Notifies the game-statistics driver that a game is being saved, the point at which accumulated stats would be captured alongside the save. The class is implied by the name, and no prototype is derived, so what it writes is unverified.", + "source": "generated" + }, + "CBaseGameStats_Driver::Event_Shutdown": { + "text": "Shuts down the game-statistics driver itself, a teardown hook distinct from the per-level CBaseGameStats_Driver::Event_LevelShutdown. The class is implied by the name, and no prototype is derived, so its final flush or cleanup work is unverified.", + "source": "generated" + }, + "CBaseGameUIInputHandler::GetName": { + "text": "Returns an identifying name for the handler; beyond that its purpose is not established by this data. The class is implied by the name, not derived from the entry itself.", + "source": "generated" + }, + "CBaseGameUIInputHandler::HandleInputEvent": { + "text": "Handles an input event for a game-UI input handler, where a UI element consumes key, mouse or controller input and decides whether to swallow it. The class is implied by the name, and no prototype is derived, so which event kinds it accepts is unverified.", + "source": "generated" + }, + "CBaseGrenade::Explode": { + "text": "Detonates the grenade and produces its explosion, carrying the string anchor Grenade.Explode. Tuning a blast means m_DmgRadius, m_flDamage and m_flDetonateTime, with m_hThrower for attribution and the m_OnExplode output to hook; no prototype is derived, so its inputs and timing are unverified.", + "source": "generated" + }, + "CBaseModelEntity::GetBoneTransform": { + "text": "Fetches the transform of a bone on the entity's model, giving a bone-accurate position and orientation for attachments, effects or hit tests. Read from the name, with a prototype derived for this entry; the coordinate space of the transform is not established here.", + "source": "generated" + }, + "CBaseModelEntity::InputSetBodyGroup": { + "text": "Backs the entity input named by its own anchor InputSetBodyGroup, switching which bodygroup of the model is shown from a map or I/O trigger. The selection lives in m_bodyGroupChoices; confidence is low and no prototype is derived, so the accepted value format is unverified.", + "source": "generated" + }, + "CBaseModelEntity::LookupBone": { + "text": "Resolves a bone on the entity's model by name into the identifier the bone APIs use, pairing naturally with CBaseModelEntity::GetBoneTransform. Read from the name, with a prototype derived; what it yields for an unknown bone is not established here.", + "source": "generated" + }, + "CBaseModelEntity::SUB_FadeOut": { + "text": "Fades the entity out of sight over time as a deferred cleanup step, rather than deleting it outright. Read from the name; no prototype is derived, so the fade duration and whether the entity is removed at the end are unverified.", + "source": "generated" + }, + "CBaseModelEntity::SetBodyGroupByName": { + "text": "Selects a bodygroup on the entity's model by bodygroup name, a usual way to swap visible model parts on props, weapons and player models. Shipped as the same function as CBaseModelEntity::SetBodygroup, with the chosen values held in m_bodyGroupChoices; a prototype is derived, though its failure behaviour is unverified.", + "source": "generated" + }, + "CBaseModelEntity::SetBodygroup": { + "text": "Sets which submodel a bodygroup on the entity's model shows, changing which parts of the model are visible. This is the same function as CBaseModelEntity::SetBodyGroupByName, and m_bodyGroupChoices holds the per-group selection; the reading comes from the name, so exact indexing rules are unverified.", + "source": "generated" + }, + "CBaseModelEntity::SetCollisionBounds": { + "text": "Sets the entity's collision bounds, the box used for collision and traces, independently of its render model. Shipped as the same function as ScriptSetSize, with the bounds living on m_Collision; read from the name, so whether it also refreshes spatial partitioning is unverified.", + "source": "generated" + }, + "CBaseModelEntity::SetMaterialGroupMask": { + "text": "Applies a material-group mask to the entity, choosing which material variants of the model render \u2014 a mechanism behind material and skin swaps. Read from the name, with a prototype derived; the bit meanings are model-authored and not established by this data.", + "source": "generated" + }, + "CBaseModelEntity::SetModel": { + "text": "Assigns a model to the entity, a runtime way to change what it renders and what its model-derived collision uses. Shipped as the same function as UTIL_SetModel; a prototype is derived, though precache requirements and whether bounds are refreshed are unverified.", + "source": "generated" + }, + "CBaseModelEntity::SetModelScale": { + "text": "Scales the entity's model, resizing how large it appears in the world. Shipped as the same function as Script_SetModelScale; a prototype is derived, but whether collision bounds in m_Collision follow the scale is unverified.", + "source": "generated" + }, + "CBaseModelEntity::SetRenderAttribute": { + "text": "Sets a named render attribute on the entity into a fixed-size slot table; its own error string reports FAILED to set %s, no more slots available (maximum %d) when that table is full. Values are stored in m_vecRenderAttributes, and with low confidence and no derived prototype the attribute naming rules are unverified.", + "source": "generated" + }, + "CBaseModelEntityAPI::SetRenderAttribute": { + "text": "Sets a named render attribute to a four-float value, as its log line shows: CBaseModelEntityAPI::SetRenderAttribute on %s: Set %s to [%.2f %.2f %.2f %.2f]. This is the API-surface form for driving material or shader parameters such as tint, with values landing in CBaseModelEntity's m_vecRenderAttributes; confidence is low, so accepted attribute names are unverified.", + "source": "generated" + }, + "CBaseMoveBehavior::~CBaseMoveBehavior": { + "text": "Tears down a move-behavior instance, the keyframe-path mover whose state includes m_pCurrentKeyFrame, m_pTargetKeyFrame and m_iPositionInterpolator. The class is implied by the name; a prototype is derived, but which resources the destructor releases is unverified.", + "source": "generated" + }, + "CBasePlayerController::CanHearAndReadChatFrom": { + "text": "Decides whether this controller may hear and read chat from another player, a natural gate for team-only chat, mutes and spectator rules, alongside m_iIgnoreGlobalChat. The class is implied by the name, and no prototype is derived, so the exact conditions it applies are unverified.", + "source": "generated" + }, + "CBasePlayerController::CheckPawn": { + "text": "Validates the controller's link to its pawn, the m_hPawn handle that ties a controller to the pawn it drives. Read from the name, with a prototype derived; what it does when that handle is stale or empty is not established here.", + "source": "generated" + }, + "CBasePlayerController::HandleCommandJoinTeam": { + "text": "Handles a player's request to join a team and rejects bad values, logging HandleCommand_JoinTeam( %d ) - invalid. A mod can gate or override team selection here; no prototype is derived, so the team numbering it accepts is unverified.", + "source": "generated" + }, + "CBasePlayerController::OnSimulateUserCommands": { + "text": "Runs the user commands queued for this controller on a tick, and warns about slow batches with '%s' took %.1fms to execute %d commands, backlog is %d commands. Shipped as the same function as CCSPlayerController::PhysicsSimulate and PhysicsSimulate, with m_nTickBase and m_bLagCompensation among the state involved.", + "source": "generated" + }, + "CBasePlayerController::RoundRespawn": { + "text": "Respawns the controller's player for a new round, a per-round respawn hook on the controller rather than on the pawn. The class is implied by the name, and no prototype is derived, so whether it spawns, teleports or only resets state is unverified.", + "source": "generated" + }, + "CBasePlayerController::SwitchSteam": { + "text": "Switches the Steam identity attached to this controller, the m_steamID and m_szNetworkIDString pairing that identifies the player. Read from the name, with a prototype derived; when or why an identity is swapped is not established by this data.", + "source": "generated" + }, + "CBasePlayerPawn::CommitSuicide": { + "text": "Kills the pawn at the player's own request, as with a kill or explode command rather than damage from an attacker. The class is implied by the name; m_fNextSuicideTime reads as its cooldown and m_flDeathTime as the recorded time, though no prototype is derived.", + "source": "generated" + }, + "CBasePlayerPawn::FindMatchingWeaponsForTeamLoadout": { + "text": "Searches a team's loadout for weapons matching a requested item, a lookup used when giving a player the loadout entry that fits their team. Shipped as the same function as CCSPlayer_FindMatchingWeaponsForTeamLoadout, with m_pItemServices and m_pWeaponServices holding related pawn state; a prototype is derived, though the match criteria are unverified.", + "source": "generated" + }, + "CBasePlayerPawn::GetEyeAngles": { + "text": "Returns the pawn's eye angles, the view direction used for aiming, traces and where the player is looking; v_angle on the class holds that orientation. Read from the name; no prototype is derived, so whether it reports networked, predicted or clamped angles is unverified.", + "source": "generated" + }, + "CBasePlayerPawn::GetEyePosition": { + "text": "Returns the pawn's eye position in world space, the origin used for view traces, shots and line-of-sight checks. Read from the name, with m_vecViewOffset the plausible offset applied to the pawn's origin; no prototype is derived, so the exact construction is unverified.", + "source": "generated" + }, + "CBasePlayerPawn::InputSetFogController": { + "text": "Handles the `SetFogController` entity-IO input on `CBasePlayerPawn`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePlayerPawn::InputSetHUDVisibility": { + "text": "Handles the `SetHUDVisibility` entity-IO input on `CBasePlayerPawn`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePlayerPawn_RemovePlayerItem": { + "text": "Removes a weapon or item from a player's inventory and tears down the owned weapon entity. The same code is shipped as CCSPlayer_WeaponServices::Destroy at medium confidence; hook it to intercept weapon loss, drops, or stripping.", + "source": "generated" + }, + "CBasePlayerPawn_SnapViewAngles": { + "text": "Snaps a player pawn's view angles to a new orientation immediately rather than easing into it, the usual mechanism for forcing where a player is looking. Also shipped under the bare name SnapViewAngles as the same function; the exact angle handling is a name-level reading.", + "source": "generated" + }, + "CBasePlayerWeapon::InputSetClipPrimary": { + "text": "Handles the `SetClipPrimary` entity-IO input on `CBasePlayerWeapon`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePlayerWeapon::InputSetClipSecondary": { + "text": "Handles the `SetClipSecondary` entity-IO input on `CBasePlayerWeapon`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseProp::CBaseProp": { + "text": "Constructs a prop entity and brings up its CBaseProp state, including m_iShapeType, m_bModelOverrodeBlockLOS and m_bConformToCollisionBounds. Purpose beyond construction is not established by this data.", + "source": "generated" + }, + "CBaseProp::ParsePropData": { + "text": "Reads a prop's authored prop-data and applies it to the entity, turning model and keyvalue settings into runtime state such as m_iShapeType and m_bConformToCollisionBounds. Read from the name; no prototype is derived, so the data's source and its defaults are unverified.", + "source": "generated" + }, + "CBasePropDoor::InputClose": { + "text": "Handles the `Close` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePropDoor::InputLock": { + "text": "Handles the `Lock` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePropDoor::InputOpen": { + "text": "Handles the `Open` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePropDoor::InputOpenAwayFrom": { + "text": "Handles the `OpenAwayFrom` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePropDoor::InputOpenAwayFromActivator": { + "text": "Handles the `OpenAwayFromActivator` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePropDoor::InputPlayerClose": { + "text": "Handles the `PlayerClose` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePropDoor::InputPlayerOpen": { + "text": "Handles the `PlayerOpen` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePropDoor::InputSetNoNPCs": { + "text": "Handles the `SetNoNPCs` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePropDoor::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePropDoor::InputUnlock": { + "text": "Handles the `Unlock` entity-IO input on `CBasePropDoor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePulseGraphInstance::CBasePulseGraphInstance": { + "text": "Constructs a pulse graph instance and emits the trace line `CBasePulseGraphInstance::CBasePulseGraphInstance( %p )` carrying the new instance pointer. It brings up the object that hosts a compiled Pulse graph on the server; the initial state it establishes is read from the name and anchor, not derived.", + "source": "generated" + }, + "CBasePulseGraphInstance::EndGraphReload": { + "text": "Closes out a hot-reload of the instance's Pulse graph, tracing `CBasePulseGraphInstance::EndGraphReload( %p ) %s` with the instance pointer and a status string. Useful as a watchpoint when Pulse graphs are swapped at runtime; the bookkeeping it restores is not established by this data.", + "source": "generated" + }, + "CBasePulseGraphInstance::InitInstance_Internal": { + "text": "Performs the internal setup of a pulse graph instance, tracing `CBasePulseGraphInstance::InitInstance_Internal( %s; %p ) %s` with a name-like string, the instance pointer and a status string. The anchor marks it as the internal half of instance initialization; what it binds or allocates is unverified.", + "source": "generated" + }, + "CBasePulseGraphInstance::Shutdown": { + "text": "Shuts a pulse graph instance down, tracing `CBasePulseGraphInstance::Shutdown( %s; %p ) %s` with a name-like string, the instance pointer and a status string. Read from the name and anchor as the teardown of the instance's runtime state; the exact cleanup is unverified.", + "source": "generated" + }, + "CBasePulseGraphInstance::StartGraphReload": { + "text": "Opens a hot-reload of the instance's Pulse graph, tracing `CBasePulseGraphInstance::StartGraphReload( %p ) %s` with the instance pointer and a status string. The name and anchor indicate it puts the instance into a reloading state; what it preserves across the reload is not derived.", + "source": "generated" + }, + "CBaseQueuedRenderable::Age": { + "text": "Advances or reports how long a queued renderable has existed, the basis for expiring time-limited render items. The class is implied by the name rather than established by the data, and no prototype is derived, so the time units and what it mutates are unverified.", + "source": "generated" + }, + "CBaseQueuedRenderable::ShouldDestroy": { + "text": "Reports whether a queued renderable has outlived its usefulness and can be discarded. The class is implied by the name rather than established by the data; the conditions it tests are unverified.", + "source": "generated" + }, + "CBaseRecognizer::mismatch": { + "text": "Signals the failed-match case during recognition. The name indicates it marks or reports a mismatch, but this data does not establish what the recognizer compares or what it does with the result.", + "source": "generated" + }, + "CBaseToggle::CBaseToggle": { + "text": "Constructs a CBaseToggle, the base for brush entities that move between two configured states, initializing toggle bookkeeping such as `m_toggle_state`, `m_vecPosition1`, `m_vecPosition2` and `m_flWait`. Read from the name and the class's fields; the exact defaults it writes are not derived here.", + "source": "generated" + }, + "CBaseTrigger::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputEndTouch": { + "text": "Handles the `EndTouch` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputStartTouch": { + "text": "Handles the `StartTouch` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputTouchTest": { + "text": "Handles the `TouchTest` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::PassesTriggerFilters": { + "text": "Decides whether a touching entity is admitted by the trigger, consulting its filter (`m_hFilter`, named by `m_iFilterName`, a `CBaseFilter`) and disabled state (`m_bDisabled`). The class is implied by the name; this is the hook point for adding custom admission rules to trigger volumes.", + "source": "generated" + }, + "CBaseTrigger::~CBaseTrigger": { + "text": "Destroys a trigger entity and releases its per-trigger state, including the touch tracking behind `m_hTouchingEntities` and the filter handle `m_hFilter`. The class is implied by the name; the exact teardown performed is not derived from this data.", + "source": "generated" + }, + "CBaseTrigger_EndTouch": { + "text": "Handles an entity ceasing to overlap a trigger volume, the natural place to react when something leaves a zone. Read from the name; whether it also maintains the trigger's touch bookkeeping, and the exact timing, are unverified.", + "source": "generated" + }, + "CBaseTrigger_StartTouch": { + "text": "Handles an entity beginning to overlap a trigger volume, where entry logic for zones, hurt volumes, and objective areas takes hold. Read from the name; the overlap test it relies on and the timing of the handling are unverified.", + "source": "generated" + }, + "CBeam::DrawDebugTextOverlays": { + "text": "Draws the beam's debug text overlay, including an `end : (%.2f,%.2f,%.2f)` line reporting the beam endpoint held in `m_vecEndPos`. Use it when debugging beam placement or attachment with entity text overlays turned on.", + "source": "generated" + }, + "CBeam::GetDataDescMap": { + "text": "Exposes the beam's data description map, the per-class table tying keyvalues and saved members to fields such as `m_fWidth`, `m_fAmplitude` and `m_vecEndPos`. The class is implied by the name; treat it as the datadesc accessor when resolving beam keyvalues to storage.", + "source": "generated" + }, + "CBeam::InputNoise": { + "text": "Handles the `Noise` entity-IO input on `CBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBeam::InputWidth": { + "text": "Handles the `Width` entity-IO input on `CBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBenchmarkService::Connect": { + "text": "Connects the benchmark service to the engine interfaces it needs before it can do any work, the usual bring-up handshake for a loop service. Class is implied by the name rather than derived, so which interfaces it acquires stays unverified.", + "source": "generated" + }, + "CBenchmarkService::Disconnect": { + "text": "Releases the engine interfaces the benchmark service holds, undoing what CBenchmarkService::Connect established. Class is implied by the name; the data does not establish what it drops.", + "source": "generated" + }, + "CBenchmarkService::GetBuildType": { + "text": "Reports which build configuration the benchmark service identifies itself with, useful when benchmark output has to be attributed to a debug or release build. Class is implied by the name, and the concrete build values are unverified.", + "source": "generated" + }, + "CBenchmarkService::GetDependencies": { + "text": "Reports which other systems the benchmark service requires, so dependency resolution can account for them when the service is brought up. Class is implied by the name; the dependency entries themselves are not in this data.", + "source": "generated" + }, + "CBenchmarkService::GetName": { + "text": "Returns the service's name string, and the name does not indicate any purpose beyond that. Class is implied by the name.", + "source": "generated" + }, + "CBenchmarkService::GetRenderingMultiplier": { + "text": "Returns the rendering multiplier the benchmark applies, a scale factor for how much rendering work a run drives. Class is implied by the name, and what the multiplier actually scales is a name-level reading.", + "source": "generated" + }, + "CBenchmarkService::GetServiceDependencies": { + "text": "Reports which other services this one requires, a service-scoped counterpart to CBenchmarkService::GetDependencies. Class is implied by the name; the entries it reports are unverified.", + "source": "generated" + }, + "CBenchmarkService::GetServiceIndex": { + "text": "Returns the index this service was assigned in the engine's service table, the read side of CBenchmarkService::SetServiceIndex. Class is implied by the name; the indexing scheme is unverified.", + "source": "generated" + }, + "CBenchmarkService::GetTier": { + "text": "Reports the initialization tier the benchmark service belongs to, the layer grouping used when systems come up. Class is implied by the name and the tier values are unverified.", + "source": "generated" + }, + "CBenchmarkService::Init": { + "text": "Initializes the benchmark service; the name does not establish what state it prepares. Class is implied by the name.", + "source": "generated" + }, + "CBenchmarkService::IsActive": { + "text": "Reports whether the benchmark service is currently active, the query paired with CBenchmarkService::SetActive. Class is implied by the name; the condition behind the answer is unverified.", + "source": "generated" + }, + "CBenchmarkService::IsSingleton": { + "text": "Reports whether the engine should keep one shared instance of this service instead of a separate instance per loop. Class is implied by the name, so the reading is name-level.", + "source": "generated" + }, + "CBenchmarkService::OnLoopActivate": { + "text": "Handles the engine loop the service lives in becoming active, the point where a benchmark would begin collecting for that loop. Class is implied by the name, so the activation work is unverified.", + "source": "generated" + }, + "CBenchmarkService::OnLoopDeactivate": { + "text": "Handles the engine loop becoming inactive, where a benchmark would stop collecting and release per-loop state. Class is implied by the name; the teardown it performs is not established.", + "source": "generated" + }, + "CBenchmarkService::PreShutdown": { + "text": "Performs the benchmark service's early teardown work, a shutdown phase kept distinct from CBenchmarkService::Shutdown. Class is implied by the name; what it releases is not established.", + "source": "generated" + }, + "CBenchmarkService::QueryInterface": { + "text": "Resolves a requested interface exposed by the benchmark service, the generic interface lookup a caller uses to reach it. Class is implied by the name; which interfaces it answers for is unverified.", + "source": "generated" + }, + "CBenchmarkService::Reconnect": { + "text": "Re-resolves the service's engine interfaces, refreshing bindings that CBenchmarkService::Connect first established when the interface set changes. Class is implied by the name, so the reading is name-level.", + "source": "generated" + }, + "CBenchmarkService::RegisterEventMap": { + "text": "Registers the benchmark service's event handlers with the engine's event system so it receives the events it subscribes to. Class is implied by the name; which events are registered is not established.", + "source": "generated" + }, + "CBenchmarkService::SetActive": { + "text": "Turns the benchmark service on or off, the setter behind CBenchmarkService::IsActive. Class is implied by the name; any side effects of flipping the flag are unverified.", + "source": "generated" + }, + "CBenchmarkService::SetName": { + "text": "Sets the service's name string, the write side of CBenchmarkService::GetName. Class is implied by the name.", + "source": "generated" + }, + "CBenchmarkService::SetServiceIndex": { + "text": "Stores the index the engine assigns this service, read back through CBenchmarkService::GetServiceIndex. Class is implied by the name; the indexing scheme is unverified.", + "source": "generated" + }, + "CBenchmarkService::ShouldActivate": { + "text": "Decides whether the benchmark service should activate for a given loop, letting the engine skip it where benchmarking is not wanted. Class is implied by the name; the criteria it weighs are unverified.", + "source": "generated" + }, + "CBenchmarkService::Shutdown": { + "text": "Shuts the benchmark service down and releases what it set up. Class is implied by the name; the specific teardown is not established.", + "source": "generated" + }, + "CBenchmarkService::~CBenchmarkService": { + "text": "Destroys a benchmark service instance and frees what it owns. Class is implied by the name; nothing further about its cleanup is established.", + "source": "generated" + }, + "CBlood::InputEmitBlood": { + "text": "Handles the `EmitBlood` entity-IO input on `CBlood`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBodyComponentBaseAnimGraph::FrameAdvance": { + "text": "Advances the entity's animation graph by an interval of time, stepping the CBaseAnimGraphController held in m_animationController so poses and graph state move forward. Read from the name and that field; the time source and update conditions are unverified.", + "source": "generated" + }, + "CBodyComponentBaseAnimGraph::SetPlaybackRate": { + "text": "Sets how fast the component's animation graph plays, a speed scale applied to the CBaseAnimGraphController in m_animationController and the knob to reach for when speeding up or slowing an entity's animation. Name-level reading; units and clamping are unverified.", + "source": "generated" + }, + "CBodyComponentSkeletonInstance::PostDataUpdate": { + "text": "Handles the component's post-data-update pass over the CSkeletonInstance in m_skeletonInstance, reconciling skeleton state with values that have just been applied from the network; the string PostDataUpdate is present in the binary. What it recomputes is a name-level reading.", + "source": "generated" + }, + "CBodyGameSystem::NotifyResourcePreReload": { + "text": "Handles a body resource that is about to be reloaded, logging the resource together with its reference count via the format 'CBodyGameSystem::NotifyResourcePreReload[%s] %s (RC=%d)' so bodies using it can let go of it before the swap. Relevant when hot-reloading model assets; the release work itself is unverified.", + "source": "generated" + }, + "CBodyGameSystem::NotifyResourceStatusChange": { + "text": "Handles a change in a body resource's load status, logging the resource with its reference count and load-type fields via 'CBodyGameSystem::NotifyResourceStatusChange[%s] %s (RC=%d,LT=%s)' so cached bodies can react to it becoming available or going away. The statuses it distinguishes are not established here.", + "source": "generated" + }, + "CBoneMergeCache::MergeMatchingBones": { + "text": "Copies transforms from a parent model's bones onto the matching bones of an attached child model, and warns \"Bone merge bones from parent were invalid: parent model '%s': our model '%s'\" when the parent's bones do not line up. Relevant to attachments such as weapons or clothing following another entity's skeleton; the matching rule is a name-level reading.", + "source": "generated" + }, + "CBoneSetup::AllocateResult": { + "text": "Allocates the result storage a bone-setup pass fills with its computed pose. The owning class is implied by the name rather than established by the data, so the buffer's size, contents and lifetime rules are unverified.", + "source": "generated" + }, + "CBoneSetup::FreeResult": { + "text": "Releases result storage previously handed out for a bone-setup pass. The owning class is implied by the name; pair it with CBoneSetup::AllocateResult when you drive bone setup yourself, though the ownership rules are not derived.", + "source": "generated" + }, + "CBoneSetup::GetCModel": { + "text": "Retrieves the model the bone setup is running against, the object that supplies bone and pose-parameter definitions. The class is implied by the name, and the returned model's concrete type is not established by this data.", + "source": "generated" + }, + "CBoneSetup::GetPoseParameter": { + "text": "Reads the current value of one pose parameter driving the model's animation blending. The class is implied by the name; the indexing scheme and whether the value is normalised or in model units are unverified.", + "source": "generated" + }, + "CBoneSetup::GetPoseParameterArray": { + "text": "Hands back the pose-parameter values as a block instead of one lookup at a time like CBoneSetup::GetPoseParameter. The class is implied by the name, so the array's layout, length and ownership are not derived.", + "source": "generated" + }, + "CBoneSetup::GetRealtime": { + "text": "Supplies the real-time clock value the bone setup uses when evaluating time-dependent animation. The class is implied by the name; whether this is engine wall-clock time or a snapshot taken per setup is not established.", + "source": "generated" + }, + "CBotAgent::Crouch": { + "text": "Performs the crouch action for a behavior-tree bot agent; the shipped warning [ AI BT ]: '%s': Crouching is not supported by this agent. shows the base implementation declines and logs when the agent type lacks crouch support. Override it in a derived agent if behavior-tree crouch actions should take effect.", + "source": "generated" + }, + "CBotAgent::Inventory": { + "text": "Performs the inventory action (item or weapon selection) for a behavior-tree bot agent; the shipped warning [ AI BT ]: '%s': Inventory is not supported by this agent. shows the base implementation declines and logs for agent types without inventory support. Override it to give a custom agent working inventory actions.", + "source": "generated" + }, + "CBotAgent::Reload": { + "text": "Performs the reload action for a behavior-tree bot agent; the shipped warning [ AI BT ]: '%s': Reloading is not supported by this agent. shows the base implementation declines and logs when the agent type cannot reload. Override it in a derived agent to make behavior-tree reload actions work.", + "source": "generated" + }, + "CBotManager::IsLineBlockedBySmoke": { + "text": "Tests whether a sight line passes through enough smoke to be considered blocked, the smoke-awareness query behind bot vision. Read from the name and the IsLineBlockedBySmoke anchor; the density model, sampling and inputs are unverified.", + "source": "generated" + }, + "CBotManager::IsVisibleThroughSmoke": { + "text": "Answers whether something can still be seen when smoke lies along the sight line, a visibility verdict rather than the blocking test of CBotManager::IsLineBlockedBySmoke. Read from the name and the IsVisibleThroughSmoke anchor; thresholds are not derived.", + "source": "generated" + }, + "CBotManager::StartFrame": { + "text": "Runs the bot manager's per-frame update, the tick where manager-wide bot bookkeeping happens. Read from the name and the StartFrame anchor; what it actually updates is not established, so treat it as a per-frame hook rather than a documented API.", + "source": "generated" + }, + "CBreakable::DrawDebugTextOverlays": { + "text": "Contributes the breakable's debug text to its on-screen overlay when debug overlays are enabled, which is how you inspect a breakable's live state in-world. The class is implied by the name, and the exact lines emitted are not derived.", + "source": "generated" + }, + "CBreakable::GetDataDescMap": { + "text": "Returns the entity's datadesc map, the table describing its saved and keyvalue fields plus input handlers such as CBreakable::InputSetHealth and CBreakable::InputSetEnableBreaking. The class is implied by the name; use it to enumerate an entity's data description at runtime.", + "source": "generated" + }, + "CBreakable::InputAddHealth": { + "text": "Handles the `AddHealth` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputBreak": { + "text": "Handles the `Break` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputRemoveHealth": { + "text": "Handles the `RemoveHealth` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputSetEnableBreaking": { + "text": "Handles the `SetEnableBreaking` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputSetEnableCollisions": { + "text": "Handles the `SetEnableCollisions` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputSetHealth": { + "text": "Handles the `SetHealth` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputSetMass": { + "text": "Handles the `SetMass` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::GetDataDescMap": { + "text": "Returns the prop's datadesc map, covering its keyvalue and saved fields plus prop-specific inputs such as CBreakableProp::InputSetNavIgnore and CBreakableProp::InputDisablePuntSound alongside fields like m_iszPuntSound and m_bUsePuntSound. The class is implied by the name.", + "source": "generated" + }, + "CBreakableProp::InputAddHealth": { + "text": "Handles the `AddHealth` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputBreak": { + "text": "Handles the `Break` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputDisablePuntSound": { + "text": "Handles the `DisablePuntSound` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputEnablePuntSound": { + "text": "Handles the `EnablePuntSound` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputForceDrop": { + "text": "Handles the `ForceDrop` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputRemoveHealth": { + "text": "Handles the `RemoveHealth` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputSetEnableBreaking": { + "text": "Handles the `SetEnableBreaking` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputSetEnableCollisions": { + "text": "Handles the `SetEnableCollisions` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputSetHealth": { + "text": "Handles the `SetHealth` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputSetNavIgnore": { + "text": "Handles the `SetNavIgnore` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBtTree::Update": { + "text": "Ticks a behavior tree, evaluating its nodes so the owning agent settles on a current action. Read from the name and the CBtTree::Update ( %d ) log format, which tags each update with a numeric value whose meaning is not identified here.", + "source": "generated" + }, + "CBugBugService::OnEventBugBug": { + "text": "Responds to a BugBug event on this service, an internal Valve diagnostic and bug-reporting path rather than gameplay code. The class is implied by the name, and what the event carries or causes is not established.", + "source": "generated" + }, + "CBugService::OnFrameBoundary": { + "text": "Handles the bug service's per-frame boundary, the point where the in-game bug reporter gets a hook each frame. The class is implied by the name; what it samples or records at that boundary is not derived.", + "source": "generated" + }, + "CC4::AbortBombPlant": { + "text": "Cancels a C4 plant already under way, taking the bomb back out of its arming sequence. Read from the name together with CC4's arming state m_bStartedArming, m_fArmedTime, m_bPlayedArmingBeeps and m_bIsPlantingViaUse; which of those it clears is unverified.", + "source": "generated" + }, + "CC4::Holster": { + "text": "Stows the C4 when the carrier switches away from it. The class is implied by the name; hook it to react to the bomb being put away, though whether it also tears down arming state such as m_bStartedArming is unverified.", + "source": "generated" + }, + "CCS2PawnGraphController::CreateAndBindController": { + "text": "Creates a pawn's animation-graph controller and binds it so graph parameters like m_moveType, m_flMoveSpeedHorizontal and m_flAimPitchAngle can be driven from gameplay state. Read from the name; the binding mechanism and what owns the controller are not derived.", + "source": "generated" + }, + "CCS2PawnGraphController::ReflectPawnState": { + "text": "Pushes the pawn's current gameplay state into its animation graph, feeding controller parameters such as m_moveType, m_flCrouchAmount, m_bIsDefusing, m_flFlashedAmount and m_flAimYawAngle. Read from the name and the ReflectPawnState anchor; the per-parameter mapping and update conditions are not derived.", + "source": "generated" + }, + "CCS2WeaponGraphController::ReflectWeaponState": { + "text": "Pushes the weapon's current state into the weapon animation graph, feeding parameters such as m_weaponType, m_flWeaponAmmo, m_bWeaponIsSilenced, m_flWeaponIronsightAmount and m_reloadStage. Read from the name and the ReflectWeaponState anchor; how each parameter is computed is not established.", + "source": "generated" + }, + "CCSBot::BendLineOfSight": { + "text": "Searches for a bent, around-the-corner line of sight from the bot toward a point when the direct line is blocked. Read from the name together with `m_bentNoisePosition` and `m_bendNoisePositionValid`, which hold a bent position and its validity flag; the search method and its conditions are unverified.", + "source": "generated" + }, + "CCSBot::Blind": { + "text": "Puts the bot into a blinded state, as from a flashbang, so it cannot see normally for a period. Read from the name and `m_blindFire`, a flag covering firing while sightless; the blind duration, triggers and recovery behaviour are unverified.", + "source": "generated" + }, + "CCSBot::ComputePartPositions": { + "text": "Computes the world positions of a player's individual body parts (head, chest and similar) used as aim and visibility sample points. Read from the name alongside `CCSBot::GetPartPosition` and `CCSBot::IsEnemyPartVisible`, which share the same body-part notion; which parts exist and how they are stored are unverified.", + "source": "generated" + }, + "CCSBot::ComputePath": { + "text": "Builds a navigation path for the bot toward a goal position on the nav mesh. Read from the name with the path state fields `m_pathIndex`, `m_pathLadderEnd` and `m_repathTimer`; the goal source, path storage and failure handling are unverified.", + "source": "generated" + }, + "CCSBot::FindMostDangerousThreat": { + "text": "Picks out the enemy the bot should treat as its most dangerous current threat. Read from the name next to `CCSBot::SetBotEnemy`, which records a chosen enemy; the scoring criteria, candidate set and visibility requirements are unverified.", + "source": "generated" + }, + "CCSBot::GetPartPosition": { + "text": "Returns the world position of one of a player's tracked body parts, for aiming or visibility tests. Read from the name alongside `CCSBot::ComputePartPositions`, which shares the same body-part notion; the part identifiers and how fresh the position is are unverified.", + "source": "generated" + }, + "CCSBot::GuardHostageEscapeZone": { + "text": "Puts the bot into guarding a hostage escape (rescue) zone, holding a covering position over it. The debug anchor `GoingToGuardHostageEscapeZone` supports this reading; which zone is picked, where the bot posts up and how long it stays are unverified.", + "source": "generated" + }, + "CCSBot::GuardHostages": { + "text": "Sends the bot to guard the hostages themselves, covering them against a rescue attempt. Read from the name with the hostage fields `m_hostageEscortCount` and `m_isWaitingForHostage`; the guard position selection and the conditions that end the behaviour are unverified.", + "source": "generated" + }, + "CCSBot::IsEnemyPartVisible": { + "text": "Tests whether a particular body part of the bot's enemy is currently visible to it, rather than testing the whole player. Read from the name alongside `CCSBot::ComputePartPositions`, which shares the same body-part notion; the trace used and which enemy is meant are unverified.", + "source": "generated" + }, + "CCSBot::MoveToInitialEncounter": { + "text": "Moves the bot toward the map's initial encounter area, the place where opposing teams are expected to first meet, logging `MoveToInitialEncounter: Pathfind failed.` when no path exists. That failure string confirms pathfinding is involved; how the encounter spot is chosen is unverified.", + "source": "generated" + }, + "CCSBot::Panic": { + "text": "Throws the bot into a panicked reaction, as when startled by an unseen threat, so it behaves erratically for a spell. Read from the name and `m_panicTimer`, a timer bounding such a state; the triggers and the actual panicked behaviour are unverified.", + "source": "generated" + }, + "CCSBot::Retreat": { + "text": "Makes the bot break off and fall back from where it is, moving away from danger. Read from the name; whether it selects a retreat destination or simply backs along its existing route, and what ends the retreat, are unverified.", + "source": "generated" + }, + "CCSBot::SendRadioMessage": { + "text": "Has the bot issue a radio message to its team, logged as `%3.1f: SendRadioMessage( %s )` with the message named. The anchor confirms a named radio message is emitted; the available message set and any rate limiting are unverified.", + "source": "generated" + }, + "CCSBot::SetBotEnemy": { + "text": "Sets the player the bot currently treats as its enemy, logged as `SetBotEnemy: %s`. Useful for forcing which target a bot fixates on; the anchor confirms a named entity is recorded, while accompanying effects such as reaction or attack state are unverified.", + "source": "generated" + }, + "CCSBot::SetLookAt": { + "text": "Aims the bot's view at a described target for a period, logged as `%3.1f SetLookAt( %s ), duration = %f`. The anchor establishes that a target and a duration are involved; priority against competing look requests and expiry behaviour are unverified.", + "source": "generated" + }, + "CCSBot::SetState": { + "text": "Switches the bot to a new behaviour state, logged as `%s: SetState: %s -> %s` with the outgoing and incoming state names. The anchor establishes a named-state transition; `m_stateTimestamp` marks when the current state began, while the set of states and their entry effects are unverified.", + "source": "generated" + }, + "CCSBot::StopAttacking": { + "text": "Ends the bot's current attack so it stops engaging its target. Read from the name and `m_isAttacking`, a flag marking the attacking condition; what else the call clears, such as the enemy reference or aim target, is unverified.", + "source": "generated" + }, + "CCSBot::UpdateGrenadeThrow": { + "text": "Drives the bot's in-progress grenade throw, including aborting when a teammate stands in the line, which logs `%3.2f: Grenade: Friend is in the way...`. That string confirms a friendly-blocking check; the aim solution, timing and grenade choice are unverified.", + "source": "generated" + }, + "CCSBot::UpdateLookAngles": { + "text": "Steps the bot's view angles toward its current look target, producing the gradual aim turn rather than a snap. Read from the name with `m_lookAheadAngle` and `m_bEyeAnglesUnderPathFinderControl`, which marks pathfinder ownership of the eye angles; turn rates and exact inputs are unverified.", + "source": "generated" + }, + "CCSBot::UpdatePeripheralVision": { + "text": "Refreshes what the bot notices at the edges of its view, its peripheral awareness of the surroundings. Read from the name; the field of view used, what it samples and what it records on noticing something are unverified.", + "source": "generated" + }, + "CCSBot::UpdateReactionQueue": { + "text": "Advances the bot's reaction queue, a delay buffer that keeps it from responding to what it sees instantly and gives human-like latency. Read from the name with the timing fields `m_surpriseTimer` and `m_alertTimer`; the queue depth and delay values are unverified.", + "source": "generated" + }, + "CCSBotChatter::Affirmative": { + "text": "Makes the bot deliver an affirmative radio callout, acknowledging a teammate's request or order. Read from the name alongside the other chatter phrases in this class; the conditions that prompt it and how the voice line is picked are not established here.", + "source": "generated" + }, + "CCSBotChatter::BarelyDefused": { + "text": "Speaks the bot's reaction to a bomb defused with almost no time to spare, selecting the phrase named by the BarelyDefused string carried in the function. Hook it to retime or silence that reaction; what margin counts as barely is not established here.", + "source": "generated" + }, + "CCSBotChatter::BombsiteClear": { + "text": "Speaks the bot's callout that a bombsite it has checked is clear, keyed by the BombsiteClear phrase string in the function. Useful when you want to filter or replace bot site-clear radio; what clearing the site requires is not established here.", + "source": "generated" + }, + "CCSBotChatter::GoingToDefendBombsite": { + "text": "Speaks the bot's announcement that it is heading to defend a bombsite, keyed by the GoingToDefendBombsite phrase string in the function. Which site the call names, and whether the bot has already committed to that plan, is not established here.", + "source": "generated" + }, + "CCSBotChatter::GoingToPlantBomb": { + "text": "Speaks the bot's announcement that it intends to go plant the bomb, keyed by the GoingToPlantBomb phrase string in the function. It reads as the intent call rather than CCSBotChatter::PlantingBomb, which names the plant itself; exact triggers are unverified.", + "source": "generated" + }, + "CCSBotChatter::HeardNoise": { + "text": "Speaks the bot's reaction to a noise it has picked up, such as nearby footsteps or gunfire, keyed by the HeardNoise phrase string in the function. Which sound events reach it, and at what range, are not established here.", + "source": "generated" + }, + "CCSBotChatter::HostagesBeingTaken": { + "text": "Speaks the bot's warning that the enemy is currently taking the hostages, keyed by the HostagesBeingTaken phrase string in the function. Relevant when tuning bot behaviour on hostage maps; nothing here establishes what hostage state it inspects.", + "source": "generated" + }, + "CCSBotChatter::HostagesTaken": { + "text": "Speaks the bot's callout that the hostages have been taken, keyed by the HostagesTaken phrase string in the function. It reads as the completed counterpart to CCSBotChatter::HostagesBeingTaken; the conditions that separate the two are not established here.", + "source": "generated" + }, + "CCSBotChatter::KilledFriend": { + "text": "Speaks the bot's reaction to killing a teammate, the apology chatter, keyed by the KilledFriend phrase string in the function. Useful if you want teamkill barks muted or replaced; how the kill is attributed to the bot is not established here.", + "source": "generated" + }, + "CCSBotChatter::Negative": { + "text": "Makes the bot deliver a negative radio callout, declining or answering no to a teammate. Read from the name as the counterpart to CCSBotChatter::Affirmative; what prompts it and which line is chosen are not established here.", + "source": "generated" + }, + "CCSBotChatter::OnMyWay": { + "text": "Has the bot announce that it is on its way to a teammate or a requested location. Read from the name; nothing here establishes what destination the call references or when the bot decides to make it.", + "source": "generated" + }, + "CCSBotChatter::PinnedDown": { + "text": "Speaks the bot's call that it is pinned down under fire and unable to move, keyed by the PinnedDown phrase string in the function. What suppression or damage state drives the call is not established here.", + "source": "generated" + }, + "CCSBotChatter::PlantingBomb": { + "text": "Has the bot announce that it is planting the bomb. Read from the name as the plant-in-progress line beside CCSBotChatter::GoingToPlantBomb, which reads as the intent call; the point at which it fires is not established here.", + "source": "generated" + }, + "CCSBotChatter::RequestReport": { + "text": "Speaks the bot's request that teammates report in with their status, keyed by the RequestReport phrase string in the function. It reads as the prompt side of a status exchange; who is asked and how replies are handled are not established here.", + "source": "generated" + }, + "CCSBotChatter::ScaredEmote": { + "text": "Plays the bot's frightened reaction chatter, keyed by the ScaredEmote phrase string in the function. What fear or threat state drives it, and whether an animation accompanies the line, is not established here.", + "source": "generated" + }, + "CCSBotChatter::SniperWarning": { + "text": "Speaks the bot's warning to teammates that an enemy sniper is covering an area, keyed by the SniperWarning phrase string in the function. How the sniper is identified, and whether the warning carries a location, are not established here.", + "source": "generated" + }, + "CCSBotChatter::SpottedLooseBomb": { + "text": "Has the bot call out a dropped bomb it has spotted lying on the ground. Read from the name beside CCSBotChatter::WhereIsTheBomb; whether it fires purely on sight, and what it reports about the bomb's position, is not established here.", + "source": "generated" + }, + "CCSBotChatter::WhereIsTheBomb": { + "text": "Speaks the bot's question asking teammates where the bomb is, keyed by the WhereIsTheBomb phrase string in the function. When a bot decides it has lost track of the bomb, and who it expects an answer from, are not established here.", + "source": "generated" + }, + "CCSBotManager::BotAddCommand": { + "text": "Implements the bot-add server command, creating a bot and putting it into the game. Read from the name beside CCSBotManager::BotPlaceCommand; a plugin that manages its own bot population will care about this entry, though the arguments it accepts are not established here.", + "source": "generated" + }, + "CCSBotManager::BotPlaceCommand": { + "text": "Moves a bot to a human player's position for the bot-place server command, and reports \"Error: BotPlaceCommand() could not find a human player to move a bot to.\" when no human player is available. Handy for staging bots during map or navigation testing.", + "source": "generated" + }, + "CCSBotManager::MaintainBotQuota": { + "text": "Keeps the number of bots in the game at the configured quota, adding or removing bots as player slots change; the fill_with_minimum string in the function ties it to quota-fill handling. Block or hook it when your plugin owns bot counts itself.", + "source": "generated" + }, + "CCSBotManager::ServerCommand": { + "text": "Handles server console command input aimed at the bot manager. Read from the name, sitting alongside CCSBotManager::BotAddCommand and CCSBotManager::BotPlaceCommand; which commands and arguments it covers is not established here.", + "source": "generated" + }, + "CCSFunFactMgr::FireGameEvent": { + "text": "Receives a fired game event for the fun-fact system, feeding the round statistics that become end-of-round fun facts. The CCSFunFactMgr class is implied by the name rather than given by the data, and the entry sits at an unbound vtable slot, so the events it listens for are unverified.", + "source": "generated" + }, + "CCSGOInput": { + "text": "Deals with client-side player input, the CCSGOInput object in libclient that gathers a player's control state. Read from the name alone, so whether this constructs, accesses, or updates that object is not established.", + "source": "generated" + }, + "CCSGOVScriptGameSystem::DestroyVM": { + "text": "Destroys the VScript virtual machine held by this game system, releasing the script state it owns. A prototype is derived for this entry so it is well pinned, but what becomes of live script handles, and whether a fresh VM can be created afterwards, is not established here.", + "source": "generated" + }, + "CCSGO_EndOfMatchLineupStart": { + "text": "Starts the end-of-match lineup, the closing presentation in which players are arranged for the post-match view. Read from the name; what it positions, and what match state it establishes, are unverified.", + "source": "generated" + }, + "CCSGameModeRules_ArmsRace::EndRound": { + "text": "Ends the current Arms Race round and applies that mode's round-end handling. The CCSGameModeRules_ArmsRace class is implied by the name, not by the data; the field a plugin usually reads alongside it is m_WeaponSequence, the mode's ordered weapon progression.", + "source": "generated" + }, + "CCSGameRules::AddTeamAccount": { + "text": "Credits a cash award to a team's account, the money bookkeeping behind round-end and objective payouts. Read from the name; no prototype is derived, so which team it credits, how the amount is chosen, and any cap handling are unverified.", + "source": "generated" + }, + "CCSGameRules::AreTeamsPlayingSwitchedSides": { + "text": "Reports whether the teams are currently playing on swapped sides, as they do after a halftime switch, which is what you need to map a team index back to the side it started on. Also shipped under the unqualified name AreTeamsPlayingSwitchedSides; the reading is from the name, with m_totalRoundsPlayed and m_nRoundsPlayedThisPhase as the related counters.", + "source": "generated" + }, + "CCSGameRules::BalanceTeams": { + "text": "Rebalances the two teams so their player counts even out, moving players across as needed. Read from the name; no prototype is derived, so how it picks who moves and whether it acts at once or at a round boundary are unverified.", + "source": "generated" + }, + "CCSGameRules::BeginGameRestart": { + "text": "Starts a full game restart after a delay, logging \"GMR_BeginGameRestart - delay = %.1fs\" with the wait it will use. Read m_bGameRestart and m_flRestartRoundTime to observe or override a restart that is already pending.", + "source": "generated" + }, + "CCSGameRules::BeginIntermission": { + "text": "Puts the server into the end-of-match intermission, logging \"GMR_BeginIntermission\". The intermission window shows up in m_gamePhase and m_timeUntilNextPhaseStarts, which is what to read when timing custom end-of-match behaviour.", + "source": "generated" + }, + "CCSGameRules::BeginWarmupPeriod": { + "text": "Starts the warmup period for a chosen duration, logging \"GMR_BeginWarmupPeriod - will last %.1fs\". The matching state is m_bWarmupPeriod together with m_fWarmupPeriodStart and m_fWarmupPeriodEnd, which is what to read or adjust when extending or shortening warmup.", + "source": "generated" + }, + "CCSGameRules::ClientCommandKeyValues": { + "text": "Handles a client command delivered to the game rules as a KeyValues block, with the anchor \"InvalidSteamLogon\" showing it rejects a request from a client lacking a valid Steam logon. A useful interception point for client-driven rules commands, though which command names it accepts is unverified.", + "source": "generated" + }, + "CCSGameRules::Constructor": { + "text": "Constructs the CS game-rules object and brings its state up from nothing, logging \"%s: CGameRules::CGameRules constructed\". This is where the CCSGameRules field block first exists, so it is a natural place to install hooks or seed custom defaults.", + "source": "generated" + }, + "CCSGameRules::CreateEndMatchMapGroupVoteOptions": { + "text": "Builds the list of next-map choices offered in the end-of-match vote, drawing on the map group and on mp_endmatch_votenextmap_wargames_modes, warning \"Invalid skirmish '%s'\" for a mode it cannot resolve. Hook or replace it to control what appears on the end-of-match vote panel; m_nNextMapInMapgroup tracks the map group position.", + "source": "generated" + }, + "CCSGameRules::EndOfMatchLineupEnd": { + "text": "Finishes the end-of-match lineup, the scripted line-up of players presented once a match is over. Read from the name; no prototype is derived, so what staging it tears down and what it restores are unverified.", + "source": "generated" + }, + "CCSGameRules::EndWarmup": { + "text": "Ends the warmup period, carrying the \"#SFUI_Notice_All_Players_Connected\" notice used when the lobby has filled. Use it to force warmup to finish early, and read m_bWarmupPeriod and m_fWarmupPeriodEnd for the state it settles.", + "source": "generated" + }, + "CCSGameRules::FPlayerCanRespawn": { + "text": "Decides whether a given player is permitted to respawn right now, logging \"FPlayerCanRespawn: pPlayer=0\" when handed a null player. This is the natural hook for custom respawn rules such as deathmatch-style instant respawn or ticketed revives.", + "source": "generated" + }, + "CCSGameRules::FrameUpdatePreEntityThink": { + "text": "Runs the game-rules work for the per-frame pre-entity-think stage, where frame-level rules bookkeeping happens. The class here is implied by the name rather than established by the data \u2014 only vtable slot 18 is derived \u2014 so both the owning type and the work it performs are unverified.", + "source": "generated" + }, + "CCSGameRules::GetChatFormat": { + "text": "Supplies the localization format token used to render a chat line, with \"Cstrike_Chat_AllDead\" as the dead-players variant. Override it to change chat prefixes or attach custom tags that vary with the speaker's team and alive state.", + "source": "generated" + }, + "CCSGameRules::HandleSwapTeams": { + "text": "Carries out the team swap that puts each side on the opposite team, as happens at halftime. Read from the name, so exactly what it moves is unverified; CCSGameRules::AreTeamsPlayingSwitchedSides reports the resulting orientation.", + "source": "generated" + }, + "CCSGameRules::IsLastRoundBeforeHalfTime": { + "text": "Reports whether the round now in progress is the last one before halftime, which is what you want for side-switch messaging or for changing economy handling on that round. Also shipped as IsLastRoundBeforeHalfTime; the reading is from the name, with m_totalRoundsPlayed and m_nRoundsPlayedThisPhase as the counters involved.", + "source": "generated" + }, + "CCSGameRules::OnTeamsSwappedAtRoundReset": { + "text": "Applies the game-rules bookkeeping for teams having been swapped as part of a round reset. Read from the name; a sensible place to fix up per-team custom state so it follows the players, though exactly which fields it updates is unverified.", + "source": "generated" + }, + "CCSGameRules::PlayerCanHearChat": { + "text": "Decides whether one player may hear another player's chat, the gate behind alive-versus-dead and team-only chat restrictions. Hook it alongside CCSGameRules::GetChatFormat to build custom visibility rules, such as letting dead players hear the living or opening cross-team chat in casual modes.", + "source": "generated" + }, + "CCSGameRules::ResetMatch": { + "text": "Resets the match to its starting state, logging \"GMR_ResetMatch\". Match-level state such as m_totalRoundsPlayed, m_nRoundsPlayedThisPhase and m_bHasMatchStarted is what to read around it when implementing a custom match restart or scrim flow.", + "source": "generated" + }, + "CCSGameRules::ResetRound": { + "text": "Resets per-round state back to its start-of-round values, logging \"GMR_ResetRound\". It is the round-scoped counterpart to CCSGameRules::ResetMatch; m_fRoundStartTime, m_iRoundTime and m_bFreezePeriod are the fields a modder would inspect alongside it.", + "source": "generated" + }, + "CCSGameRules::RestartRound": { + "text": "Restarts the current round, including selecting the spawn-point configuration \u2014 it logs \"Using spawn points configuration 0x%08X\". Use it to force a fresh round from a plugin; m_fRoundStartTime, m_iFreezeTime and m_bFreezePeriod describe the round timing that results.", + "source": "generated" + }, + "CCSGameRules::SetGamePhase": { + "text": "Sets the match's game phase, with the \"GamePhaseChanged\" anchor indicating it also signals the change outward. m_gamePhase holds the value and m_nOvertimePlaying the overtime count, so this is the lever for driving custom phase transitions such as entering overtime.", + "source": "generated" + }, + "CCSGameRules::StartCTTimeOut": { + "text": "Begins a Counter-Terrorist tactical timeout, pausing play on that side's request. Read from the name; m_bCTTimeOutActive, m_flCTTimeOutRemaining and m_nCTTimeOuts hold the timeout state, and m_bMatchWaitingForResume covers the paused match.", + "source": "generated" + }, + "CCSGameRules::StartTerroristTimeOut": { + "text": "Begins a Terrorist tactical timeout, pausing play on that side's request. Read from the name; m_bTerroristTimeOutActive, m_flTerroristTimeOutRemaining and m_nTerroristTimeOuts hold the timeout state, and m_bMatchWaitingForResume covers the paused match.", + "source": "generated" + }, + "CCSGameRules::TerminateRound": { + "text": "Ends the round in progress and settles its outcome, making it the entry point when a plugin needs to call a round early. Also shipped as TerminateRound; m_iRoundWinStatus and m_eRoundWinReason carry the result, and the reading comes from the name rather than a derived prototype.", + "source": "generated" + }, + "CCSGameRules::WillTeamHaveRoomForPlayer": { + "text": "Reports whether a team still has room to accept another player, the capacity check behind join and team-change requests. Consult or override it alongside CCSGameRules::BalanceTeams when writing custom team-join, auto-assign or reserved-slot rules.", + "source": "generated" + }, + "CCSGameRules_GoToIntermission": { + "text": "Puts the match into intermission, the break that ends active play, and emits a line recording both teams' scores and the elapsed minutes. That score anchor plus the name make the role clear; what else intermission changes on CCSGameRules is not established.", + "source": "generated" + }, + "CCSGameStats::Event_Commentary": { + "text": "Records a commentary stats event, logging under the anchor CBaseGameStats::Event_Commentary [%d] with a numeric identifier for the commentary item. The anchor fixes the event's identity; which counters it touches is unverified, so treat it as a hook point for tracking commentary usage.", + "source": "generated" + }, + "CCSGameStats::Event_CrateSmashed": { + "text": "Records a stats event for a crate being smashed, carrying the anchor CBaseGameStats::Event_CrateSmashed. The anchor names the event but does not establish what the stat write updates, so use it as a notification point for destructible-crate breakage rather than as a counter you can read.", + "source": "generated" + }, + "CCSGameStats::Event_Credits": { + "text": "Records a credits stats event, carrying the anchor CBaseGameStats::Event_Credits. The anchor establishes the event's identity only; what triggers it and what it accumulates are unverified.", + "source": "generated" + }, + "CCSGameStats::Event_DecrementPlayerEnteredNoClip": { + "text": "Backs out a previously recorded noclip entry for a named player, per the anchor CBaseGameStats::Event_DecrementPlayerEnteredNoClip [%s] decrementing NOCLIPe. Pair it with CCSGameStats::Event_PlayerEnteredNoClip when a noclip toggle should not leave the session flagged as cheated.", + "source": "generated" + }, + "CCSGameStats::Event_Init": { + "text": "Starts a game-stats session, logging the session ordinal through the anchor CBaseGameStats::Event_Init [%dth session]. The anchor establishes that sessions are counted; exactly which stats state is prepared is unverified.", + "source": "generated" + }, + "CCSGameStats::Event_LoadGame": { + "text": "Performs the game-stats bookkeeping associated with a saved game being loaded. The class CCSGameStats is implied by the name rather than established by the data, since the entry sits at an unbound vtable slot, and the name is the sole evidence for what it does.", + "source": "generated" + }, + "CCSGameStats::Event_MapChange": { + "text": "Handles the game-stats side of a map change, the point at which per-map stats state would be rolled over. The class CCSGameStats is implied by the name, not by the data, and what is flushed or reset at the change is unverified.", + "source": "generated" + }, + "CCSGameStats::Event_PlayerEnteredGodMode": { + "text": "Records that a named player enabled god mode, logging the anchor CBaseGameStats::Event_PlayerEnteredGodMode [%s] entered GOD mode. Useful for detecting sessions whose recorded stats should be treated as non-competitive.", + "source": "generated" + }, + "CCSGameStats::Event_PlayerEnteredNoClip": { + "text": "Records that a named player enabled noclip, logging the anchor CBaseGameStats::Event_PlayerEnteredNoClip [%s] entered NOCLIPe. Its counterpart CCSGameStats::Event_DecrementPlayerEnteredNoClip reverses the record, so the pair behaves like a tracked flag on the session.", + "source": "generated" + }, + "CCSGameStats::Event_PreSaveGameLoaded": { + "text": "Handles stats bookkeeping for a saved game about to be loaded, logging the anchor CBaseGameStats::Event_PreSaveGameLoaded [%s] %s with the names it reports. The anchor confirms the event and its save-load context; what state is captured is unverified.", + "source": "generated" + }, + "CCSGameStats::Event_Punted": { + "text": "Records a punt stats event for a named subject, per the anchor CBaseGameStats::Event_Punted [%s]. The anchor establishes the event's identity and that it names one subject; what qualifies as a punt in this build is not established here.", + "source": "generated" + }, + "CCSGameStats::Event_SaveGame": { + "text": "Performs the game-stats bookkeeping for a game being saved. The class CCSGameStats is implied by the name rather than shown by the data, as the entry sits at an unbound vtable slot; whether it writes stats out or merely marks the save is unverified.", + "source": "generated" + }, + "CCSGameStats::Event_Shutdown": { + "text": "Closes down the game-stats session, the teardown counterpart to CCSGameStats::Event_Init. The class CCSGameStats is implied by the name, not established by the data, so whether it persists accumulated stats or just releases state is unverified.", + "source": "generated" + }, + "CCSGameStats::Event_WeaponFired": { + "text": "Records a shot for stats purposes, logging the anchor CBaseGameStats::Event_WeaponFired [%s] %s weapon [%s] with the player, a qualifier and the weapon name. A natural hook for per-weapon shot counting, since the weapon identity is present in the logged text.", + "source": "generated" + }, + "CCSGameStats::Event_WeaponHit": { + "text": "Records a weapon hit for stats purposes, logging the anchor CBaseGameStats::Event_WeaponHit [%s] %s weapon [%s] damage [%f] with the player, the weapon and a damage value. Useful for per-weapon damage accounting; the anchor shows damage is carried, but not how it is accumulated.", + "source": "generated" + }, + "CCSGameStats::IncrementStat": { + "text": "Raises a tracked statistic's value, acting as a general write path for game-stats counters rather than a fixed-purpose event. The class CCSGameStats is implied by the name, since the entry sits at an unbound vtable slot; which statistics are addressable is not established here.", + "source": "generated" + }, + "CCSGameStats::LoadingEvent_PlayerIDDifferentThanLoadedStats": { + "text": "Handles the case where the player ID carried by loaded stats does not match the current player, per the anchor CBaseGameStats::LoadingEvent_PlayerIDDifferentThanLoadedStats. Relevant when stats are restored onto the wrong account; whether it discards or remaps the loaded data is unverified.", + "source": "generated" + }, + "CCSHLTVDirector::OnHLTVUncompressedSnapshot": { + "text": "Handles an uncompressed HLTV snapshot reaching the director, the per-snapshot notification a broadcast director would use to pick shots or record state. The class CCSHLTVDirector is implied by the name, as the entry sits at an unbound vtable slot, so the snapshot's contents are unverified.", + "source": "generated" + }, + "CCSHitboxSystem::TraceShapeAgainstHitboxes": { + "text": "Traces a shape against a set of hitboxes, the fine-grained intersection test behind precise hit detection, with the anchor %s: TraceShapeAgainstHitboxes confirming the name verbatim. Of interest for custom hit registration or hitbox debugging; which shape kinds and which entities it accepts are unverified.", + "source": "generated" + }, + "CCSInventoryManager::OnLoadoutChanged": { + "text": "Reacts to a loadout change, refreshing the inventory manager's view of what a player has equipped; the anchor OnLoadoutChanged appears verbatim. Useful alongside m_unCurrentLoadoutHash when you need to notice equipped-item changes, though what the handler recomputes is unverified.", + "source": "generated" + }, + "CCSNavArea::IncrementPlayerCount": { + "text": "Raises the count of players attributed to a navigation area, with an overflow guard that emits the anchor CCSNavArea::IncrementPlayerCount: Overflow. Relevant when driving bot or spawn logic off nav-area occupancy, since a miscounted area is what the overflow message reports.", + "source": "generated" + }, + "CCSNavArea::PostLoad": { + "text": "Completes navigation-area setup once navigation data has been read, resolving links between areas; unusable input is reported through the anchor beginning CNavArea::PostLoad: Corrupt navigation data. Worth knowing when authoring or patching navigation meshes, since that message flags areas it cannot connect.", + "source": "generated" + }, + "CCSNavArea_IsValidNavMesh": { + "text": "Reports whether the navigation mesh is valid, a usability check on the nav data bots path over. Read from the name; what counts as valid, and whether the check covers a single area or loaded nav data more broadly, is not established.", + "source": "generated" + }, + "CCSObserverPawn::PrePhysicsSimulate": { + "text": "Runs the observer pawn's pre-physics simulation work for a tick, per the name's PrePhysics prefix. The class CCSObserverPawn is implied by the name, since the entry sits at an unbound vtable slot, so what the step updates on a spectating pawn is unverified.", + "source": "generated" + }, + "CCSObserverPawn::SetColor": { + "text": "Sets a colour value on the observer pawn, the kind of render or team tint a spectator entity carries. The class CCSObserverPawn is implied by the name, as the entry sits at an unbound vtable slot, and which colour channel or purpose is meant is unverified.", + "source": "generated" + }, + "CCSObserver_CameraServices::CCSObserver_CameraServices": { + "text": "Constructs the observer camera-services component, bringing an observer's camera state into existence in an initialised form. Being a constructor, no behaviour beyond initialisation is established; hook it when you need to catch observer camera services being created.", + "source": "generated" + }, + "CCSObserver_UseServices::CCSObserver_UseServices": { + "text": "Constructs the observer use-services component that carries an observer's use or interaction state. Being a constructor, nothing beyond initialisation is established; it is a hook point for catching the creation of that component.", + "source": "generated" + }, + "CCSPlayerController::ChangeTeam": { + "text": "Moves the player this controller owns onto a different team, the controller-side path whose pending and post-change state m_iPendingTeamNum and m_bTeamChanged record. The owning class is implied by the name rather than derived, and no prototype is verified, so the team encoding and side effects are unconfirmed.", + "source": "generated" + }, + "CCSPlayerController::LegacyGameEventListener": { + "text": "Supplies the controller's legacy game-event listener object, used for older-style game-event delivery on this player. Read from the name and its GetLegacyGameEventListener alias; no prototype is derived, so what the listener is and how a modder would use it stay unverified.", + "source": "generated" + }, + "CCSPlayerController::OnPreResetRound": { + "text": "Runs the controller's pre-round-reset bookkeeping, emitting a player identity line plus the \"CTMDBG, team %d will switch %d\" trace tied to pending team swaps such as m_bSwitchTeamsOnNextRoundReset. Confidence is low and no prototype is derived, so the anchors show the concern but not the exact behaviour.", + "source": "generated" + }, + "CCSPlayerController::PhysicsSimulate": { + "text": "Simulates the controller's queued user commands for the tick, emitting the \"took %.1fms to execute %d commands, backlog is %d commands\" warning when a player's input backs up. Its CBasePlayerController::OnSimulateUserCommands alias supports that reading; no prototype is derived, so the timing thresholds are unverified.", + "source": "generated" + }, + "CCSPlayerController::PrePhysicsSimulate": { + "text": "Handles the controller's preparation step for the tick's physics and user-command simulation. The owning class is implied by the name, and no prototype is derived, so what it prepares and whether it can veto the simulation are unverified.", + "source": "generated" + }, + "CCSPlayerController::ProcessUserCmd": { + "text": "Consumes user commands arriving from the client, logging the \"Recv usercmd %d. Margin:%5.1fms net +%2d queue =%5.1f total\" line that reports each command's network margin and queue depth. This name ships at the same address as CCSPlayerController::ProcessUserCommands and CCSPlayerController::ProcessUsercmds; no prototype is derived for this entry.", + "source": "generated" + }, + "CCSPlayerController::ProcessUserCommands": { + "text": "Consumes user commands arriving from the client, logging the \"Recv usercmd %d. Margin:%5.1fms net +%2d queue =%5.1f total\" line reporting network margin and queue depth \u2014 the natural place to inspect or rewrite incoming player input. A prototype is derived for this entry, which ships at the same address as CCSPlayerController::ProcessUserCmd and CCSPlayerController::ProcessUsercmds.", + "source": "generated" + }, + "CCSPlayerController::ProcessUsercmds": { + "text": "Consumes user commands arriving from the client, logging the \"Recv usercmd %d. Margin:%5.1fms net +%2d queue =%5.1f total\" line that reports network margin and queue depth. This spelling ships at the same address as CCSPlayerController::ProcessUserCmd and CCSPlayerController::ProcessUserCommands; no prototype is derived for this entry.", + "source": "generated" + }, + "CCSPlayerController::Respawn": { + "text": "Puts the controller's player back into play with a live pawn, refreshing controller-side mirrors such as m_bPawnIsAlive and m_iPawnHealth. The class is implied by the name, and this entry resolves to the same unbound vtable slot as CCSPlayerController::RoundRespawn, so the two are not separately verified.", + "source": "generated" + }, + "CCSPlayerController::RoundRespawn": { + "text": "Respawns the controller's player for a round restart, restoring the pawn and the m_bPawnIsAlive and m_iPawnHealth mirrors the controller exposes. The class is implied by the name, and this entry resolves to the same unbound vtable slot as CCSPlayerController::Respawn, so the two are not separately verified.", + "source": "generated" + }, + "CCSPlayerController::SetPlayerName": { + "text": "Sets the name this controller carries for its player, the string other clients see in scoreboard and chat. Read from the name; no prototype is derived, so whether it sanitises input, renames an existing pawn, or replicates immediately is unverified.", + "source": "generated" + }, + "CCSPlayerController::SwitchTeam": { + "text": "Switches this controller's player to another team, the operation whose in-progress state m_bInSwitchTeam tracks alongside m_iPendingTeamNum. Read from the name and those fields; no prototype is derived, so which team encoding it expects and whether the move is immediate are unverified.", + "source": "generated" + }, + "CCSPlayerController::UpdateTeamSelectionPreview": { + "text": "Refreshes the team-selection preview a player sees while picking a side, anchored to the string \"team_select_counterterrorist\" for the CT option. Also shipped as CCSPlayerController_UpdateSelectTeamPreview; no prototype is derived, so what the preview covers and when it refreshes are unverified.", + "source": "generated" + }, + "CCSPlayerController_InventoryServices::GetItemInLoadoutFilteredByProhibition": { + "text": "Looks up the item equipped in a loadout slot while excluding items that are prohibited, a filtered form of the lookup CCSPlayerInventory::GetItemInLoadout performs. Read from the name; useful with m_unCurrentLoadoutHash and m_vecServerAuthoritativeWeaponSlots when checking what a controller is actually allowed to receive.", + "source": "generated" + }, + "CCSPlayerController_UpdateSelectTeamPreview": { + "text": "Refreshes the team-selection preview shown for a player controller, with the string anchor team_select_counterterrorist tying it to the named team-select presentation entries. Read alongside the CCSPlayerController::UpdateTeamSelectionPreview alias; no prototype is derived, so what prompts the refresh and what it puts on screen are unverified.", + "source": "generated" + }, + "CCSPlayerInventory::GetItemInLoadout": { + "text": "Looks up the item occupying a given loadout slot in a player's inventory. The class CCSPlayerInventory is implied by the name, since the entry sits at an unbound vtable slot; CCSPlayerController_InventoryServices::GetItemInLoadoutFilteredByProhibition names the variant that additionally drops prohibited items.", + "source": "generated" + }, + "CCSPlayerInventory::SOUpdated": { + "text": "Handles an update to a cached inventory shared object, refreshing the player's inventory when the backing economy data changes. The class CCSPlayerInventory is implied by the name, as the entry sits at an unbound vtable slot, so which object types it accepts is unverified.", + "source": "generated" + }, + "CCSPlayerInventory::SendInventoryUpdateEvent": { + "text": "Emits an inventory-update event announcing that a player's inventory changed, so listeners can re-read equipped items. It is also shipped under the name CPlayerInventory::SendInventoryUpdateEvent, which is the same function, so a hook placed on either address catches both.", + "source": "generated" + }, + "CCSPlayerPawn::CanMove": { + "text": "Reports whether this player pawn is currently permitted to move, the gate to consult when freezing players or working out why movement input is being ignored; m_iPlayerLocked holds related lock state. Read from the name, so the exact conditions it tests are unverified.", + "source": "generated" + }, + "CCSPlayerPawn::GetPlayerMaxSpeed": { + "text": "Reports the pawn's current maximum movement speed, the natural place to hook for speed buffs, slowdowns, or diagnosing why a player caps out where they do. Its prototype is derived and the name is unambiguous; the same function also ships as CCSPlayerPawn_GetMaxSpeed.", + "source": "generated" + }, + "CCSPlayerPawn::IsAbleToApplySpray": { + "text": "Decides whether the pawn may apply a spray decal right now, rejecting unsuitable surface angles with the #SFUI_Notice_SprayPaint_GrazingAngle notice. Pair it with m_flNextSprayDecalTime and m_bNextSprayDecalTimeExpedited when changing spray cooldowns; the anchor confirms the spray role, though the individual checks are unverified.", + "source": "generated" + }, + "CCSPlayerPawn::OnRescueZoneTouch": { + "text": "Handles this pawn touching a hostage rescue zone, the hook to use when customising rescue-zone behaviour; m_bInHostageRescueZone and m_bWasInHostageRescueZone carry the matching state. Read from the name, with no prototype derived, so its effects on touch are unverified.", + "source": "generated" + }, + "CCSPlayerPawn::OnTakeDamage": { + "text": "Handles a damage event delivered to this player pawn, the point at which mods scale, redirect, or cancel incoming damage; m_flTimeOfLastInjury tracks the resulting timestamp. Read from the name, so the exact damage inputs it consults are unverified.", + "source": "generated" + }, + "CCSPlayerPawn::OnTakeDamage_Alive": { + "text": "Handles damage taken while the pawn is alive, the alive-only damage path to touch for armour, falloff, or survivability rules. It occupies an unbound vtable slot, so the CCSPlayerPawn class is implied by the name rather than established by the data, and no prototype is derived.", + "source": "generated" + }, + "CCSPlayerPawn::PostThink": { + "text": "Performs the pawn's recurring post-think update work, which includes hostage-rescue-zone bookkeeping: the enter_rescue_zone anchor sits in this function. Its prototype is derived; hook it when per-update pawn state such as m_bInHostageRescueZone or m_bOnGroundLastTick needs to stay current.", + "source": "generated" + }, + "CCSPlayerPawn::Respawn": { + "text": "Respawns this player pawn back into play, the call to reach for in custom respawn or deathmatch logic, with m_bResetArmorNextSpawn governing armour on the coming spawn. It occupies an unbound vtable slot, so the class is implied by the name and no prototype is derived.", + "source": "generated" + }, + "CCSPlayerPawn::SetModelFromClass": { + "text": "Sets the pawn's player model from its character class, the path to override when forcing which model a team or agent uses; m_nCharacterDefIndex holds the related character definition. Read from the name, so where the model is sourced from is unverified.", + "source": "generated" + }, + "CCSPlayerPawn::SetModelFromLoadout": { + "text": "Sets the pawn's player model from its loadout selection, the place to intervene when applying custom agents or per-team model overrides; m_nCharacterDefIndex and m_EconGloves hold the associated loadout state. It also ships as CCSPlayerPawn::UpdateModelFromLoadout, the same function; read from the name.", + "source": "generated" + }, + "CCSPlayerPawn::UpdateModelFromLoadout": { + "text": "Applies the pawn's loadout selection to its player model, refreshing the visible agent after a loadout or team change; m_nCharacterDefIndex and m_EconGloves carry the associated state. It also ships as CCSPlayerPawn::SetModelFromLoadout, the same function; read from the name, with no prototype derived.", + "source": "generated" + }, + "CCSPlayerPawnBase::IncrementNumMVPs": { + "text": "Raises a player pawn's MVP count and supports replacing the MVP reason, logging the anchor CCSPlayerPawnBase: MVP override ( %s -> %s ) when one reason supersedes another. A natural entry point for awarding custom MVPs or changing why an MVP was granted.", + "source": "generated" + }, + "CCSPlayerPawnBase::IsPlayer": { + "text": "Reports whether the entity is a player pawn, a type predicate for telling player pawns apart from other entities. The class CCSPlayerPawnBase is implied by the name, since the entry sits at an unbound vtable slot, and the conditions it treats as player-like are unverified.", + "source": "generated" + }, + "CCSPlayerPawn_GetMaxSpeed": { + "text": "Gives a player pawn's current maximum movement speed, the value to hook or override when making players faster or slower. The prototype is verified, and it also ships as CCSPlayerPawn::GetPlayerMaxSpeed.", + "source": "generated" + }, + "CCSPlayerWeaponTimingGraph::RunTick": { + "text": "Advances the weapon timing graph by one tick, updating whatever per-tick weapon timing state the class maintains; the generic anchor RunTick appears verbatim. Read mainly from the name, so what the graph's nodes represent and which weapons feed it are unverified.", + "source": "generated" + }, + "CCSPlayer_BuyServices::BuyPreset": { + "text": "Executes a buy-preset purchase for a player, acquiring the items recorded in a saved buy preset in one action. Read from the name, with no anchor to confirm it; m_vecSellbackPurchaseEntries on the same class is what a refund path would consult after such a purchase.", + "source": "generated" + }, + "CCSPlayer_FindMatchingWeaponsForTeamLoadout": { + "text": "Looks up the weapons in a player's loadout that match a given team, the query behind handing out team-appropriate equipment. Read from the name and the CBasePlayerPawn::FindMatchingWeaponsForTeamLoadout alias; no prototype is derived, so the matching criteria and loadout source are unverified.", + "source": "generated" + }, + "CCSPlayer_ItemServices::AddToRebuy": { + "text": "Records a purchased item on the player's rebuy list, keyed by loadout slot \u2014 the string `Unhandled loadout slot (%i) in AddToRebuy` shows slots it does not recognise are reported rather than stored. Hook it to control what a rebuy re-purchases; the item form it stores is unverified.", + "source": "generated" + }, + "CCSPlayer_ItemServices::CanAcquire": { + "text": "Decides whether the player is permitted to take a given item, the gate behind buy-menu purchases and world pickups. Hook it to allow or deny particular weapons per player; CEconItemView is among the classes this batch's parameters reference, though the refusal cases it distinguishes are unverified.", + "source": "generated" + }, + "CCSPlayer_ItemServices::GiveGlove": { + "text": "Applies a glove wearable to the player. The data groups this name with CCSPlayer_ItemServices::SetWearables and CCSPlayer_ItemServices::UpdateWearables as one shipped function, so the glove path and the general wearable path are the same code; the item plumbing behind it is unverified.", + "source": "generated" + }, + "CCSPlayer_ItemServices::RemoveAllItems": { + "text": "Strips what the player is carrying, clearing weapons and equipment in a single call. The CCSPlayer_ItemServices class here is implied by the name rather than established by the data \u2014 the entry sits on an unbound vtable slot \u2014 so the owner and the exact breadth of the strip are unverified.", + "source": "generated" + }, + "CCSPlayer_ItemServices::RemoveWeapons": { + "text": "Removes the player's carried weapons, a narrower strip than clearing the whole inventory. The class is implied by the name, not established by the data \u2014 this entry is an unbound vtable slot \u2014 so its owner and whether equipment state such as m_bHasDefuser survives are unverified.", + "source": "generated" + }, + "CCSPlayer_ItemServices::SetWearables": { + "text": "Sets the player's wearable items. It is the same shipped function as CCSPlayer_ItemServices::GiveGlove and CCSPlayer_ItemServices::UpdateWearables, so gloves and other wearables go through one body of code; read from the names, and what it rebuilds on the player is unverified.", + "source": "generated" + }, + "CCSPlayer_ItemServices::UpdateWearables": { + "text": "Refreshes the player's wearables after a loadout or model change, sharing one body of code with CCSPlayer_ItemServices::GiveGlove and CCSPlayer_ItemServices::SetWearables. Read from the name and that alias grouping, so what prompts a refresh and which wearables it rebuilds are unverified.", + "source": "generated" + }, + "CCSPlayer_ItemServices_DropActivePlayerWeapon": { + "text": "Drops the weapon a player currently has deployed, the server-side path behind forcing someone to lose their active weapon. It sits at an unbound vtable slot, so the owning item-services class is implied by the name rather than shown by the data, and the drop's exact behaviour is unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::AddGravity": { + "text": "Applies gravity to the player's velocity during a move step; the name also appears verbatim as a string in the binary, and it is the counterpart of CCSPlayer_MovementServices::StartGravity. Hook it to change how fast a player falls; the amount applied and the conditions guarding it are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::AirAccelerate": { + "text": "Accelerates the player while airborne, the air-control path that governs strafe-jump and surf speed gain; also shipped under the bare name AirAccelerate. Read from the name, so the wish-speed cap it enforces and its interaction with CCSPlayer_MovementServices::GroundAccelerate are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::AirMove": { + "text": "Performs the airborne movement step, turning input into motion while the player is off the ground; the anchor PreSource1AirMove marks a legacy Source-1-style air path inside it. Also shipped as AirMove; which path a given build takes, and the condition selecting it, are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::CanUnduck": { + "text": "Tests whether the player has clearance to stand up out of a crouch, the check that gates leaving the ducked state tracked by m_bDucked and m_bDucking. Also shipped as CanUnduck; read from the name, so the hull and trace it uses are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::CategorizePosition": { + "text": "Classifies the player's relationship to the world for the move \u2014 on ground, airborne or in water \u2014 and updates the resulting ground state. Also shipped as CategorizePosition; read from the name, so the surface tolerances it applies and the fields it writes are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::CheckFalling": { + "text": "Handles landing after a fall, covering fall damage and the landing sound \u2014 the anchor Land_WaterVol.StepLeft is one of the surface-specific sounds it can pick. Also shipped as CheckFalling; the damage curve and the speed thresholds it uses are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::CheckJumpButtonLegacy": { + "text": "Evaluates the jump button under the legacy jump model and starts the jump when allowed, working with m_flStamina and the m_LegacyJump state. Also shipped as CheckJumpButton and CheckJumpButtonLegacy; read from the name, so the eligibility rules and launch velocity are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::CheckJumpButtonModern": { + "text": "Evaluates the jump button under the modern jump model and starts the jump when allowed, alongside the m_ModernJump state. Read from the name and its counterpart CCSPlayer_MovementServices::CheckJumpButtonLegacy; which model a server actually uses, and the launch rules, are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::CheckParameters": { + "text": "Validates and clamps the movement inputs for a command \u2014 view angles and the forward, side and up move values \u2014 before they drive the move. Hook it to cap or rewrite client movement input server-side; read from the name, so the specific clamps are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::CheckVelocity": { + "text": "Clamps the player's velocity against the allowed maximum, logging `Got a velocity too high (>%.2f)` with the player and context when a component exceeds it. Also shipped as CheckVelocity; useful when chasing speed-hack reports or physics blow-ups, though the source of the limit is unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::Duck": { + "text": "Drives the crouch state for the move step: duck progress, the crouched view offset and the crouch speed penalty. Read from the name together with m_bDucked, m_flDuckAmount, m_flDuckSpeed and m_flDuckViewOffset; hook it for custom crouch timing, though which of those fields it writes is unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::Friction": { + "text": "Applies friction to the player's velocity, scaling speed down when they are not actively accelerating. Also shipped as Friction, with m_bUseFrictionStashedSpeed and m_flFrictionStashedSpeed holding the stashed-speed behaviour on the class; the friction constants it reads are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::FullWalkMove": { + "text": "Carries out the full walking-movement step for a tick, covering ground and air handling, water transitions and the resulting position change. Also shipped as FullWalkMove; read from the name, so the internal branches and the conditions selecting them are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::GroundAccelerate": { + "text": "Accelerates the player along the ground toward the wish velocity; its debug string prints flAccelSpeed, flGoalSpeed and flStoredAccel, naming the accel speed, goal speed and stored acceleration it works with. Counterpart to CCSPlayer_MovementServices::AirAccelerate for ground speed tuning; the caps applied are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::LadderMove": { + "text": "Moves the player while on a ladder, turning input into motion along the ladder surface. The contact state lives in m_vecLadderNormal and m_nLadderSurfacePropIndex; read from the name, so the mount, dismount and climb-speed rules are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::MoveInit": { + "text": "Initialises the per-move working state for a movement tick \u2014 the basis vectors m_vecForward, m_vecLeft and m_vecUp are the kind of field such setup fills. Also shipped as MoveInit; read from the name, so what it actually resets is unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::OnJump": { + "text": "Performs the per-tick movement processing step and carries the PlayerMovementTraces anchor; the data groups this name with CCSPlayer_MovementServices::ProcessMove and ProcessMovement as a single shipped function, so despite the name it is not a jump-only body. For jump-specific behaviour use CCSPlayer_MovementServices::OnJumpModern or CCSPlayer_MovementServices::OnJumpLegacy.", + "source": "generated" + }, + "CCSPlayer_MovementServices::OnJumpLegacy": { + "text": "Handles a jump under the legacy model, with the anchor player_jump naming the game event of that name, and updates jump bookkeeping such as m_flHeightAtJumpStart and m_flStaminaAtJumpStart. Also shipped as OnJumpLegacy; which fields it writes and the stamina cost applied are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::OnJumpModern": { + "text": "Handles a jump under the modern model, updating jump tracking such as m_ModernJump, m_flMaxJumpHeightThisJump and m_nLastJumpTick. Read from the name and its counterpart CCSPlayer_MovementServices::OnJumpLegacy; the model selection and the exact bookkeeping it performs are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::PlayerMove": { + "text": "Moves the player for the current command, with the string `Can't move` marking a state in which motion is refused. Also shipped as PlayerMove; read from the name, so the movement modes it covers and the condition behind that refusal are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::PreWalkMove": { + "text": "Does the preparation associated with the walking move \u2014 its own name appears verbatim as a string in the binary, the kind of label used for tracing or profiling. Read from the name alone, so what it prepares is unverified; the related walk step is CCSPlayer_MovementServices::FullWalkMove.", + "source": "generated" + }, + "CCSPlayer_MovementServices::ProcessMove": { + "text": "Updates the player's position and velocity for the tick \u2014 the top-level movement step, carrying the PlayerMovementTraces anchor and the trace bookkeeping in m_nTraceCount. Also shipped as ProcessMovement and grouped with CCSPlayer_MovementServices::OnJump as one function; this is the usual hook point for wholesale movement changes.", + "source": "generated" + }, + "CCSPlayer_MovementServices::ProcessUserCmd": { + "text": "Applies one user command from the client \u2014 buttons, view angles and move values \u2014 as a movement tick for the player. Also shipped as RunCommand; read from the name, so the validation it performs and its treatment of dropped or duplicated commands are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::RunCommand": { + "text": "Executes user commands for the player, turning client input into movement for the tick; also shipped as CPlayer_MovementServices::RunCmds and CPlayer_MovementServices::RunCommand. m_bHasEverProcessedCommand and m_nGameCodeHasMovedPlayerAfterCommand hold related command state; read from the name, so the per-command checks are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::SetupMove": { + "text": "Assembles the movement state for a tick out of the incoming command, filling the working values the move step uses. Hook it to rewrite or sanitise input as that state is built; read from the name, so exactly which fields it populates is unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::StartGravity": { + "text": "Applies the opening gravity contribution to the player's velocity for a move; the name appears verbatim as a string in the binary and pairs with CCSPlayer_MovementServices::AddGravity as a split gravity application. Read from the names, so the split and the amounts applied are unverified.", + "source": "generated" + }, + "CCSPlayer_MovementServices::WaterMove": { + "text": "Moves the player while in water, applying swim handling instead of ground movement. Water state sits in m_nOldWaterLevel and m_flWaterEntryTime; also shipped as WaterMove, and the buoyancy, sink and surface behaviour it implements are unverified.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::BumpWeapon": { + "text": "Handles the player bumping into a weapon lying in the world, picking it up or absorbing its ammo; m_bIsPickingUpGroundWeapon and m_bPickedUpWeapon track that state. The class is implied by the name, and the behaviour is read from the name, so the exact pickup conditions are unverified.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::CanEquip": { + "text": "Tests whether the player is allowed to equip a given CBasePlayerWeapon, making it the gate to consult before granting or forcing an item. Read from the name; a prototype is derived, but the conditions that cause a refusal are not established.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::CanSwitch": { + "text": "Tests whether the player may switch to a given CBasePlayerWeapon at this moment, useful before forcing a weapon change. Read from the name; m_bDisableAutoDeploy and m_flNextAttack are the fields a modder would inspect alongside it, though their influence on the answer is unverified.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::CanUse": { + "text": "Tests whether the player is permitted to use a particular weapon, a check distinct from the equip and switch permissions. The class is implied by the name, and the reading comes from the name alone, so what qualifies as use here is unverified.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::Destroy": { + "text": "Removes a weapon from the player and destroys it; the same code also ships as CBasePlayerPawn_RemovePlayerItem, which describes the behaviour more plainly. Use this to strip an item outright rather than releasing it into the world.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::DetachWeapon": { + "text": "Detaches a weapon from the player, severing ownership without destroying the item itself. Read from the name; a prototype is derived, but whether the weapon is left in the world or merely unlinked is not established.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::DropWeapon": { + "text": "Drops a weapon from the player into the world, refusing during warmup with the notice #SFUI_Notice_CannotDropWeaponDuringWarmup. The class is implied by the name; the warmup restriction comes from that string anchor, while other drop conditions are unverified.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::EquipWeapon": { + "text": "Adds a weapon to the player and attaches it to the pawn; the same code also ships as CCSPlayer_WeaponServices::Weapon_Equip. This is the give-item path to use after creating a CBasePlayerWeapon, though the ownership side effects are unverified.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::FinishTick": { + "text": "Performs end-of-tick weapon bookkeeping for the player, the plausible home for per-tick timers such as m_flNextAttack and m_nTimeToPrimary. Read from the name, which also appears verbatim as a string anchor; what it actually settles each tick is not established.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::GetInterpolatedShootPosition": { + "text": "Computes the player's shoot origin interpolated to a moment in time; its log string, %s: GetInterpolatedShootPosition time [ #%d + %.3f ], shows that time as a tick number plus a fractional offset. Relevant when reconstructing where a shot originated under sub-tick timing.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::GetWeaponBySlot": { + "text": "Looks up the weapon the player holds in a given inventory slot, the convenient way to reach a pawn's primary, secondary or melee item. Read from the name; a prototype is derived, but the slot numbering it expects is not established.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::SelectItem": { + "text": "Selects an item from the player's inventory and makes it the active held item. The class is implied by the name, and it occupies the same vtable slot 31 as CCSPlayer_WeaponServices::SelectWeapon, so both names may resolve to one function.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::SelectWeapon": { + "text": "Selects a weapon from the player's inventory and makes it the active one. The class is implied by the name, and it occupies the same vtable slot 31 as CCSPlayer_WeaponServices::SelectItem, so both names may resolve to one function.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::SwitchWeapon": { + "text": "Switches the player's active weapon to a specified one, the acting counterpart to the switch-permission check. The class is implied by the name; m_hSavedWeapon and m_bDisableAutoDeploy are the fields worth inspecting alongside it, though that link is unverified.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::Weapon_Equip": { + "text": "Attaches a weapon to the player's inventory; this is an alternate shipped name for the same code as CCSPlayer_WeaponServices::EquipWeapon. Hook just one of the two names, since both reach identical behaviour.", + "source": "generated" + }, + "CCSPlayer_WeaponServices::Weapon_Switch": { + "text": "Switches the player to a given CBasePlayerWeapon, deploying it as the held item. Read from the name; it ships separately from CCSPlayer_WeaponServices::SwitchWeapon in this data, and what distinguishes the two is not established.", + "source": "generated" + }, + "CCSPointScriptEntity::FindEntitiesByClass": { + "text": "Finds entities matching a class name, exposing an entity lookup to scripts running on a point-script entity. The class is implied by the name, and the reading comes from the name, so the match semantics and how results are handed back are unverified.", + "source": "generated" + }, + "CCSPointScriptEntity::OnScriptReload": { + "text": "Handles the entity's script being reloaded, giving the script a chance to re-establish state after a live edit. The class is implied by the name, and the reading comes from the name alone, so what survives a reload is unverified.", + "source": "generated" + }, + "CCSPointScriptEntity::Think": { + "text": "Runs the entity's periodic think work, the hook where a point-script entity performs time-based updates. The class is implied by the name; the think interval and what it updates are not established.", + "source": "generated" + }, + "CCSScript::OnActivate": { + "text": "Activates a script; the same code also ships as CCSServer::PointScriptEntityEnterScope, indicating that activation happens when a point-script entity enters scope. That alias makes this the place to observe a script becoming live for an entity.", + "source": "generated" + }, + "CCSScriptOnActivate": { + "text": "Activates a map's point-script entity so its scripted logic becomes live. Also shipped as CCSScript::OnActivate and CCSServer::PointScriptEntityEnterScope; the attribution is medium confidence, so verify before relying on it to observe map script startup.", + "source": "generated" + }, + "CCSScript_EntityScript::FindWeaponBySlot": { + "text": "Looks up a weapon in an inventory by slot index, so script code can reach the weapon entity occupying a given slot. Read from the name, whose class qualifier is implied by the name; no prototype is derived, so the slot numbering and whose inventory is searched remain unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnBeforePlayerDamage": { + "text": "Script hook for player damage at a point before it is applied, giving map scripts a chance to inspect or suppress the hit. Read from the name, with the class qualifier implied by the name; the damage detail exposed and whether the script can veto are unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnBeginRoundRestart": { + "text": "Script hook for the beginning of a round restart, the natural place to reset per-round scripted state such as counters, spawned props, or custom rules. Read from the name, whose class qualifier is implied by the name; the exact point within the restart is unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnBulletImpact": { + "text": "Script hook for a bullet impact, usable for surface-reactive map logic, custom effects, or hit logging. Read from the name, with the class qualifier implied by the name; which impact details (position, surface, shooter) the script receives is unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnGrenadeThrow": { + "text": "Script hook for a grenade being thrown, useful for tracking utility usage or reacting to incoming projectiles in scripted maps. Read from the name, whose class qualifier is implied by the name; the grenade and thrower detail available to the script is unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnGunFire": { + "text": "Script hook for a weapon being fired, useful for shot counting, firing-driven map events, or custom weapon rules. Read from the name, with the class qualifier implied by the name; the shooter and weapon detail exposed to the script is unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnGunReload": { + "text": "Script hook for a weapon reload, letting scripts drive behaviour off reloads or do ammo bookkeeping. Read from the name, whose class qualifier is implied by the name; whether it covers reload start, completion, or both is unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnModifyPlayerDamage": { + "text": "Script hook for altering player damage rather than merely observing it, the modifying counterpart to CCSScript_EntityScript::OnPlayerDamage. Read from the name, with the class qualifier implied by the name; how a script returns a changed amount, and what it may change, are unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnPlayerDamage": { + "text": "Script hook for damage dealt to a player, suited to observation work such as scoring, logging, or triggering scripted responses. Read from the name, whose class qualifier is implied by the name; the victim, attacker, and amount detail exposed is unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnPlayerJump": { + "text": "Script hook for a player jumping, usable for jump-driven map logic such as parkour rules, triggers, or movement stats. Read from the name, with the class qualifier implied by the name; the player detail supplied to the script is unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnPlayerKill": { + "text": "Script hook for a player kill, the place for custom scoring, killstreak logic, or death-driven map events. Read from the name, whose class qualifier is implied by the name; the killer, victim, and weapon detail exposed is unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnPlayerLand": { + "text": "Script hook for a player landing after a fall or jump, useful for fall-damage rules, landing effects, or surface-specific map logic. Read from the name, with the class qualifier implied by the name; the landing detail supplied to the script is unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnPlayerPing": { + "text": "Script hook for a player placing a ping marker, letting scripts react to pinged locations for objectives, callouts, or custom markers. Read from the name, whose class qualifier is implied by the name; the ping position and target detail exposed are unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnPlayerReset": { + "text": "Script hook for a player being reset, the point at which per-player scripted state should be cleared or reapplied. Read from the name, with the class qualifier implied by the name; what a reset covers here, and how it differs from a round restart, are unverified.", + "source": "generated" + }, + "CCSScript_EntityScript::OnWeaponDrop": { + "text": "Script hook for a weapon being dropped, usable for tracking loose weapons, custom pickup rules, or economy logic. Read from the name, whose class qualifier is implied by the name; the weapon and previous-owner detail exposed to the script is unverified.", + "source": "generated" + }, + "CCSServer::PointScriptEntityEnterScope": { + "text": "Handles a point-script entity entering scope, and the same code ships as CCSScript::OnActivate, so it reads as the script entity's activation entry point where script state is brought up. Both names are recorded aliases in this data; no prototype is derived, so what scope means here is unverified.", + "source": "generated" + }, + "CCSServerPointScriptEntityEnterScope": { + "text": "Brings a point-script entity into scope on the server, activating the script it carries. This names the same code as CCSScript::OnActivate at medium confidence, and is the place to watch or gate map-authored scripting.", + "source": "generated" + }, + "CCSWeaponBase::GetEconWpnData": { + "text": "The string anchor GetEconWpnData marks this as the accessor for a weapon's economy item data, the item-definition record (skin, stickers, item attributes) behind the weapon as distinct from its live gameplay state. Standing is anchor-and-name level; no prototype is derived, so the lookup key and the data it yields are unverified.", + "source": "generated" + }, + "CCSWeaponBase::ToggleCanBePickedUp": { + "text": "The string anchor ToggleCanBePickedUp marks this as the switch controlling whether the weapon may be picked up, matching CCSWeaponBase's m_bCanBePickedUp field, which is useful for pinning weapons in place or blocking scavenging. No prototype is derived, so whether it flips the flag or sets an explicit value is unverified.", + "source": "generated" + }, + "CCallbackImpl<16>::GetCallbackSizeBytes": { + "text": "Reports the size in bytes of the callback payload for the CCallbackImpl<16> template instantiation, the figure the callback machinery needs to size a dispatch buffer. Read from the name and the template argument; no prototype is derived, so whether 16 is that byte size or another parameter is unverified.", + "source": "generated" + }, + "CCallbackImpl<1>::GetCallbackSizeBytes": { + "text": "Reports the size in bytes of the callback payload for the CCallbackImpl<1> template instantiation, so callback handling code knows how much data one dispatch carries. Read from the name and the template argument; no prototype is derived, so what the template parameter counts is unverified.", + "source": "generated" + }, + "CCallbackImpl<4>::GetCallbackSizeBytes": { + "text": "Reports the size in bytes of the callback payload for the CCallbackImpl<4> template instantiation, the per-instantiation size used when handling that callback's data. Read from the name and the template argument; no prototype is derived, so what the template parameter counts is unverified.", + "source": "generated" + }, + "CCallbackImpl<4>::Run": { + "text": "Executes the callback body for the CCallbackImpl<4> instantiation, the entry point that does the callback's actual work on its payload. Read from the name; no prototype is derived, so what data it acts on and what it performs are unverified.", + "source": "generated" + }, + "CCallbackImpl<8>::GetCallbackSizeBytes": { + "text": "Reports the size in bytes of the callback payload for the CCallbackImpl<8> template instantiation, letting callback handling code size that instantiation's data. Read from the name and the template argument; no prototype is derived, so what the template parameter counts is unverified.", + "source": "generated" + }, + "CChangeLevel::FindLandmark": { + "text": "Resolves the landmark entity that anchors a level transition, aligning positions between the outgoing and incoming maps, and pairs with CChangeLevel's m_sLandmarkName field. Read from the name and that field; no prototype is derived, so the search scope and the behaviour on a missing landmark are unverified.", + "source": "generated" + }, + "CChangeLevel::GetDataDescMap": { + "text": "Retrieves the data description map for the changelevel entity, the table describing its saved and mappable fields such as m_sMapName and m_sLandmarkName. Read from the name, whose class qualifier is implied by the name; the map's contents for this class are not established by this data.", + "source": "generated" + }, + "CChangeLevel::InTransitionVolume": { + "text": "Tests whether something lies inside the transition volume tied to this level change, the check that decides what carries across a map transition. Read from the name; no prototype is derived, so how the volume is defined and what is tested against it are unverified.", + "source": "generated" + }, + "CChangeLevel::InputChangeLevel": { + "text": "Handles the `ChangeLevel` entity-IO input on `CChangeLevel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CChangeLevelIssue::CanCallVote": { + "text": "Decides whether a map-change vote may be started, gating the changelevel vote issue against current conditions. Read from the name, whose class qualifier is implied by the name; the conditions it checks and any failure reason it reports back are unverified.", + "source": "generated" + }, + "CChicken::AnimThink": { + "text": "Periodic animation update for the chicken, advancing its activity state; CChicken carries m_desiredActivity, m_currentActivity, and m_activityTimer, which such an update would drive. Read from the name and those fields, with the class qualifier implied by the name; the update interval is unverified.", + "source": "generated" + }, + "CChicken::FireGameEvent": { + "text": "Receives a game event on behalf of the chicken, letting it respond to broadcast events such as round or player events. Read from the name, whose class qualifier is implied by the name; which events it subscribes to and how it reacts are unverified.", + "source": "generated" + }, + "CChicken::Fly": { + "text": "The string anchor Chicken.Fly marks this as the chicken's flying or flapping behaviour, the airborne motion that CChicken's m_isOnGround and m_vFallVelocity fields track. Standing is anchor-and-name level; no prototype is derived, so the conditions that put the chicken into flight are unverified.", + "source": "generated" + }, + "CChicken::OnBreak": { + "text": "Handles the chicken being broken or destroyed, the entity's response to its own destruction such as gibs, sounds, and cleanup. Read from the name, whose class qualifier is implied by the name; what it actually spawns or clears is unverified.", + "source": "generated" + }, + "CChicken::Panic": { + "text": "The string anchor Chicken.Panic marks this as the chicken's panic behaviour, the startled flee state matching CChicken's m_fleeFrom and m_startleTimer fields. Standing is anchor-and-name level; no prototype is derived, so what provokes panic and how long it lasts are unverified.", + "source": "generated" + }, + "CChoreoEvent_EXTERNAL_ANIMGRAPH::SetExternalAnimgraphResource": { + "text": "The string anchor SetExternalAnimgraphResource marks this as the setter that points an external-animgraph choreo event at the animgraph asset it should use. Standing is anchor-and-name level; no prototype is derived, so the form of the resource reference and any validation it applies are unverified.", + "source": "generated" + }, + "CClientFrame::IsMemPoolAllocated": { + "text": "Reports whether this client frame was handed out from a memory pool rather than allocated normally, which is what tells the owner how to give it back. The class CClientFrame is implied by the name; the reading is name-level and the pooling policy behind the answer is unverified.", + "source": "generated" + }, + "CClientFrame::~CClientFrame": { + "text": "Destroys a client frame and releases the per-frame state it holds. The class is implied by the name; as a destructor its purpose is structural, and what it actually frees is unverified.", + "source": "generated" + }, + "CClientFrameManager::~CClientFrameManager": { + "text": "Destroys the client-frame manager and tears down the frame bookkeeping it owns. The class CClientFrameManager is implied by the name; nothing here establishes which frames or buffers are released.", + "source": "generated" + }, + "CCoJobMgr::BResumeYieldingJobs": { + "text": "Resumes co-jobs that have yielded, letting suspended work under the engine's cooperative job manager continue. The string CCoJobMgr::BResumeYieldingJobs appears verbatim in libserver; the conditions for resumption and the scheduling behaviour are unverified.", + "source": "generated" + }, + "CCodeResourceManifestManager::GetNamedManifestResources": { + "text": "Retrieves the resources listed under a named code resource manifest, giving callers the contents of a manifest by its name. The class is implied by the name; the manifest naming scheme and the form of the result are unverified.", + "source": "generated" + }, + "CCodeResourceManifestManager::IsResourceManifestGroupKnown": { + "text": "Tests whether a resource-manifest group is registered with the manifest manager, so a caller can check availability before asking for its contents. The class is implied by the name; the identifier form used for a group is unverified.", + "source": "generated" + }, + "CCollisionProperty::SetSolid": { + "text": "Sets the solid type on an entity's collision property, changing how the entity collides; it corresponds to m_nSolidType and works alongside m_usSolidFlags and m_CollisionGroup. Useful for making an entity solid or non-solid at runtime, though any recomputation of m_vecSurroundingMins and m_vecSurroundingMaxs is unverified.", + "source": "generated" + }, + "CColorCorrection::GetDataDescMap": { + "text": "Exposes the entity's datadesc map, the description used for save/restore and keyvalue handling of CColorCorrection fields such as m_flFadeInDuration and m_flMaxWeight. The class is implied by the name; the map's contents are not established by this data.", + "source": "generated" + }, + "CColorCorrection::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CColorCorrection`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CColorCorrection::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CColorCorrection`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CColorCorrection::InputSetFadeInDuration": { + "text": "Handles the `SetFadeInDuration` entity-IO input on `CColorCorrection`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CColorCorrection::InputSetFadeOutDuration": { + "text": "Handles the `SetFadeOutDuration` entity-IO input on `CColorCorrection`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CColorCorrectionSystem::FireGameEvent": { + "text": "Handles a game event delivered to the color-correction system, letting it react to engine events it has subscribed to. The class is implied by the name; which events it listens for and how it responds are unverified.", + "source": "generated" + }, + "CColorCorrectionVolume::ColorCorrectionVolumeThink": { + "text": "Runs the periodic update for a color-correction volume, moving m_Weight toward m_MaxWeight over m_FadeDuration using the m_LastEnterTime, m_LastEnterWeight, m_LastExitTime and m_LastExitWeight marks. Read from the name and those fade fields; the think cadence and the exact blend are unverified.", + "source": "generated" + }, + "CCommand::Tokenize": { + "text": "Splits a raw console command string into the argument tokens the CCommand object then exposes, which is how server command text becomes individual arguments. Read from the name; the quoting, escaping and length rules it applies are unverified.", + "source": "generated" + }, + "CCommentaryAuto::InputMultiplayerSpawned": { + "text": "Handles the `MultiplayerSpawned` entity-IO input on `CCommentaryAuto`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCommentarySystem::InitCommentary": { + "text": "Initializes the commentary system for the loaded map, preparing the node bookkeeping behind m_vecNodes, m_hCurrentNode and m_hActiveCommentaryNode. The class is implied by the name; what it loads and which convars in m_ModifiedConvars it touches are unverified.", + "source": "generated" + }, + "CCommentaryViewPosition::~CCommentaryViewPosition": { + "text": "Destroys a commentary view-position entity, which by its name marks a viewing position used by commentary playback. The class is implied by the name, and what the destructor releases is unverified.", + "source": "generated" + }, + "CCommentary_SaveRestoreBlockHandler::GetBlockName": { + "text": "Supplies the identifying name of the commentary block in save data, tagging the section this handler writes and reads. The class is implied by the name; the literal string it yields is unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddBoolLiteral": { + "text": "Appends a boolean literal to the expression being compiled into a stack-machine program. The class CCompileTargetExprStackMachineBuilder is implied by the name; how the literal is encoded in the emitted program is unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddElementAccess": { + "text": "Emits an element-access step, indexing into an array or aggregate value inside the expression program being built. The class is implied by the name; the indexing form and bounds behaviour are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddFloatLiteral": { + "text": "Appends a floating-point literal to the expression program under construction. The class is implied by the name; how the constant is stored in the emitted program is unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddFunctionCall": { + "text": "Emits a call to a named function within the expression program being built, so a compiled expression can invoke functions the host exposes. The class is implied by the name; function resolution and argument handling are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddIntLiteral": { + "text": "Appends an integer literal to the expression program under construction. The class is implied by the name; the literal's width and encoding are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddVariableExistenceLookup": { + "text": "Emits a test for whether a named variable is present in the evaluation context, which is what lets an expression guard on optional inputs. The class is implied by the name; variable naming and scoping rules are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddVariableLookup": { + "text": "Emits a fetch of a named variable's value into the expression program being built. The class is implied by the name; the namespace it resolves names against is unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::ReportParseError": { + "text": "Records a parse error hit while building an expression, so malformed input surfaces a diagnostic instead of a silently bad program. The class is implied by the name; the message format and where the error is reported are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::~CCompileTargetExprStackMachineBuilder": { + "text": "Destroys the expression stack-machine builder and releases the program state it accumulated. The class is implied by the name; what it frees is unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::CanEncode": { + "text": "Tests whether a block of rotation samples can be represented in this quaternion compression format, letting a caller pick a codec that fits the data. The class is implied by the name; the acceptance criteria and what is inspected are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::CreateContainer": { + "text": "Allocates the container that holds compressed quaternion track data for this codec, giving decode work somewhere to read from or write into. The class is implied by the name; the container's layout, sizing and ownership are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::DecodeFrame": { + "text": "Decompresses a single frame of a quaternion animation track, yielding usable rotation values for the requested frame. Reach for this when reading packed animation data rather than posing through the animgraph; the class is implied by the name, and the frame addressing is unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::DecodeSize": { + "text": "Reports how much decoded output this compressed quaternion data expands to, so a caller can size a destination buffer before decoding. The class is implied by the name; whether the figure covers one frame or a whole track is unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::DeswizzleAndBlendContainer": { + "text": "Unpacks a swizzled compressed quaternion container and blends the recovered rotations into an existing pose, combining decode and weighted accumulation in one pass. The class is implied by the name; the blend weighting and destination pose format are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::DeswizzleContainer": { + "text": "Unpacks a swizzled compressed quaternion container into straight per-element rotation values, without blending against anything. The class is implied by the name; the packed storage layout it rearranges is unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::GetFieldType": { + "text": "Reports which animation field type this codec handles, identifying it as the quaternion-valued variant among the animation codecs. The class is implied by the name; the identifier's enumeration values are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::GetFlags": { + "text": "Returns the codec's flag bits, letting a caller query behavioural properties of this quaternion compression format before using it. The class is implied by the name; the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::GetName": { + "text": "Returns the codec's name. Purpose beyond that is not established, and the class is implied by the name.", + "source": "generated" + }, + "CCompressedAnimQuaternion::GetSizeof": { + "text": "Reports the in-memory size of this quaternion codec object, which a caller needs when reserving storage for one. The class is implied by the name; the units and whether any container data is included are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::Instantiate": { + "text": "Brings a quaternion codec instance into existence, producing a usable object for decoding compressed rotation tracks. The class is implied by the name; where the memory comes from and what state is initialised are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::~CCompressedAnimQuaternion": { + "text": "Destroys a quaternion codec instance, releasing whatever it holds for its compressed rotation data. The class is implied by the name; exactly what is freed is unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::CanEncode": { + "text": "Tests whether a block of three-component samples, such as bone positions or scales, fits this vector compression format, so a caller can pick a suitable codec. The class is implied by the name; the acceptance criteria and what is inspected are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::CreateContainer": { + "text": "Allocates the container that holds compressed three-component track data for this codec, giving decode work somewhere to read from or write into. The class is implied by the name; the container's layout, sizing and ownership are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::DecodeFrame": { + "text": "Decompresses a single frame of a vector animation track, yielding usable three-component values such as bone translations. Useful when reading packed animation data directly; the class is implied by the name, and the frame addressing is unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::DecodeSize": { + "text": "Reports how much decoded output this compressed vector data expands to, so a caller can size a destination buffer before decoding. The class is implied by the name; whether the figure covers one frame or a whole track is unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks a swizzled compressed vector container and blends the recovered three-component values into an existing pose, combining decode and weighted accumulation in one pass. The class is implied by the name; the blend weighting and destination pose format are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::DeswizzleContainer": { + "text": "Unpacks a swizzled compressed vector container into straight per-element three-component values, without blending against anything. The class is implied by the name; the packed storage layout it rearranges is unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::GetFieldType": { + "text": "Reports which animation field type this codec handles, identifying it as the three-component vector variant among the animation codecs. The class is implied by the name; the identifier's enumeration values are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::GetFlags": { + "text": "Returns the codec's flag bits, letting a caller query behavioural properties of this vector compression format before using it. The class is implied by the name; the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::GetName": { + "text": "Returns the codec's name. Purpose beyond that is not established, and the class is implied by the name.", + "source": "generated" + }, + "CCompressedAnimVector3::GetSizeof": { + "text": "Reports the in-memory size of this vector codec object, which a caller needs when reserving storage for one. The class is implied by the name; the units and whether any container data is included are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::Instantiate": { + "text": "Brings a vector codec instance into existence, producing a usable object for decoding compressed three-component tracks. The class is implied by the name; where the memory comes from and what state is initialised are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::~CCompressedAnimVector3": { + "text": "Destroys a vector codec instance, releasing whatever it holds for its compressed three-component data. The class is implied by the name; exactly what is freed is unverified.", + "source": "generated" + }, + "CCompressedDeltaVector3::CanEncode": { + "text": "Tests whether a given set of source values can be represented by this delta-compressed Vector3 encoding, so a caller can pick a workable codec before compressing. The class is implied by the name, and the acceptance criteria it applies are not established by this data.", + "source": "generated" + }, + "CCompressedDeltaVector3::CreateContainer": { + "text": "Allocates the storage container that holds delta-compressed Vector3 data, giving encode and decode work a place to keep the packed bytes. The class is implied by the name; the container's layout and ownership rules are not established here.", + "source": "generated" + }, + "CCompressedDeltaVector3::DecodeFrame": { + "text": "Decodes one frame's worth of values out of a delta-compressed Vector3 container back into usable Vector3 output. The class is implied by the name, and how frames are indexed or where output lands is not established by this data.", + "source": "generated" + }, + "CCompressedDeltaVector3::DecodeSize": { + "text": "Reports how much decoded data a delta-compressed Vector3 container yields, which a caller needs when sizing a destination buffer. The class is implied by the name, and the units it reports are not established here.", + "source": "generated" + }, + "CCompressedDeltaVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks delta-compressed Vector3 data out of its interleaved (swizzled) container layout and blends the result against other values in the same pass, the shape you want for weighted blending. The class is implied by the name; the blend weighting is not established by this data.", + "source": "generated" + }, + "CCompressedDeltaVector3::DeswizzleContainer": { + "text": "Unpacks delta-compressed Vector3 data from its interleaved (swizzled) container layout into straight per-element order. The class is implied by the name, and the exact swizzle pattern and destination are not established here.", + "source": "generated" + }, + "CCompressedDeltaVector3::GetFieldType": { + "text": "Reports the field-type identifier for this codec, letting generic compression code tell that a track holds Vector3 data before touching it. The class is implied by the name; the enumeration behind the identifier is not established by this data.", + "source": "generated" + }, + "CCompressedDeltaVector3::GetFlags": { + "text": "Reports this codec's flag bits, which generic compression code can query to learn what the delta-compressed Vector3 encoding supports. The class is implied by the name, and the meaning of individual bits is not established here.", + "source": "generated" + }, + "CCompressedDeltaVector3::GetName": { + "text": "Returns this codec's name, the string form useful for logging or listing compression types. The class is implied by the name; no further purpose is established.", + "source": "generated" + }, + "CCompressedDeltaVector3::GetSizeof": { + "text": "Reports a byte size tied to this codec, the number a caller needs to allocate or step through delta-compressed Vector3 storage. The class is implied by the name, and whether the size covers the codec object or one encoded element is not established.", + "source": "generated" + }, + "CCompressedDeltaVector3::Instantiate": { + "text": "Brings up an instance of the delta-compressed Vector3 codec so the compression system has a usable object for that encoding. The class is implied by the name, and what the instance holds is not established by this data.", + "source": "generated" + }, + "CCompressedDeltaVector3::~CCompressedDeltaVector3": { + "text": "Tears down a delta-compressed Vector3 codec instance and releases whatever it owns, including any container storage it allocated. The destructor role and the class are implied by the name; the specific resources freed are not established here.", + "source": "generated" + }, + "CCompressedFullBool::CanEncode": { + "text": "Tests whether given source values can be represented by this full-precision boolean encoding, so a caller can pick a workable codec before compressing. The class is implied by the name, and the acceptance criteria it applies are not established by this data.", + "source": "generated" + }, + "CCompressedFullBool::CreateContainer": { + "text": "Allocates the storage container that holds full-precision boolean track data, giving encode and decode work a place to keep the packed bits. The class is implied by the name; the container's layout and ownership rules are not established here.", + "source": "generated" + }, + "CCompressedFullBool::DecodeFrame": { + "text": "Decodes one frame's worth of boolean values out of a full-bool container back into usable output. The class is implied by the name, and how frames are indexed or where output lands is not established by this data.", + "source": "generated" + }, + "CCompressedFullBool::DecodeSize": { + "text": "Reports how much decoded data a full-precision boolean container yields, which a caller needs when sizing a destination buffer. The class is implied by the name, and the units it reports are not established here.", + "source": "generated" + }, + "CCompressedFullBool::DeswizzleAndBlendContainer": { + "text": "Unpacks full-precision boolean data out of its interleaved (swizzled) container layout and blends the result against other values in the same pass. The class is implied by the name; how booleans are blended, and by what weighting, is not established by this data.", + "source": "generated" + }, + "CCompressedFullBool::DeswizzleContainer": { + "text": "Unpacks full-precision boolean data from its interleaved (swizzled) container layout into straight per-element order. The class is implied by the name, and the exact swizzle pattern and destination are not established here.", + "source": "generated" + }, + "CCompressedFullBool::GetFieldType": { + "text": "Reports the field-type identifier for this codec, letting generic compression code tell that a track holds boolean data before touching it. The class is implied by the name; the enumeration behind the identifier is not established by this data.", + "source": "generated" + }, + "CCompressedFullBool::GetFlags": { + "text": "Reports this codec's flag bits, which generic compression code can query to learn what the full-precision boolean encoding supports. The class is implied by the name, and the meaning of individual bits is not established here.", + "source": "generated" + }, + "CCompressedFullBool::GetName": { + "text": "Returns this codec's name, the string form useful for logging or listing compression types. The class is implied by the name; no further purpose is established.", + "source": "generated" + }, + "CCompressedFullBool::GetSizeof": { + "text": "Reports a byte size tied to this codec, the number a caller needs to allocate or step through full-bool storage. The class is implied by the name, and whether the size covers the codec object or one encoded element is not established.", + "source": "generated" + }, + "CCompressedFullBool::Instantiate": { + "text": "Brings up an instance of the full-precision boolean codec so the compression system has a usable object for that encoding. The class is implied by the name, and what the instance holds is not established by this data.", + "source": "generated" + }, + "CCompressedFullBool::~CCompressedFullBool": { + "text": "Tears down a full-precision boolean codec instance and releases whatever it owns, including any container storage it allocated. The destructor role and the class are implied by the name; the specific resources freed are not established here.", + "source": "generated" + }, + "CCompressedFullChar::CanEncode": { + "text": "Tests whether a given block of source data can be represented in this codec's full-char encoding, so a caller can choose a codec before committing to encode. Read from the name, with the CCompressedFullChar class implied by the name rather than derived from the data, and the acceptance criteria unverified.", + "source": "generated" + }, + "CCompressedFullChar::CreateContainer": { + "text": "Allocates and prepares a container that holds data in this codec's compressed full-char form, ready to be decoded. Read from the name; the CCompressedFullChar class is implied by the name, and the container's layout and ownership rules are unverified.", + "source": "generated" + }, + "CCompressedFullChar::DecodeFrame": { + "text": "Decodes a single frame of values out of the compressed full-char representation into caller-supplied output. Read from the name; the CCompressedFullChar class is implied by the name, and which frame is selected and where the output is written are unverified.", + "source": "generated" + }, + "CCompressedFullChar::DecodeSize": { + "text": "Reports how much decoded output this codec's full-char data expands to, letting a caller size a destination buffer before decoding. Read from the name; the CCompressedFullChar class is implied by the name, and whether the size is per frame or per container is unverified.", + "source": "generated" + }, + "CCompressedFullChar::DeswizzleAndBlendContainer": { + "text": "Unpacks a container's interleaved (swizzled) full-char storage into linear per-element output and blends the result against existing output values instead of overwriting them. Read from the name; the CCompressedFullChar class is implied by the name, and the blend weighting and swizzle layout are unverified.", + "source": "generated" + }, + "CCompressedFullChar::DeswizzleContainer": { + "text": "Unpacks a container's interleaved (swizzled) full-char storage into linear per-element output, writing results without blending. Read from the name; the CCompressedFullChar class is implied by the name, and the exact swizzle layout is unverified.", + "source": "generated" + }, + "CCompressedFullChar::GetFieldType": { + "text": "Reports which field type this codec handles, the char-typed data indicated by the class name, so generic code can match a codec to a field. Read from the name; the CCompressedFullChar class is implied by the name, and the enumeration returned is unverified.", + "source": "generated" + }, + "CCompressedFullChar::GetFlags": { + "text": "Returns this codec's capability or behaviour flags, which callers use to decide how its compressed data may be handled. Read from the name; the CCompressedFullChar class is implied by the name, and the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedFullChar::GetName": { + "text": "Returns a name; beyond that, purpose is not established. The CCompressedFullChar class is implied by the name, not derived from the data.", + "source": "generated" + }, + "CCompressedFullChar::GetSizeof": { + "text": "Reports the size of one element of this codec's data, which callers need for stride and buffer arithmetic. Read from the name; the CCompressedFullChar class is implied by the name, and whether it describes the encoded or the decoded element is unverified.", + "source": "generated" + }, + "CCompressedFullChar::Instantiate": { + "text": "Creates a usable instance of this full-char codec for callers that select codecs generically. Read from the name; the CCompressedFullChar class is implied by the name, and what storage the new instance occupies is unverified.", + "source": "generated" + }, + "CCompressedFullChar::~CCompressedFullChar": { + "text": "Destroys a CCompressedFullChar codec instance and releases whatever it allocated. Standard destructor behaviour; the class is implied by the name, and any cleanup beyond freeing the object is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::CanEncode": { + "text": "Tests whether a given block of source data can be represented in this codec's full 32-bit colour encoding, so a caller can choose a codec before committing to encode. Read from the name, with the CCompressedFullColor32 class implied by the name rather than derived from the data, and the acceptance criteria unverified.", + "source": "generated" + }, + "CCompressedFullColor32::CreateContainer": { + "text": "Allocates and prepares a container holding data in this codec's compressed full 32-bit colour form, ready to be decoded. Read from the name; the CCompressedFullColor32 class is implied by the name, and the container's layout and ownership rules are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::DecodeFrame": { + "text": "Decodes a single frame of 32-bit colour values out of the compressed representation into caller-supplied output. Read from the name; the CCompressedFullColor32 class is implied by the name, and which frame is selected and where the output is written are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::DecodeSize": { + "text": "Reports how much decoded output this codec's colour data expands to, letting a caller size a destination buffer before decoding. Read from the name; the CCompressedFullColor32 class is implied by the name, and whether the size is per frame or per container is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::DeswizzleAndBlendContainer": { + "text": "Unpacks a container's interleaved (swizzled) 32-bit colour storage into linear per-element output and blends the result against existing output values instead of overwriting them. Read from the name; the CCompressedFullColor32 class is implied by the name, and the blend weighting and swizzle layout are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::DeswizzleContainer": { + "text": "Unpacks a container's interleaved (swizzled) 32-bit colour storage into linear per-element output, writing results without blending. Read from the name; the CCompressedFullColor32 class is implied by the name, and the exact swizzle layout is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::GetFieldType": { + "text": "Reports which field type this codec handles, the 32-bit colour data indicated by the class name, so generic code can match a codec to a field. Read from the name; the CCompressedFullColor32 class is implied by the name, and the enumeration returned is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::GetFlags": { + "text": "Returns this codec's capability or behaviour flags, which callers use to decide how its compressed colour data may be handled. Read from the name; the CCompressedFullColor32 class is implied by the name, and the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::GetName": { + "text": "Returns a name; beyond that, purpose is not established. The CCompressedFullColor32 class is implied by the name, not derived from the data.", + "source": "generated" + }, + "CCompressedFullColor32::GetSizeof": { + "text": "Reports the size of one element of this codec's colour data, which callers need for stride and buffer arithmetic. Read from the name; the CCompressedFullColor32 class is implied by the name, and whether it describes the encoded or the decoded element is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::Instantiate": { + "text": "Creates a usable instance of this full 32-bit colour codec for callers that select codecs generically. Read from the name; the CCompressedFullColor32 class is implied by the name, and what storage the new instance occupies is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::~CCompressedFullColor32": { + "text": "Destroys a CCompressedFullColor32 codec instance and releases whatever it allocated. Standard destructor behaviour; the class is implied by the name, and any cleanup beyond freeing the object is unverified.", + "source": "generated" + }, + "CCompressedFullFloat::CanEncode": { + "text": "Reports whether this full-precision float format is able to encode a given piece of source data, so a caller can pick a codec that accepts it. Read from the name; the class is implied by the name, and the accept/reject criteria are not established here.", + "source": "generated" + }, + "CCompressedFullFloat::CreateContainer": { + "text": "Allocates the storage container that holds this codec's full-precision float data. Read from the name; the class is implied by the name, and the container's layout and ownership are not established here.", + "source": "generated" + }, + "CCompressedFullFloat::DecodeFrame": { + "text": "Decodes one frame's worth of values out of compressed full-precision float storage into usable output. Read from the name; the class is implied by the name, and the frame indexing and destination are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::DecodeSize": { + "text": "Reports the size of the decoded result for full-precision float data, letting a caller size a destination buffer before decoding. Read from the name; the class is implied by the name, and the unit of that size is unverified.", + "source": "generated" + }, + "CCompressedFullFloat::DeswizzleAndBlendContainer": { + "text": "Unpacks interleaved (swizzled) full-precision float container data into per-element order while blending it against another set of values, such as when mixing two sampled poses. Read from the name; the class is implied by the name, and the blend inputs are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::DeswizzleContainer": { + "text": "Unpacks interleaved (swizzled) full-precision float container data back into per-element order for direct use, without the blending step its sibling performs. Read from the name; the class is implied by the name, and the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::GetFieldType": { + "text": "Reports which field type this codec stores, so calling code can match a codec against the data it is meant to hold. Read from the name; the class is implied by the name, and the type enumeration is not established here.", + "source": "generated" + }, + "CCompressedFullFloat::GetFlags": { + "text": "Exposes the codec's behaviour or capability flags, which callers test to learn how the format may be used. Read from the name; the class is implied by the name, and the individual flag meanings are not established here.", + "source": "generated" + }, + "CCompressedFullFloat::GetName": { + "text": "Purpose is not established beyond supplying a name for this codec; the class is implied by the name.", + "source": "generated" + }, + "CCompressedFullFloat::GetSizeof": { + "text": "Reports the byte size associated with this codec, useful when allocating storage or striding through its data. Read from the name; the class is implied by the name, and whether the size describes one element or the whole object is unverified.", + "source": "generated" + }, + "CCompressedFullFloat::Instantiate": { + "text": "Brings a working instance of the full-precision float codec into existence for data that selects this format. Read from the name; the class is implied by the name, and what it constructs or registers is not established here.", + "source": "generated" + }, + "CCompressedFullFloat::~CCompressedFullFloat": { + "text": "Tears down a CCompressedFullFloat instance and releases what the codec holds. Read from the name as this class's destructor; the class is implied by the name, and what it frees is not established here.", + "source": "generated" + }, + "CCompressedFullInt::CanEncode": { + "text": "Reports whether this full-precision integer format is able to encode a given piece of source data, so a caller can pick a codec that accepts it. Read from the name; the class is implied by the name, and the accept/reject criteria are not established here.", + "source": "generated" + }, + "CCompressedFullInt::CreateContainer": { + "text": "Allocates the storage container that holds this codec's full-precision integer data. Read from the name; the class is implied by the name, and the container's layout and ownership are not established here.", + "source": "generated" + }, + "CCompressedFullInt::DecodeFrame": { + "text": "Decodes one frame's worth of values out of compressed full-precision integer storage into usable output. Read from the name; the class is implied by the name, and the frame indexing and destination are unverified.", + "source": "generated" + }, + "CCompressedFullInt::DecodeSize": { + "text": "Reports the size of the decoded result for full-precision integer data, letting a caller size a destination buffer before decoding. Read from the name; the class is implied by the name, and the unit of that size is unverified.", + "source": "generated" + }, + "CCompressedFullInt::DeswizzleAndBlendContainer": { + "text": "Unpacks interleaved (swizzled) full-precision integer container data into per-element order while blending it against another set of values, such as when mixing two sampled poses. Read from the name; the class is implied by the name, and the blend inputs are unverified.", + "source": "generated" + }, + "CCompressedFullInt::DeswizzleContainer": { + "text": "Unpacks interleaved (swizzled) full-precision integer container data back into per-element order for direct use, without the blending step its sibling performs. Read from the name; the class is implied by the name, and the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedFullInt::GetFieldType": { + "text": "Reports which field type this codec stores, so calling code can match a codec against the data it is meant to hold. Read from the name; the class is implied by the name, and the type enumeration is not established here.", + "source": "generated" + }, + "CCompressedFullInt::GetFlags": { + "text": "Exposes the codec's behaviour or capability flags, which callers test to learn how the format may be used. Read from the name; the class is implied by the name, and the individual flag meanings are not established here.", + "source": "generated" + }, + "CCompressedFullInt::GetName": { + "text": "Purpose is not established beyond supplying a name for this codec; the class is implied by the name.", + "source": "generated" + }, + "CCompressedFullInt::GetSizeof": { + "text": "Reports the byte size associated with this codec, useful when allocating storage or striding through its data. Read from the name; the class is implied by the name, and whether the size describes one element or the whole object is unverified.", + "source": "generated" + }, + "CCompressedFullInt::Instantiate": { + "text": "Brings a working instance of the full-precision integer codec into existence for data that selects this format. Read from the name; the class is implied by the name, and what it constructs or registers is not established here.", + "source": "generated" + }, + "CCompressedFullInt::~CCompressedFullInt": { + "text": "Tears down a CCompressedFullInt instance and releases what the codec holds. Read from the name as this class's destructor; the class is implied by the name, and what it frees is not established here.", + "source": "generated" + }, + "CCompressedFullShort::CanEncode": { + "text": "Tests whether this short-valued compression format can represent a given piece of source data, so a caller can pick a format that round-trips. Behaviour is read from the name, and the owning class is implied by the name rather than the data, so the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedFullShort::CreateContainer": { + "text": "Creates the storage container that holds compressed short data for this format. Read from the name; the class is implied by the name rather than the data, so what the container holds and who owns its memory are unverified.", + "source": "generated" + }, + "CCompressedFullShort::DecodeFrame": { + "text": "Decodes one frame's worth of compressed short values back into usable data, a read path for sampling stored animation channels. Read from the name; the class is implied by the name, and the frame indexing and output layout are unverified.", + "source": "generated" + }, + "CCompressedFullShort::DecodeSize": { + "text": "Reports the size of the decoded result for this compressed-short format, useful when sizing a destination buffer before decoding. Read from the name; the class is implied by the name, and whether the figure counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedFullShort::DeswizzleAndBlendContainer": { + "text": "Unpacks a container's interleaved compressed short data into linear order while blending it against a weight, a combined path for sampling between stored values. Read from the name; the class is implied by the name, so the blend factor's meaning is unverified.", + "source": "generated" + }, + "CCompressedFullShort::DeswizzleContainer": { + "text": "Unpacks a container's interleaved compressed short data back into linear per-element order, without any blending step. Read from the name; the class is implied by the name rather than the data, so the storage layout it reverses is unverified.", + "source": "generated" + }, + "CCompressedFullShort::GetFieldType": { + "text": "Reports which field type this compression format handles, letting a caller match a compressed stream to the data it decodes into. Read from the name; the class is implied by the name, and the identifier it hands back is not established here.", + "source": "generated" + }, + "CCompressedFullShort::GetFlags": { + "text": "Reports the format's flag bits, which describe its capabilities or storage options to whatever selects a compression format. Read from the name; the class is implied by the name, and the meaning of individual bits is not established here.", + "source": "generated" + }, + "CCompressedFullShort::GetName": { + "text": "Purpose is not established beyond retrieving a name for this compression format. The owning class is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedFullShort::GetSizeof": { + "text": "Reports an in-memory size associated with this compressed-short format, useful when allocating or striding over its data. Read from the name; the class is implied by the name, and whether the size describes one element or the codec object is unverified.", + "source": "generated" + }, + "CCompressedFullShort::Instantiate": { + "text": "Constructs or registers the working instance of this compressed-short format so it becomes usable. Read from the name; the class is implied by the name rather than the data, so where the instance lives and whether it is shared are unverified.", + "source": "generated" + }, + "CCompressedFullShort::~CCompressedFullShort": { + "text": "Destructor for the compressed-short codec object, releasing whatever it holds when it is torn down. The class is implied by the name, and what it frees is unverified, so code that hooks or replaces the codec should not assume it owns container memory.", + "source": "generated" + }, + "CCompressedFullVector2D::CanEncode": { + "text": "Tests whether this two-component-vector compression format can represent a given piece of source data, so a caller can pick a format that round-trips. Behaviour is read from the name, and the owning class is implied by the name rather than the data, so the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedFullVector2D::CreateContainer": { + "text": "Creates the storage container that holds compressed two-component vector data for this format. Read from the name; the class is implied by the name rather than the data, so what the container holds and who owns its memory are unverified.", + "source": "generated" + }, + "CCompressedFullVector2D::DecodeFrame": { + "text": "Decodes one frame's worth of compressed Vector2D values back into usable data, a read path for sampling stored animation channels. Read from the name; the class is implied by the name, and the frame indexing and output layout are unverified.", + "source": "generated" + }, + "CCompressedFullVector2D::DecodeSize": { + "text": "Reports the size of the decoded result for this compressed Vector2D format, useful when sizing a destination buffer before decoding. Read from the name; the class is implied by the name, and whether the figure counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedFullVector2D::DeswizzleAndBlendContainer": { + "text": "Unpacks a container's interleaved compressed Vector2D data into linear order while blending it against a weight, a combined path for sampling between stored values. Read from the name; the class is implied by the name, so the blend factor's meaning is unverified.", + "source": "generated" + }, + "CCompressedFullVector2D::DeswizzleContainer": { + "text": "Unpacks a container's interleaved compressed Vector2D data back into linear per-element order, without any blending step. Read from the name; the class is implied by the name rather than the data, so the storage layout it reverses is unverified.", + "source": "generated" + }, + "CCompressedFullVector2D::GetFieldType": { + "text": "Reports which field type this compression format handles, letting a caller match a compressed stream to the data it decodes into. Read from the name; the class is implied by the name, and the identifier it hands back is not established here.", + "source": "generated" + }, + "CCompressedFullVector2D::GetFlags": { + "text": "Reports the format's flag bits, which describe its capabilities or storage options to whatever selects a compression format. Read from the name; the class is implied by the name, and the meaning of individual bits is not established here.", + "source": "generated" + }, + "CCompressedFullVector2D::GetName": { + "text": "Purpose is not established beyond retrieving a name for this compression format. The owning class is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::GetSizeof": { + "text": "Reports an in-memory size associated with this compressed Vector2D format, useful when allocating or striding over its data. Read from the name; the class is implied by the name, and whether the size describes one element or the codec object is unverified.", + "source": "generated" + }, + "CCompressedFullVector2D::Instantiate": { + "text": "Constructs or registers the working instance of this compressed Vector2D format so it becomes usable. Read from the name; the class is implied by the name rather than the data, so where the instance lives and whether it is shared are unverified.", + "source": "generated" + }, + "CCompressedFullVector2D::~CCompressedFullVector2D": { + "text": "Destructor for the compressed Vector2D codec object, releasing whatever it holds when it is torn down. The class is implied by the name, and what it frees is unverified, so code that hooks or replaces the codec should not assume it owns container memory.", + "source": "generated" + }, + "CCompressedFullVector3::CanEncode": { + "text": "Tests whether a given three-component vector track can be represented in this full-precision compressed format, so a caller can decide which codec to use for it. Read from the name; the owning class CCompressedFullVector3 is implied by the name rather than by the data, and the accept/reject criteria are unverified.", + "source": "generated" + }, + "CCompressedFullVector3::CreateContainer": { + "text": "Allocates the storage container that holds this codec's encoded three-component vector data. Read from the name; the class CCompressedFullVector3 is implied by the name rather than by the data, so the container's layout, capacity and ownership rules are unverified.", + "source": "generated" + }, + "CCompressedFullVector3::DecodeFrame": { + "text": "Decodes a single frame of three-component vector values out of this codec's compressed container into usable output. Read from the name; the class CCompressedFullVector3 is implied by the name rather than by the data, so frame addressing and where the decoded values land are unverified.", + "source": "generated" + }, + "CCompressedFullVector3::DecodeSize": { + "text": "Reports how much decoded data this three-component codec produces, letting a caller size an output buffer before decoding. Read from the name; the class CCompressedFullVector3 is implied by the name rather than by the data, and whether the figure counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedFullVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks this codec's interleaved container back into per-element three-component vectors while blending between stored values, the form needed when a pose falls between frames. Read from the name; the class CCompressedFullVector3 is implied by the name, so the blend weight's convention is unverified.", + "source": "generated" + }, + "CCompressedFullVector3::DeswizzleContainer": { + "text": "Unpacks this codec's interleaved container into plain per-element three-component vectors with no blending applied. Read from the name; the class CCompressedFullVector3 is implied by the name rather than by the data, so the exact packing order it reverses is unverified.", + "source": "generated" + }, + "CCompressedFullVector3::GetFieldType": { + "text": "Reports which field type this codec handles, letting the decompression system match a codec to a track. Read from the name; the class CCompressedFullVector3 is implied by the name rather than by the data, and how the reported type value is encoded is unverified.", + "source": "generated" + }, + "CCompressedFullVector3::GetFlags": { + "text": "Reports this codec's descriptive flags, the sort of thing consulted when selecting or configuring compression for a track. Read from the name; the class CCompressedFullVector3 is implied by the name rather than by the data, so the meaning of individual flag bits is unverified.", + "source": "generated" + }, + "CCompressedFullVector3::GetName": { + "text": "Reports the codec's identifying name, the label tooling and debug output use for this compression type. Nothing beyond that is established; the class CCompressedFullVector3 is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedFullVector3::GetSizeof": { + "text": "Reports the in-memory size of this codec's record, useful when stepping through packed compressed data. Read from the name; the class CCompressedFullVector3 is implied by the name rather than by the data, so exactly which object is being measured is unverified.", + "source": "generated" + }, + "CCompressedFullVector3::Instantiate": { + "text": "Brings up a working instance of this full-precision three-component codec for use by the decompression machinery. Read from the name; the class CCompressedFullVector3 is implied by the name rather than by the data, so allocation and ownership behaviour are unverified.", + "source": "generated" + }, + "CCompressedFullVector3::~CCompressedFullVector3": { + "text": "Destructor for the full-precision three-component codec object, releasing whatever the instance holds. Standard destructor behaviour is assumed and the class CCompressedFullVector3 is implied by the name, so any additional teardown it performs is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::CanEncode": { + "text": "Tests whether a given four-component vector track can be represented in this full-precision compressed format, so a caller can pick a suitable codec. Read from the name; the owning class CCompressedFullVector4D is implied by the name rather than by the data, and the rejection criteria are unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::CreateContainer": { + "text": "Allocates the storage container holding this codec's encoded four-component vector data. Read from the name; the class CCompressedFullVector4D is implied by the name rather than by the data, so container layout, capacity and ownership are unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::DecodeFrame": { + "text": "Decodes one frame of four-component vector values from this codec's compressed container into usable output. Read from the name; the class CCompressedFullVector4D is implied by the name rather than by the data, so frame addressing and output placement are unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::DecodeSize": { + "text": "Reports how much decoded data this four-component codec yields, so a caller can size an output buffer ahead of decoding. Read from the name; the class CCompressedFullVector4D is implied by the name rather than by the data, and the unit being reported is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::DeswizzleAndBlendContainer": { + "text": "Unpacks this codec's interleaved container into per-element four-component vectors while blending between stored values, as needed when sampling between frames. Read from the name; the class CCompressedFullVector4D is implied by the name, so the blend weight's convention is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::DeswizzleContainer": { + "text": "Unpacks this codec's interleaved container into plain per-element four-component vectors with no blending applied. Read from the name; the class CCompressedFullVector4D is implied by the name rather than by the data, so the exact packing order it reverses is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::GetFieldType": { + "text": "Reports which field type this four-component codec serves, letting the decompression system match a codec to a track. Read from the name; the class CCompressedFullVector4D is implied by the name rather than by the data, and how the reported type value is encoded is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::GetFlags": { + "text": "Reports this codec's descriptive flags, consulted when selecting or configuring compression for a track. Read from the name; the class CCompressedFullVector4D is implied by the name rather than by the data, so the meaning of individual flag bits is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::GetName": { + "text": "Reports the codec's identifying name, the label tooling and debug output use for this compression type. Nothing beyond that is established; the class CCompressedFullVector4D is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedFullVector4D::GetSizeof": { + "text": "Reports the in-memory size of this codec's record, useful when walking packed compressed data. Read from the name; the class CCompressedFullVector4D is implied by the name rather than by the data, so which object is being measured is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::Instantiate": { + "text": "Brings up a working instance of this full-precision four-component codec for the decompression machinery to use. Read from the name; the class CCompressedFullVector4D is implied by the name rather than by the data, so allocation and lifetime behaviour are unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::~CCompressedFullVector4D": { + "text": "Destructor for the full-precision four-component codec object, releasing anything the instance owns. Standard destructor behaviour is assumed and the class CCompressedFullVector4D is implied by the name, so any extra teardown it performs is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::CanEncode": { + "text": "Tests whether some given boolean data can be represented by this compressed-static encoding, so a caller can pick a codec that fits the data. Read from the name; the CCompressedStaticBool class is implied by the name, and the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticBool::CreateContainer": { + "text": "Allocates the container object that holds this codec's compressed boolean payload, which a caller fills and later decodes from. Read from the name; the CCompressedStaticBool class is implied by the name, and the container's layout and ownership are unverified.", + "source": "generated" + }, + "CCompressedStaticBool::DecodeFrame": { + "text": "Decodes the codec's compressed boolean data for a single frame into usable output values. Read from the name; the CCompressedStaticBool class is implied by the name, and the frame indexing and destination format are unverified.", + "source": "generated" + }, + "CCompressedStaticBool::DecodeSize": { + "text": "Reports how large the decoded boolean output is, letting a caller size a destination buffer before asking for a decode. Read from the name; the CCompressedStaticBool class is implied by the name, and the units measured are unverified.", + "source": "generated" + }, + "CCompressedStaticBool::DeswizzleAndBlendContainer": { + "text": "Unpacks a compressed boolean container out of its interleaved storage order and blends the decoded values against existing destination data rather than overwriting them. Read from the name; the CCompressedStaticBool class is implied by the name, and the blend weighting is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::DeswizzleContainer": { + "text": "Unpacks a compressed boolean container out of its interleaved storage order into straight per-element output, with no blend step indicated by the name. Read from the name; the CCompressedStaticBool class is implied by the name, and the storage layout is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::GetFieldType": { + "text": "Reports which field type this codec handles, identifying it as the boolean variant to code that inspects codecs generically. Read from the name; the CCompressedStaticBool class is implied by the name, and the type enumeration used is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::GetFlags": { + "text": "Reports the codec's capability or behaviour flags, for code deciding how to treat a codec before using it. Read from the name; the CCompressedStaticBool class is implied by the name, and the meaning of individual flag bits is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::GetName": { + "text": "Purpose is not established beyond yielding some identifying name for the codec. The CCompressedStaticBool class is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedStaticBool::GetSizeof": { + "text": "Reports the size of the codec's own object, as needed when allocating storage for one or stepping across instances. Read from the name; the CCompressedStaticBool class is implied by the name, and exactly what is measured is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::Instantiate": { + "text": "Brings a working instance of this boolean codec into existence for use. Read from the name; the CCompressedStaticBool class is implied by the name, and what is produced or where it is placed is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::~CCompressedStaticBool": { + "text": "Destroys a codec instance, releasing whatever storage it owns when it is torn down. The CCompressedStaticBool class is implied by the name, and the specific resources freed are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::CanEncode": { + "text": "Tests whether some given char-typed data can be represented by this compressed-static encoding, so a caller can pick a codec that fits the data. Read from the name; the CCompressedStaticChar class is implied by the name, and the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::CreateContainer": { + "text": "Allocates the container object that holds this codec's compressed char payload, which a caller fills and later decodes from. Read from the name; the CCompressedStaticChar class is implied by the name, and the container's layout and ownership are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::DecodeFrame": { + "text": "Decodes the codec's compressed char data for a single frame into usable output values. Read from the name; the CCompressedStaticChar class is implied by the name, and the frame indexing and destination format are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::DecodeSize": { + "text": "Reports how large the decoded char output is, letting a caller size a destination buffer before asking for a decode. Read from the name; the CCompressedStaticChar class is implied by the name, and the units measured are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::DeswizzleAndBlendContainer": { + "text": "Unpacks a compressed char container out of its interleaved storage order and blends the decoded values against existing destination data rather than overwriting them. Read from the name; the CCompressedStaticChar class is implied by the name, and the blend weighting is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::DeswizzleContainer": { + "text": "Unpacks a compressed char container out of its interleaved storage order into straight per-element output, with no blend step indicated by the name. Read from the name; the CCompressedStaticChar class is implied by the name, and the storage layout is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::GetFieldType": { + "text": "Reports which field type this codec handles, identifying it as the char variant to code that inspects codecs generically. Read from the name; the CCompressedStaticChar class is implied by the name, and the type enumeration used is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::GetFlags": { + "text": "Reports the codec's capability or behaviour flags, for code deciding how to treat a codec before using it. Read from the name; the CCompressedStaticChar class is implied by the name, and the meaning of individual flag bits is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::GetName": { + "text": "Purpose is not established beyond yielding some identifying name for the codec. The CCompressedStaticChar class is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedStaticChar::GetSizeof": { + "text": "Reports the size of the codec's own object, as needed when allocating storage for one or stepping across instances. Read from the name; the CCompressedStaticChar class is implied by the name, and exactly what is measured is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::Instantiate": { + "text": "Brings a working instance of this char codec into existence for use. Read from the name; the CCompressedStaticChar class is implied by the name, and what is produced or where it is placed is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::~CCompressedStaticChar": { + "text": "Destroys a codec instance, releasing whatever storage it owns when it is torn down. The CCompressedStaticChar class is implied by the name, and the specific resources freed are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::CanEncode": { + "text": "Reports whether supplied color32 data can be represented by this static-value compression format, letting a caller test a codec before committing data to it. Read from the name; the owning class is implied by the name rather than by the data, so the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::CreateContainer": { + "text": "Allocates the container object that holds this codec's compressed color32 payload, the storage an encoder or decoder then works against. Read from the name; the class is implied by the name, so the container's layout and who owns it afterwards are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::DecodeFrame": { + "text": "Decompresses one frame's worth of color32 values out of an encoded container into caller-visible output. Use it when you need the animated colour value at a specific frame; the class is implied by the name, so frame indexing and output destination are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::DecodeSize": { + "text": "Reports how large the decoded color32 output is, which is what you need to size a destination buffer before decoding. Read from the name; the class is implied by the name, so whether the figure counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::DeswizzleAndBlendContainer": { + "text": "Unpacks color32 samples out of the container's swizzled (interleaved) storage order and blends them into linear, directly readable output. Read from the name; the class is implied by the name, so the blend weighting and the destination layout are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::DeswizzleContainer": { + "text": "Unpacks color32 samples from the container's swizzled storage order into a linear, directly readable ordering, with no blend step named. Read from the name; the class is implied by the name, so the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::GetFieldType": { + "text": "Reports which data field type this codec encodes, colour32 by the class name, so a caller can match a codec to a data channel. Read from the name; the class is implied by the name, so the identifier's encoding is unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::GetFlags": { + "text": "Reports the codec's descriptive flags, which a caller inspects to learn how its compressed color32 data must be handled. Read from the name; the class is implied by the name, so the meaning of individual flag bits is unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::GetName": { + "text": "Yields an identifying name for this codec; beyond that, purpose is not established. The class is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedStaticColor32::GetSizeof": { + "text": "Reports the byte size of this codec's structure, the figure you would use for allocation or stride arithmetic. Read from the name; the class is implied by the name, so exactly what is being measured is unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::Instantiate": { + "text": "Brings a working instance of this color32 static codec into being, so callers obtain a usable codec object rather than constructing one directly. Read from the name; the class is implied by the name, so where the instance lives and how it is initialised are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::~CCompressedStaticColor32": { + "text": "Tears down a CCompressedStaticColor32 instance, releasing whatever compressed-data storage it holds. Read from the name; the class is implied by the name, so the exact resources freed are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::CanEncode": { + "text": "Reports whether supplied float data can be represented by this static-value compression format, letting a caller test a codec before committing data to it. Read from the name; the owning class is implied by the name rather than by the data, so the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::CreateContainer": { + "text": "Allocates the container object that holds this codec's compressed float payload, the storage an encoder or decoder then works against. Read from the name; the class is implied by the name, so the container's layout and who owns it afterwards are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::DecodeFrame": { + "text": "Decompresses one frame's worth of float values out of an encoded container into caller-visible output. Use it when you need the animated scalar value at a specific frame; the class is implied by the name, so frame indexing and output destination are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::DecodeSize": { + "text": "Reports how large the decoded float output is, which is what you need to size a destination buffer before decoding. Read from the name; the class is implied by the name, so whether the figure counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::DeswizzleAndBlendContainer": { + "text": "Unpacks float samples out of the container's swizzled (interleaved) storage order and blends them into linear, directly readable output. Read from the name; the class is implied by the name, so the blend weighting and the destination layout are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::DeswizzleContainer": { + "text": "Unpacks float samples from the container's swizzled storage order into a linear, directly readable ordering, with no blend step named. Read from the name; the class is implied by the name, so the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::GetFieldType": { + "text": "Reports which data field type this codec encodes, float by the class name, so a caller can match a codec to a data channel. Read from the name; the class is implied by the name, so the identifier's encoding is unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::GetFlags": { + "text": "Reports the codec's descriptive flags, which a caller inspects to learn how its compressed float data must be handled. Read from the name; the class is implied by the name, so the meaning of individual flag bits is unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::GetName": { + "text": "Yields an identifying name for this codec; beyond that, purpose is not established. The class is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedStaticFloat::GetSizeof": { + "text": "Reports the byte size of this codec's structure, the figure you would use for allocation or stride arithmetic. Read from the name; the class is implied by the name, so exactly what is being measured is unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::Instantiate": { + "text": "Brings a working instance of this float static codec into being, so callers obtain a usable codec object rather than constructing one directly. Read from the name; the class is implied by the name, so where the instance lives and how it is initialised are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::~CCompressedStaticFloat": { + "text": "Tears down a CCompressedStaticFloat instance, releasing whatever compressed-data storage it holds. Read from the name; the class is implied by the name, so the exact resources freed are unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::CanEncode": { + "text": "Tests whether supplied animation data can be represented in this constant Vector3 compression format, so a caller can decide the codec is applicable before committing to it. Reading is name-level and unverified; the owning class is implied by the name rather than bound in the data.", + "source": "generated" + }, + "CCompressedStaticFullVector3::CreateContainer": { + "text": "Allocates and prepares the storage container that holds this codec's compressed constant Vector3 data. Read from the name only; the owning class is implied by the name, and what the container is built from is unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::DecodeFrame": { + "text": "Recovers the Vector3 value for a requested frame from the compressed block and writes it out for the animation system to consume. Name-level reading; the owning class is implied by the name, and the exact inputs and output layout are unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::DecodeSize": { + "text": "Reports how large the decoded Vector3 output is, useful for sizing a destination buffer before decoding. Read from the name; the owning class is implied by the name, and precisely what the size measures is unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed Vector3 values back into per-element layout while blending them against existing output values, as used for weighted animation layering. Name-level reading; the owning class is implied by the name and the blend semantics are unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::DeswizzleContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed Vector3 values into straight per-element layout, without any blending step. Reading is name-level and unverified; the owning class is implied by the name rather than bound in the data.", + "source": "generated" + }, + "CCompressedStaticFullVector3::GetFieldType": { + "text": "Reports which animation field type this codec handles, letting a caller match a codec against a data channel. Read from the name; the owning class is implied by the name, and the type enumeration is not established here.", + "source": "generated" + }, + "CCompressedStaticFullVector3::GetFlags": { + "text": "Reports the codec's descriptor flags, the bits a caller inspects to learn how the compressed data behaves. Name-level reading; the owning class is implied by the name, and the individual flag meanings are not established by this data.", + "source": "generated" + }, + "CCompressedStaticFullVector3::GetName": { + "text": "Returns an identifying name for the codec, but which string it yields is not established. The owning class is implied by the name, not derived from the data.", + "source": "generated" + }, + "CCompressedStaticFullVector3::GetSizeof": { + "text": "Reports the in-memory size of this codec's data element, useful when walking or allocating a compressed block. Read from the name; the owning class is implied by the name, and exactly what is measured is unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::Instantiate": { + "text": "Brings an instance of this codec into existence, the construction hook a codec registry uses to obtain a working object. Beyond that the purpose is not established; the owning class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticFullVector3::~CCompressedStaticFullVector3": { + "text": "Destroys a CCompressedStaticFullVector3 instance, releasing whatever compressed-data storage it holds. The owning class is implied by the name; the specific cleanup performed is unverified.", + "source": "generated" + }, + "CCompressedStaticInt::CanEncode": { + "text": "Tests whether supplied animation data can be represented in this constant integer compression format, so a caller can decide the codec is applicable before committing to it. Reading is name-level and unverified; the owning class is implied by the name rather than bound in the data.", + "source": "generated" + }, + "CCompressedStaticInt::CreateContainer": { + "text": "Allocates and prepares the storage container that holds this codec's compressed constant integer data. Read from the name only; the owning class is implied by the name, and what the container is built from is unverified.", + "source": "generated" + }, + "CCompressedStaticInt::DecodeFrame": { + "text": "Recovers the integer value for a requested frame from the compressed block and writes it out for the animation system to consume. Name-level reading; the owning class is implied by the name, and the exact inputs and output layout are unverified.", + "source": "generated" + }, + "CCompressedStaticInt::DecodeSize": { + "text": "Reports how large the decoded integer output is, useful for sizing a destination buffer before decoding. Read from the name; the owning class is implied by the name, and precisely what the size measures is unverified.", + "source": "generated" + }, + "CCompressedStaticInt::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed integer values back into per-element layout while blending them against existing output values, as used for weighted animation layering. Name-level reading; the owning class is implied by the name and the blend semantics are unverified.", + "source": "generated" + }, + "CCompressedStaticInt::DeswizzleContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed integer values into straight per-element layout, without any blending step. Reading is name-level and unverified; the owning class is implied by the name rather than bound in the data.", + "source": "generated" + }, + "CCompressedStaticInt::GetFieldType": { + "text": "Reports which animation field type this codec handles, letting a caller match a codec against a data channel. Read from the name; the owning class is implied by the name, and the type enumeration is not established here.", + "source": "generated" + }, + "CCompressedStaticInt::GetFlags": { + "text": "Reports the codec's descriptor flags, the bits a caller inspects to learn how the compressed data behaves. Name-level reading; the owning class is implied by the name, and the individual flag meanings are not established by this data.", + "source": "generated" + }, + "CCompressedStaticInt::GetName": { + "text": "Returns an identifying name for the codec, but which string it yields is not established. The owning class is implied by the name, not derived from the data.", + "source": "generated" + }, + "CCompressedStaticInt::GetSizeof": { + "text": "Reports the in-memory size of this codec's data element, useful when walking or allocating a compressed block. Read from the name; the owning class is implied by the name, and exactly what is measured is unverified.", + "source": "generated" + }, + "CCompressedStaticInt::Instantiate": { + "text": "Brings an instance of this codec into existence, the construction hook a codec registry uses to obtain a working object. Beyond that the purpose is not established; the owning class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticInt::~CCompressedStaticInt": { + "text": "Destroys a CCompressedStaticInt instance, releasing whatever compressed-data storage it holds. The owning class is implied by the name; the specific cleanup performed is unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::CanEncode": { + "text": "Tests whether a given set of animation rotation values can be represented in this static-quaternion compressed form, so a packer can accept or reject the codec. Read from the name; the class is implied by the name, and the acceptance criteria it applies are unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::CreateContainer": { + "text": "Allocates the container object that holds this codec's compressed static quaternion data. Read from the name; the class is implied by the name, so the container's layout and who owns the memory are unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::DecodeFrame": { + "text": "Decodes a single animation frame out of compressed static quaternion data into usable rotation values. Read from the name; the class is implied by the name, and which buffers it reads and writes are unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::DecodeSize": { + "text": "Reports how much decoded output this static-quaternion codec produces, letting a caller size a destination buffer before decoding. Read from the name; the class is implied by the name, and the unit the size is expressed in is unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::DeswizzleAndBlendContainer": { + "text": "Unpacks the interleaved (swizzled) layout of a compressed static-quaternion container and blends the decoded rotations into a destination pose. Read from the name; the class is implied by the name, so the blend weighting and container layout are unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::DeswizzleContainer": { + "text": "Unpacks a compressed static-quaternion container from its interleaved (swizzled) storage order into per-element rotation values, without the blending step. Read from the name; the class is implied by the name, and the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::GetFieldType": { + "text": "Reports which animation field type this codec handles, which is how decoding code picks a codec for a given channel. Read from the name; the class is implied by the name, and the type enumeration behind the value is unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::GetFlags": { + "text": "Reports the codec's flags, the bitfield describing how its compressed data is to be treated. Read from the name; the class is implied by the name, and the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::GetName": { + "text": "Returns the codec's name, useful for identifying it in tooling or logs; beyond identification the purpose is not established. The class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticQuaternion::GetSizeof": { + "text": "Reports the size of this codec's data element, the figure a caller needs for allocation and stride arithmetic over a compressed block. Read from the name; the class is implied by the name, and exactly what is being measured is unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::Instantiate": { + "text": "Brings an instance of the static-quaternion codec into existence so it can be used for decoding. Read from the name; the class is implied by the name, and where the resulting instance is kept is unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::~CCompressedStaticQuaternion": { + "text": "Destroys the static-quaternion codec object and releases the storage it holds. Standard destructor behaviour; the class is implied by the name, and any cleanup beyond freeing the object is unverified.", + "source": "generated" + }, + "CCompressedStaticShort::CanEncode": { + "text": "Tests whether given animation values fit this short-integer static compressed form, so a packer can accept or reject the codec for a channel. Read from the name; the class is implied by the name, and the acceptance criteria it applies are unverified.", + "source": "generated" + }, + "CCompressedStaticShort::CreateContainer": { + "text": "Allocates the container object that holds this codec's compressed static short-integer data. Read from the name; the class is implied by the name, so the container's layout and memory ownership are unverified.", + "source": "generated" + }, + "CCompressedStaticShort::DecodeFrame": { + "text": "Decodes a single animation frame out of compressed static short-integer data into usable values. Read from the name; the class is implied by the name, and which buffers it reads and writes are unverified.", + "source": "generated" + }, + "CCompressedStaticShort::DecodeSize": { + "text": "Reports how much decoded output this short-integer codec produces, so a caller can size a destination buffer before decoding. Read from the name; the class is implied by the name, and the unit the size is expressed in is unverified.", + "source": "generated" + }, + "CCompressedStaticShort::DeswizzleAndBlendContainer": { + "text": "Unpacks the interleaved (swizzled) layout of a compressed static short-integer container and blends the decoded values into a destination. Read from the name; the class is implied by the name, so the blend weighting and container layout are unverified.", + "source": "generated" + }, + "CCompressedStaticShort::DeswizzleContainer": { + "text": "Unpacks a compressed static short-integer container from its interleaved (swizzled) storage order into per-element values, without the blending step. Read from the name; the class is implied by the name, and the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedStaticShort::GetFieldType": { + "text": "Reports which animation field type this codec handles, which is how decoding code picks a codec for a given channel. Read from the name; the class is implied by the name, and the type enumeration behind the value is unverified.", + "source": "generated" + }, + "CCompressedStaticShort::GetFlags": { + "text": "Reports the codec's flags, the bitfield describing how its compressed data is to be treated. Read from the name; the class is implied by the name, and the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedStaticShort::GetName": { + "text": "Returns the codec's name, useful for identifying it in tooling or logs; beyond identification the purpose is not established. The class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticShort::GetSizeof": { + "text": "Reports the size of this codec's data element, the figure a caller needs for allocation and stride arithmetic over a compressed block. Read from the name; the class is implied by the name, and exactly what is being measured is unverified.", + "source": "generated" + }, + "CCompressedStaticShort::Instantiate": { + "text": "Brings an instance of the short-integer static codec into existence so it can be used for decoding. Read from the name; the class is implied by the name, and where the resulting instance is kept is unverified.", + "source": "generated" + }, + "CCompressedStaticShort::~CCompressedStaticShort": { + "text": "Destroys the short-integer static codec object and releases the storage it holds. Standard destructor behaviour; the class is implied by the name, and any cleanup beyond freeing the object is unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::CanEncode": { + "text": "Tests whether a given block of source data can be represented in this compressed static 2D-vector encoding, so a writer can reject a codec that does not fit the data. Read from the name; the class CCompressedStaticVector2D is implied by the name, and the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::CreateContainer": { + "text": "Allocates the storage container that holds this codec's compressed static 2D-vector data. Read from the name; the class CCompressedStaticVector2D is implied by the name, so the container's layout and who owns it are unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::DecodeFrame": { + "text": "Decodes a single frame's worth of values out of the compressed static 2D-vector data into usable vectors. Read from the name; the class CCompressedStaticVector2D is implied by the name, and the exact frame addressing and output form are unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::DecodeSize": { + "text": "Reports the size of the decoded form of the compressed static 2D-vector data, letting a caller size an output buffer before decoding. Read from the name; the class CCompressedStaticVector2D is implied by the name, and the unit the size is expressed in is unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed 2D-vector storage and blends the result with existing values, the variant a caller wants when weighting one source against another rather than overwriting. Read from the name; the class CCompressedStaticVector2D is implied by the name, and the blend semantics are unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::DeswizzleContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed 2D-vector storage back into per-element values, without the blending step its sibling performs. Read from the name; the class CCompressedStaticVector2D is implied by the name, and the packed layout it reverses is unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::GetFieldType": { + "text": "Reports the field-type identifier for the kind of data this codec encodes, which a caller uses to match a codec against a data channel. Read from the name; the class CCompressedStaticVector2D is implied by the name, and the identifier's enumeration is unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::GetFlags": { + "text": "Reports flag bits describing this codec's properties or capabilities, useful when deciding whether it suits a given channel. Read from the name; the class CCompressedStaticVector2D is implied by the name, and the meaning of individual bits is unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::GetName": { + "text": "Returns a name for this codec; purpose beyond that is not established, since the name does not indicate what the returned string identifies or where it is displayed. The class CCompressedStaticVector2D is implied by the name.", + "source": "generated" + }, + "CCompressedStaticVector2D::GetSizeof": { + "text": "Reports the in-memory size of the codec's element or record, useful when striding through or allocating its compressed data. Read from the name; the class CCompressedStaticVector2D is implied by the name, and exactly which object the size describes is unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::Instantiate": { + "text": "Brings a usable instance of this compressed static 2D-vector codec into existence for a caller that has selected it. Read from the name; the class CCompressedStaticVector2D is implied by the name, and what is constructed and where it is placed are unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::~CCompressedStaticVector2D": { + "text": "Destroys the codec object, releasing whatever compressed static 2D-vector storage it holds. Standard destructor behaviour read from the name; the class CCompressedStaticVector2D is implied by the name, and any additional cleanup it performs is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::CanEncode": { + "text": "Tests whether a given block of source data can be represented in this compressed static three-component vector encoding, so a writer can reject a codec that does not fit. Read from the name; the class CCompressedStaticVector3 is implied by the name, and the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::CreateContainer": { + "text": "Allocates the storage container that holds this codec's compressed static three-component vector data. Read from the name; the class CCompressedStaticVector3 is implied by the name, so the container's layout and who owns it are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::DecodeFrame": { + "text": "Decodes a single frame's worth of values out of the compressed static three-component vector data into usable vectors. Read from the name; the class CCompressedStaticVector3 is implied by the name, and the exact frame addressing and output form are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::DecodeSize": { + "text": "Reports the size of the decoded form of the compressed static three-component vector data, letting a caller size an output buffer before decoding. Read from the name; the class CCompressedStaticVector3 is implied by the name, and the unit the size is expressed in is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed three-component vector storage and blends the result with existing values, the variant a caller wants when weighting one source against another rather than overwriting. Read from the name; the class CCompressedStaticVector3 is implied by the name, and the blend semantics are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::DeswizzleContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed three-component vector storage back into per-element values, without the blending step its sibling performs. Read from the name; the class CCompressedStaticVector3 is implied by the name, and the packed layout it reverses is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::GetFieldType": { + "text": "Reports the field-type identifier for the kind of data this codec encodes, which a caller uses to match a codec against a data channel. Read from the name; the class CCompressedStaticVector3 is implied by the name, and the identifier's enumeration is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::GetFlags": { + "text": "Reports flag bits describing this codec's properties or capabilities, useful when deciding whether it suits a given channel. Read from the name; the class CCompressedStaticVector3 is implied by the name, and the meaning of individual bits is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::GetName": { + "text": "Returns a name for this codec; purpose beyond that is not established, since the name does not indicate what the returned string identifies or where it is displayed. The class CCompressedStaticVector3 is implied by the name.", + "source": "generated" + }, + "CCompressedStaticVector3::GetSizeof": { + "text": "Reports the in-memory size of the codec's element or record, useful when striding through or allocating its compressed data. Read from the name; the class CCompressedStaticVector3 is implied by the name, and exactly which object the size describes is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::Instantiate": { + "text": "Brings a usable instance of this compressed static three-component vector codec into existence for a caller that has selected it. Read from the name; the class CCompressedStaticVector3 is implied by the name, and what is constructed and where it is placed are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::~CCompressedStaticVector3": { + "text": "Destroys the codec object, releasing whatever compressed static three-component vector storage it holds. Standard destructor behaviour read from the name; the class CCompressedStaticVector3 is implied by the name, and any additional cleanup it performs is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::CanEncode": { + "text": "Tests whether a given block of four-component vector data can be represented in this compressed static Vector4D encoding, so a compressor can reject unsuitable channels before packing them. Read from the name; the class is implied by the name, and the accept/reject criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::CreateContainer": { + "text": "Allocates the packed container that holds a channel's compressed static Vector4D data. Read from the name, with the class implied by the name; sizing, ownership and lifetime of that storage are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::DecodeFrame": { + "text": "Unpacks one frame's worth of Vector4D values out of the compressed static container into usable form, the read path a sampler would use. The class is implied by the name and the reading comes from the name alone, so frame indexing and destination layout are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::DecodeSize": { + "text": "Reports how large the decoded output of this compressed static Vector4D encoding is, letting a caller size a destination buffer. Read from the name; the class is implied by the name, and exactly what is measured is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::DeswizzleAndBlendContainer": { + "text": "Converts the container's swizzled, component-major packing back into per-element Vector4D values while blending the result into the destination, as when weighting one pose against another. The reading is from the name, the class is implied by the name, and the blend semantics are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::DeswizzleContainer": { + "text": "Converts the container's swizzled, component-major packing back into ordinary per-element Vector4D values, the plain counterpart to CCompressedStaticVector4D::DeswizzleAndBlendContainer. Read from the name; the class is implied by the name, and the exact storage layout is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::GetFieldType": { + "text": "Reports which field type this compressed static Vector4D codec handles, the tag used to match a codec against an animation channel. Read from the name, with the class implied by the name; the type enumeration itself is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::GetFlags": { + "text": "Reports the format or capability flags describing this compressed static Vector4D codec. Read from the name, with the class implied by the name; the individual flag meanings are not established here.", + "source": "generated" + }, + "CCompressedStaticVector4D::GetName": { + "text": "Purpose is not established beyond supplying a name for the object; the class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticVector4D::GetSizeof": { + "text": "Reports the in-memory size of this compressed static Vector4D codec object, useful when allocating or stepping over instances. Read from the name; the class is implied by the name, and exactly what is measured is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::Instantiate": { + "text": "Brings up a live instance of the compressed static Vector4D codec so it can encode or decode animation data. Read from the name, with the class implied by the name; the allocation scheme and any initial state are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::~CCompressedStaticVector4D": { + "text": "Tears down a compressed static Vector4D codec instance, releasing whatever container storage it holds. Destructor behaviour is read from the name and the class is implied by the name, so what it actually frees is unverified.", + "source": "generated" + }, + "CConstraintAnchor::~CConstraintAnchor": { + "text": "Tears down a constraint anchor, the helper that pins a physics constraint to a point on an entity and carries the m_massScale weighting. Destructor behaviour is read from the name and the class is implied by the name; the cleanup performed is unverified.", + "source": "generated" + }, + "CCredits::InputRollCredits": { + "text": "Handles the `RollCredits` entity-IO input on `CCredits`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCredits::InputRollOutroCredits": { + "text": "Handles the `RollOutroCredits` entity-IO input on `CCredits`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCredits::InputSetLogoLength": { + "text": "Handles the `SetLogoLength` entity-IO input on `CCredits`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCredits::InputShowLogo": { + "text": "Handles the `ShowLogo` entity-IO input on `CCredits`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCustomGameEventManager::ScriptSend_ServerToPlayer": { + "text": "Sends a custom game event from the server to one target player, as exposed to script, warning 'Invalid player' when the supplied player does not resolve. Use it to push per-player HUD or UI events from server code.", + "source": "generated" + }, + "CCustomGameEventManager::Script_RegisterListener": { + "text": "Registers a script listener for a named custom game event, reporting 'Registered %s' with the event name on success. Use it when server-side script must receive custom events; registration yields an ID that CCustomGameEventManager::Script_UnregisterListener accepts.", + "source": "generated" + }, + "CCustomGameEventManager::Script_UnregisterListener": { + "text": "Removes a previously registered custom-game-event script listener by its ID, rejecting an unknown one with 'Invalid ID'. Use it to tear down listeners created through CCustomGameEventManager::Script_RegisterListener when the owning script or entity goes away.", + "source": "generated" + }, + "CCvar::ProcessConVar": { + "text": "Handles a console variable inside the engine's cvar system \u2014 resolving it and applying or validating the value carried with it. Read from the name and the engine library it ships in; whether it covers registration, change notification, or command-line application is unverified.", + "source": "generated" + }, + "CDebugOverlayAIEventFilter::FindAllMatchingSnapshots": { + "text": "Collects the recorded debug-overlay snapshots whose AI events satisfy this filter, so the overlay history browser can be narrowed to AI activity. Read from the name, with the class implied by the name; the match criteria and snapshot representation are unverified.", + "source": "generated" + }, + "CDebugOverlayCombinedFilter::FindAllMatchingSnapshots": { + "text": "Collects recorded debug-overlay snapshots matching a filter assembled from several sub-filters, letting a debugger stack criteria in one query. Read from the name, with the class implied by the name; how the sub-filters combine (conjunction versus disjunction) is unverified.", + "source": "generated" + }, + "CDebugOverlayEntityFilter::FindAllMatchingSnapshots": { + "text": "Collects recorded debug-overlay snapshots matching this filter's entity criteria, so overlay history can be narrowed to a single entity. Read from the name, with the class implied by the name; the entity fields matched are unverified.", + "source": "generated" + }, + "CDebugOverlayGrenades::CreateAndBindController": { + "text": "Creates the grenade debug-overlay controller and binds it to its host, standing up grenade trajectory and impact visualisation. Read from the name, with the class implied by the name; what the controller draws and what it binds to are unverified.", + "source": "generated" + }, + "CDebugOverlayPathfindingFilter::FindAllMatchingSnapshots": { + "text": "Collects recorded debug-overlay snapshots matching this filter's pathfinding criteria, for inspecting navigation queries and generated paths after the fact. Read from the name, with the class implied by the name; the criteria are unverified.", + "source": "generated" + }, + "CDebugOverlayScheduleFilter::FindAllMatchingSnapshots": { + "text": "Collects recorded debug-overlay snapshots matching this filter's AI schedule criteria, letting a debugger review which schedules an NPC was running. Read from the name, with the class implied by the name; the schedule fields matched are unverified.", + "source": "generated" + }, + "CDebugOverlayTacticalFilter::FindAllMatchingSnapshots": { + "text": "Collects recorded debug-overlay snapshots matching this filter's tactical criteria \u2014 the AI's cover and positioning decisions \u2014 for the overlay history view. Read from the name, with the class implied by the name; the tactical data matched is unverified.", + "source": "generated" + }, + "CDebugOverlayTaskFilter::FindAllMatchingSnapshots": { + "text": "Collects recorded debug-overlay snapshots matching this filter's AI task criteria, for reviewing individual tasks rather than whole schedules. Read from the name, with the class implied by the name; the task fields matched are unverified.", + "source": "generated" + }, + "CDebugOverlayTextFilter::FindAllMatchingSnapshots": { + "text": "Collects recorded debug-overlay snapshots whose text content matches this filter, a text search over captured overlay messages. Read from the name, with the class implied by the name; the matching rule \u2014 exact, substring, case sensitivity \u2014 is unverified.", + "source": "generated" + }, + "CDecalGameSystem::LoopInit": { + "text": "Performs the decal game system's loop initialisation, standing the system up so decals can be placed and tracked for the session. The system and entry point are named by a string anchor; the initialisation actually performed and its timing are unverified.", + "source": "generated" + }, + "CDecoyProjectile::BounceSound": { + "text": "Plays the bounce sound for a decoy grenade as it strikes a surface. Read from the name, with the class implied by the name; sound selection and the impact conditions that trigger it are unverified.", + "source": "generated" + }, + "CDecoyProjectile::EmitGrenade": { + "text": "Creates and launches the 'decoy_projectile' entity, the decoy grenade whose firing state is held in m_nDecoyShotTick, m_shotsRemaining and m_fExpireTime. Use it to spawn a decoy from server code; the launch inputs and initial velocity handling are unverified.", + "source": "generated" + }, + "CDeltaCalculator::BuildDelta": { + "text": "Computes the delta between two network states, producing the changed-field set the network system sends on the wire. Read from the name and the networking library it ships in; the state representation and delta encoding are unverified.", + "source": "generated" + }, + "CDemoFile::Close": { + "text": "Closes an open demo file, finishing off the recording and releasing the underlying file handle. Read from the name, with the class implied by the name; whether it flushes pending data or writes a trailer is unverified.", + "source": "generated" + }, + "CDestructiblePartsSystemData::CDestructiblePartsSystemData": { + "text": "Constructs the destructible-parts data block holding m_PartsDataByHitGroup and m_nMinMaxNumberHitGroupsToDestroyWhenGibbing, the per-hitgroup part tables and gib threshold a destructible model is driven by. Constructor role is read from the name and the class string anchor; the initial values it sets are unverified.", + "source": "generated" + }, + "CDynamicLight::DynamicLightThink": { + "text": "Runs the periodic update for a dynamic light entity, applying its current state \u2014 m_On, m_Radius, m_LightStyle and the cone angles m_InnerAngle and m_OuterAngle \u2014 to the live light. Read from the name and the class's fields; the update cadence and what it recomputes are unverified.", + "source": "generated" + }, + "CDynamicLight::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CDynamicLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicLight::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CDynamicLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicLight::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CDynamicLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicLight::KeyValue": { + "text": "Applies spawn keyvalues to a light_dynamic entity, filling fields such as m_Exponent, m_Radius and m_LightStyle, and range-checks them \u2014 an out-of-range exponent logs 'light_dynamic at [%d %d %d] has invalid exponent value'. Keep mapper-supplied exponents inside the bounds that message reports.", + "source": "generated" + }, + "CDynamicNavConnectionsVolume::CDynamicNavConnectionsVolume": { + "text": "Constructs a CDynamicNavConnectionsVolume, the volume entity that stitches navigation areas together at runtime; m_iszConnectionTarget, m_bConnectionsEnabled, m_flTargetAreaSearchRadius and m_flMaxConnectionDistance control which areas it links and how far it reaches. Read from the name and those fields, so what the constructor itself initialises is unverified.", + "source": "generated" + }, + "CDynamicProp::GetDataDescMap": { + "text": "Exposes the entity data-description map for dynamic props, the table naming their keyvalues, inputs and outputs for map I/O and save/restore. The class is implied by the name rather than the data, and the slot is unbound, so which map it hands over is unverified.", + "source": "generated" + }, + "CDynamicProp::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputDisableCollision": { + "text": "Handles the `DisableCollision` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputEnableCollision": { + "text": "Handles the `EnableCollision` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimation": { + "text": "Handles the `SetAnimation` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationLooping": { + "text": "Handles the `SetAnimationLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationNoReset": { + "text": "Handles the `SetAnimationNoReset` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationNoResetLooping": { + "text": "Handles the `SetAnimationNoResetLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationNoResetNotLooping": { + "text": "Handles the `SetAnimationNoResetNotLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationNotLooping": { + "text": "Handles the `SetAnimationNotLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetDefaultAnimationLooping": { + "text": "Handles the `SetDefaultAnimationLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetGlowOverride": { + "text": "Handles the `SetGlowOverride` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetGlowRange": { + "text": "Handles the `SetGlowRange` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetIdleAnimation": { + "text": "Handles the `SetDefaultAnimation` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetIdleAnimationLooping": { + "text": "Handles the `SetIdleAnimationLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetPlaybackRate": { + "text": "Handles the `SetPlaybackRate` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputStartGlowing": { + "text": "Handles the `StartGlowing` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputStopGlowing": { + "text": "Handles the `StopGlowing` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEconItem::BAddToMessage": { + "text": "Packs an econ item's state into an outgoing message so the item can be carried across the wire. The class is implied by the name; the slot is unbound and the message type and encoding are unverified.", + "source": "generated" + }, + "CEconItem::DeserializeFromProtoBufItem": { + "text": "Rebuilds an econ item's state from a serialized protobuf item payload, the form in which inventory items arrive. The anchor string DeserializeFromProtoBufItem matches the name; which protobuf message it consumes and which fields it fills are unverified.", + "source": "generated" + }, + "CEconItemAttributeDefinition::GetDefinitionIndex": { + "text": "Yields the numeric definition index identifying this attribute definition inside the item schema, the id used to reference attributes instead of matching names. The class is implied by the name, not the data, though a prototype is derived.", + "source": "generated" + }, + "CEconItemSchema::BInitAchievementRewards": { + "text": "Parses the schema's achievement-reward block, failing with 'Complex achievement %s must have an Items key or a DefIndex field' when a complex achievement declares neither. This is where achievements become bound to the items they grant; further parse detail is unverified.", + "source": "generated" + }, + "CEconItemSchema::BInitAttributes": { + "text": "Builds the item schema's attribute definition table, rejecting entries whose index is negative with 'Attribute definition index %d must be greater than or equal to zero'. This is where the attribute definitions the rest of the econ system references come into being; other validation it performs is unverified.", + "source": "generated" + }, + "CEconItemSchema::BInitEquipRegionConflicts": { + "text": "Resolves which equip regions conflict with one another, erroring with 'Unable to find other equip region named \"%s\" for conflicts.' when a referenced region cannot be found. Equip-region conflicts decide which items may be equipped at once; the schema keys parsed are unverified.", + "source": "generated" + }, + "CEconItemSchema::BInitEquipRegions": { + "text": "Registers the schema's equip regions, rejecting a second region that reuses a name with 'Duplicate equip region named \"%s\".'. Equip regions are the coverage slots that conflicts are declared against; the per-region keys it reads are unverified.", + "source": "generated" + }, + "CEconItemSchema::BInitItemLevels": { + "text": "Loads the schema's named item-leveling data blocks, refusing a repeated name with 'Duplicate leveling data block named \"%s\".'. These blocks supply the per-level naming an item displays; nothing beyond that duplicate check is established here.", + "source": "generated" + }, + "CEconItemSchema::BInitQualities": { + "text": "Builds the item quality table from the schema, treating 'any' as a reserved keyword and rejecting a quality definition that uses it. Qualities are the grade tags an item carries, such as the value held in m_iEntityQuality on CEconItemView.", + "source": "generated" + }, + "CEconItemSchema::BInitQuestRewardLootLists": { + "text": "Registers quest-reward loot lists keyed by index and name, refusing an addition with 'Quest reward lootlist %d '%s' already exists, cannot add '%s'.'. Confidence is low; beyond that duplicate guard, the contents and parsing of a quest reward loot list are unverified.", + "source": "generated" + }, + "CEconItemSchema::BInitRecipes": { + "text": "Builds the schema's recipe definitions and rejects any whose index is negative, per 'Recipe definition index %d must be greater than or equal to zero'. Recipes describe crafting-style input and output rules; what else it validates is unverified.", + "source": "generated" + }, + "CEconItemSchema::BInitRevolvingLootLists": { + "text": "Registers revolving loot lists, the numbered rotating lists the schema indexes by id, refusing a clash with 'Revolving lootlist %d '%s' already exists, cannot add '%s'.'. Confidence is low: what such a list holds beyond an index and a name is not established.", + "source": "generated" + }, + "CEconItemSchema::BInitSchema": { + "text": "Drives the top-level econ schema load, walking sections of the schema document such as attribute_controlled_attached_particles. This is the point at which schema text becomes the server's runtime item tables; which sections it covers overall is unverified.", + "source": "generated" + }, + "CEconItemSchema::BInitSoundMaterials": { + "text": "Builds the schema's sound-material table, rejecting a second entry that reuses a value with 'Duplicate sound material value (%d)'. Sound materials tie items to their sound sets; the keys parsed per material are unverified.", + "source": "generated" + }, + "CEconItemSchema::BInitStickerKits": { + "text": "Loads sticker kit definitions from the schema, including validation of tournament gold stickers per event, team and player: 'Sticker kit name '%s' is a duplicate gold sticker for event %d team %d player %d with a decreasing ID'. Confidence is low and the rest of its parsing is unverified.", + "source": "generated" + }, + "CEconItemSchema::GetItemDefinition": { + "text": "Looks up an item definition in the schema by its numeric definition index, the id stored in m_iItemDefinitionIndex on CEconItemView. A prototype is derived, so resolving an index to its definition data is solid ground when reading item state.", + "source": "generated" + }, + "CEconItemSchema::GetItemDefinitionByName": { + "text": "Resolves an item definition from its schema name string rather than its numeric index, handy when item choices come from configuration text. A prototype is derived; how names are matched, including case and aliases, is unverified.", + "source": "generated" + }, + "CEconItemView::CEconItemView": { + "text": "Constructs a CEconItemView, the server-side view of one econ item instance carrying m_iItemDefinitionIndex, m_iEntityQuality, m_iAccountID, m_AttributeList and m_szCustomName. Use it when building an item to attach to a weapon or loadout slot; the initial values it writes are unverified.", + "source": "generated" + }, + "CEconItemView::operator=": { + "text": "Assigns one item view's contents onto another, overwriting fields including m_iItemDefinitionIndex, m_iItemID, m_AttributeList and m_NetworkedDynamicAttributes. Convenient for cloning an item's definition and attribute payload; whether the CAttributeList data is deep-copied is unverified.", + "source": "generated" + }, + "CEconLootListDefinition::~CEconLootListDefinition": { + "text": "Tears down a loot list definition and releases whatever storage its entries hold. The class is implied by the name rather than the data, and with the slot unbound the destructor variant cannot be distinguished here.", + "source": "generated" + }, + "CEngineAPI::MainLoop": { + "text": "Runs the engine's outer main loop in libengine2, the pump that keeps the process ticking until shutdown. Read from the name; confidence is low and the loop's stages and exit conditions are unverified.", + "source": "generated" + }, + "CEngineServer::ClientCommand": { + "text": "Issues a console command on a specific connected client from the server side, the mechanism behind server-driven client commands. The class is implied by the name; the slot is unbound and any formatting or filtering it applies is unverified.", + "source": "generated" + }, + "CEngineServer::GetClientConVarValue": { + "text": "Reads the value a connected client reports for a named convar, the query behind server-side checks of client settings. The class is implied by the name, not the data, though a prototype is derived.", + "source": "generated" + }, + "CEngineServer::SetClientUpdateRate": { + "text": "Sets how frequently the server sends updates to one particular client, overriding that client's rate. The class is implied by the name; the slot is unbound, and the units and any clamping are unverified.", + "source": "generated" + }, + "CEngineServer::SetFakeClientConVarValue": { + "text": "Sets a convar value on a fake client (a bot) as though the bot had set it itself, which is how bot-side settings get configured from the server. The class is implied by the name; a prototype is derived but the slot is unbound.", + "source": "generated" + }, + "CEngineServiceMgr::SleepAfterMainLoop": { + "text": "Sleeps once a main-loop iteration has finished, the throttle that keeps a dedicated server from spinning a core flat out. Read from the name in libengine2; the sleep duration and where it comes from are unverified.", + "source": "generated" + }, + "CEngineServiceMgr::SwitchToLoop": { + "text": "Switches the engine service manager onto a different named loop, the mechanism for moving between engine modes such as loading and running a session. The class is implied by the name; a prototype is derived, but the loop names it accepts are unverified.", + "source": "generated" + }, + "CEngineServiceMgr::_MainLoop": { + "text": "Runs the engine service manager's own main loop, keeping registered engine services ticking while the process lives. Read from the name in libengine2; what a single iteration performs is unverified.", + "source": "generated" + }, + "CEngineTrace::TraceRotatedBody": { + "text": "Traces an oriented (rotated) collision body through the world rather than an axis-aligned box, so a sweep respects the body's rotation. Read from the name and the matching TraceRotatedBody anchor; confidence is low, and the trace inputs and filtering are unverified.", + "source": "generated" + }, + "CEngineTrace::TraceShape": { + "text": "Sweeps a collision shape against the world on the server, profiled under the label Physics/TraceShape (Server). It also ships under the bare name TraceShape, the same function; the shape kinds and filters it accepts are unverified.", + "source": "generated" + }, + "CEntity2SaveRestore::AppendTransitionResources": { + "text": "Adds the resources that must carry across a level transition to the save's resource list. The CEntity2SaveRestore class is implied by the name rather than the data, and no prototype is derived, so which resources are gathered and where they are stored is unverified.", + "source": "generated" + }, + "CEntity2SaveRestore::BeginRestoreEntities": { + "text": "Opens a restore pass over saved entities, logging a `BeginRestoreEntities( %s%s )` line that names what is being restored. That anchor is the useful trace point when diagnosing why entities do or do not come back on a load; the inputs it takes are unverified.", + "source": "generated" + }, + "CEntity2SaveRestore::ClearSaveFile": { + "text": "Discards a save file, logging `async CEntity2SaveRestore::ClearSaveFile(%s)` with the file named and the work marked asynchronous. Read from that anchor and the name; what makes a file eligible for clearing is not established here.", + "source": "generated" + }, + "CEntity2SaveRestore::DirectoryCopy": { + "text": "Copies save data between directories, logging a `WRITE %s in CEntity2SaveRestore::DirectoryCopy` line for the file it writes. Useful when tracking how save files are duplicated around a transition; the source and destination selection is not established here.", + "source": "generated" + }, + "CEntity2SaveRestore::DispatchAsyncSave": { + "text": "Hands a pending save off to be written asynchronously, logging a `CEntity2SaveRestore::DispatchAsyncSave` line as it does. Read from that anchor and the name; the payload handed over and how completion is reported are unverified.", + "source": "generated" + }, + "CEntity2SaveRestore::EntityDataWrite": { + "text": "Writes entity data into a save, with its anchor `EntityDataWrite: kv3 using %s` showing the payload is serialized as KV3. Handy when working out what a save actually records per entity; which entities and fields are included is not established here.", + "source": "generated" + }, + "CEntity2SaveRestore::EntityPatchRead": { + "text": "Reads an entity patch record out of a save, logging `EntityPatchRead( %s ) read %d entries` with the source and the entry count. The count in that anchor is a quick check on whether patch data was found; the record's contents are unverified.", + "source": "generated" + }, + "CEntity2SaveRestore::EntityPatchWrite": { + "text": "Writes an entity patch record into a save, logging `EntityPatchWrite( %s ) wrote %d entries` with the target and the number of entries written. Pairs with the read side for confirming patch data round-trips; the entry format is not established here.", + "source": "generated" + }, + "CEntity2SaveRestore::ExecuteSave": { + "text": "Carries out the save itself and times it, logging `ExecuteSave( %s ) took %f msec`. That timing line makes this the natural place to measure save cost; the anchor establishes the timed operation but not what gets written.", + "source": "generated" + }, + "CEntity2SaveRestore::LoadAdjacentEnts": { + "text": "Loads entities brought in from an adjacent level so they exist on the other side of a transition. The CEntity2SaveRestore class is implied by the name rather than the data, and no prototype is derived, so the adjacency rules and entity selection are unverified.", + "source": "generated" + }, + "CEntity2SaveRestore::OpenSaveFileAndExtractLevels": { + "text": "Opens a save file and pulls out the set of levels it holds, logging a `READ %s in CEntity2SaveRestore::OpenSaveFileAndExtractLevels` line for the file it reads. Useful for understanding how a save's levels are discovered before a restore; the file layout is not established here.", + "source": "generated" + }, + "CEntity2SaveRestore::SaveGame_Finalize": { + "text": "Finishes a save-game operation, and for a transition logs `transition %s, not making .sav file` \u2014 a finalize can deliberately skip writing a .sav. Worth knowing when an expected save file never appears on disk; the remaining finalize work is not established here.", + "source": "generated" + }, + "CEntity2SaveRestore::SaveGame_Start": { + "text": "Begins a save-game operation, queuing an `AgeSaveList()` step as its anchor records. Read from that anchor and the name; what game state is captured at this point is unverified.", + "source": "generated" + }, + "CEntity2SaveRestore::SetMostRecentElapsedTime": { + "text": "Stores the most recent elapsed-time value associated with a save, logging it under the `ET:` tag with the name and a numeric value. Read from that anchor and the name; the units and what later consumes the value are unverified.", + "source": "generated" + }, + "CEntity2SaveRestore::StartNewRestore": { + "text": "Starts a fresh restore operation, emitting a `StartNewRestore` log line. The anchor confirms it as a distinct step in the restore path; what state it initializes or clears is not established here.", + "source": "generated" + }, + "CEntity2SaveRestore::StreamEntitiesFromFile": { + "text": "Streams entities out of a save file, logging `StreamEntitiesFromFile: '%s' [%d entities]` with the file name and how many entities it yielded. That count is the practical signal when diagnosing an incomplete restore; the streaming format is unverified.", + "source": "generated" + }, + "CEntityClass::Unserialize": { + "text": "Deserializes an entity class definition, logging `CEntityClass::Unserialize( %d:%s:%s )` with an index and two name strings. The binary also ships this same function as FindUseEntity, so both names resolve to one address \u2014 a hook on either is a hook on both.", + "source": "generated" + }, + "CEntityComponentHelperT::Allocate": { + "text": "Allocates a CBodyComponentPoint body component for an entity through the component-helper template, the point-only body variant used by entities with no skeleton. Read from the name; no string anchor or prototype is derived, so the allocation source and any initialization are unverified.", + "source": "generated" + }, + "CEntityComponentHelperT::Allocate": { + "text": "Allocates a CBodyComponentSkeletonInstance body component for an entity through the component-helper template, the skeleton-bearing body variant used by animated models. Read from the name; no string anchor or prototype is derived, so the allocation source and any initialization are unverified.", + "source": "generated" + }, + "CEntityDataInstantiator::DestroyDataObject": { + "text": "Tears down the per-entity CWatcherList data object this instantiator created and releases its storage. Read from the name; the data is silent on what triggers the destruction and what the watcher list holds.", + "source": "generated" + }, + "CEntityDataInstantiator::DestroyDataObject": { + "text": "Tears down the per-entity groundlink_t data object this instantiator created \u2014 the ground-contact link record \u2014 and releases its storage. Read from the name; what triggers the destruction and the record's contents are unverified.", + "source": "generated" + }, + "CEntityDataInstantiator::DestroyDataObject": { + "text": "Tears down the per-entity physicspushlist_t data object this instantiator created, the record tracking entities being pushed by a physics mover, and releases its storage. Read from the name; the trigger for destruction and the record's contents are unverified.", + "source": "generated" + }, + "CEntityDissolve::GetDataDescMap": { + "text": "Supplies the datadesc map describing the dissolve entity's saved and keyvalue fields, covering the timing and appearance data such as m_flStartTime, m_nDissolveType, m_vDissolverOrigin and m_nMagnitude. The CEntityDissolve class is implied by the name rather than the data, though a prototype is derived for this entry.", + "source": "generated" + }, + "CEntityDissolve::InputDissolve": { + "text": "Handles the `Dissolve` entity-IO input on `CEntityDissolve`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEntityFlame::FlameThink": { + "text": "Runs the burning entity's periodic think, advancing the flame against m_flLifetime and applying m_flDirectDamagePerSecond to the attached victim in m_hEntAttached. Read from the name and the class's fields; the tick interval and the exact damage application are unverified.", + "source": "generated" + }, + "CEntityFlame::GetDataDescMap": { + "text": "Supplies the datadesc map describing the flame entity's saved and keyvalue fields, covering burn data such as m_hEntAttached, m_flSize, m_flLifetime and m_flDirectDamagePerSecond. The CEntityFlame class is implied by the name rather than the data, though a prototype is derived for this entry.", + "source": "generated" + }, + "CEntityIOOutput::FireOutput": { + "text": "Fires an entity I/O output so the inputs wired to it receive the value \u2014 the mechanism behind map-authored entity links. A prototype is derived, making this a solid hook point for observing or filtering output traffic; the activator, caller and delay semantics are not established here.", + "source": "generated" + }, + "CEntityIdentity::AcceptInput": { + "text": "Delivers a named input to the entity this identity belongs to, the entry point for driving entity inputs from code or from map I/O. A prototype is derived and the string anchor outputid sits with it; the neighbouring m_name and m_designerName fields identify the receiving entity.", + "source": "generated" + }, + "CEntityInstance::AcceptInput": { + "text": "Delivers a named entity-I/O input to the instance, the same kind of input a map trigger or another entity's output produces, so the entity reacts to it. Also shipped as CBaseEntity::AcceptInput, one function under both names; the roles of the individual arguments are a name-level reading.", + "source": "generated" + }, + "CEntityInstance::GetDynamicBinding": { + "text": "Returns the entity's dynamic binding \u2014 the runtime-resolved binding record the engine keeps for this instance. The CEntityInstance class here is implied by the name rather than established by the data, and what the binding object holds is unverified.", + "source": "generated" + }, + "CEntityInstance::GetEntityIndex": { + "text": "Returns the entity's index, the numeric slot that identifies it in the entity list and that index-based lookups take. Read from the name; the exact form and validity rules of the index are not established here.", + "source": "generated" + }, + "CEntityInstance::GetOrCreatePrivateScriptScope": { + "text": "Returns the entity's private VScript scope, creating it when the entity does not have one yet, giving script code a per-entity table other scopes are not meant to reach. Pairs with the m_iszPrivateVScripts and m_CScriptComponent fields; the create-on-miss reading comes from the name.", + "source": "generated" + }, + "CEntityInstance::GetOrCreatePublicScriptScope": { + "text": "Returns the entity's public VScript scope, creating it when absent, so scripts can publish state that other script code reads. Also shipped as ScriptGetOrCreatePublicScriptScope, one function under both names; the m_CScriptComponent field holds the entity's script component.", + "source": "generated" + }, + "CEntityInstance::GetRefEHandle": { + "text": "Returns the entity's reference handle, the serial-tagged reference that stays safe to hold after the entity is gone, unlike a raw pointer. Also shipped as ScriptGetEHandle, so script and native callers get the handle from one function; the handle's layout is not established here.", + "source": "generated" + }, + "CEntityInstance::Kill": { + "text": "Destroys the entity, marking it for removal from the entity system \u2014 the native equivalent of firing a kill input at it. Read from the name; whether removal happens immediately or is deferred is not established by this data.", + "source": "generated" + }, + "CEntityInstance::Spawn": { + "text": "Performs the entity's spawn-time initialisation, the point at which a freshly created entity becomes live in the world with its keyvalues applied. The class is implied by the name rather than established by the data, so the per-class work done here is a name-level reading.", + "source": "generated" + }, + "CEntityKeyValues::AddConnectionDesc": { + "text": "Adds an entity-I/O connection description to a keyvalues block, the output-to-input wiring that normally comes from a map's entity lump. Use it when assembling an entity's connections in code; the fields making up a connection description are not established here.", + "source": "generated" + }, + "CEntityKeyValues::FindKeyValues": { + "text": "Looks up a named entry in the keyvalues block and returns the existing one, so callers can read a value already set on the entity. Read from the name; how a miss is reported and how the key is specified are unverified.", + "source": "generated" + }, + "CEntityKeyValues::FindOrCreateKeyValues": { + "text": "Looks up a named entry in the keyvalues block and creates it when it is absent, so a caller can write a value without checking first. The create-on-miss reading comes from the name; CEntityKeyValues::FindKeyValues is the name-level lookup-only counterpart.", + "source": "generated" + }, + "CEntityKeyValues::LoadFromContext": { + "text": "Reads a serialised entity keyvalues block from a load context and checks a version stamp, reporting 'Invalid version! Expected %d, encountered %d!' when the stamp does not match. That anchor establishes versioned deserialisation; the context's source and the on-disk format are not established here.", + "source": "generated" + }, + "CEntityKeyValues::RemoveKeyValues": { + "text": "Removes a named entry from the keyvalues block, dropping a value previously set on the entity. Read from the name; whether removing an absent key is harmless or an error is not established.", + "source": "generated" + }, + "CEntityKeyValues::SetString": { + "text": "Stores a string value under a named key in the keyvalues block, the same assignment a map file's keyvalue pair produces for an entity. Read from the name; whether an existing entry is overwritten or a duplicate is added is unverified.", + "source": "generated" + }, + "CEntityLumpRequest::Start": { + "text": "Begins loading a named entity lump \u2014 the map's block of entity keyvalues \u2014 and logs 'LOAD START' with the lump name as it does. The anchor establishes that it starts a named lump load; whether the load continues asynchronously afterwards is not established.", + "source": "generated" + }, + "CEntityReport::Add": { + "text": "Records an entity being added into the report's per-entity accounting. The CEntityReport class is implied by the name rather than established by the data; what the report accumulates and where it is surfaced are name-level readings.", + "source": "generated" + }, + "CEntityReport::DeleteEntity": { + "text": "Notes an entity's deletion in the report so its accounting keeps step with entities disappearing from the world. The class is implied by the name rather than established by the data, and what the report stores per entity is unverified.", + "source": "generated" + }, + "CEntityReport::LeavePVS": { + "text": "Records that an entity left a client's PVS, the visibility set that governs whether the entity keeps being networked to that client. The class is implied by the name rather than established by the data; the report's consumer is unverified.", + "source": "generated" + }, + "CEntityReport::NetworkPacketFinished": { + "text": "Closes out the report's accounting for one network packet, the boundary at which per-packet entity statistics are complete. The class is implied by the name rather than established by the data, so the statistics kept are a name-level reading.", + "source": "generated" + }, + "CEntityReport::Record": { + "text": "Records an entity event into the report, the general-purpose entry point for the entity traffic statistics it accumulates. The class is implied by the name rather than established by the data, and the contents of a record are unverified.", + "source": "generated" + }, + "CEntityReport::~CEntityReport": { + "text": "Destroys the report object and releases what it accumulated. Beyond destructor cleanup no purpose is established, and the class is implied by the name rather than by the data.", + "source": "generated" + }, + "CEntityResourceManifest::AddResource": { + "text": "Adds a resource to an entity resource manifest, the list of assets an entity's class needs loaded before it can be used. The class is implied by the name rather than established by the data; how a resource is identified is not established here.", + "source": "generated" + }, + "CEntityResourceManifest::AddResourceInternal": { + "text": "Adds a resource to the entity resource manifest through the manifest's internal path, and lives in libengine2 rather than the server library. Read from the name; how it differs from CEntityResourceManifest::AddResource is not established by this data.", + "source": "generated" + }, + "CEntitySaveRestoreBlockHandler::PreSave": { + "text": "Runs the pre-save pass over the save/restore block's entities and warns 'entity identity is missing, may cause a crash' when an entity has no CEntityIdentity. The anchor establishes save-time entity validation; what the block eventually writes is not established here.", + "source": "generated" + }, + "CEntityScriptFramework::DispatchActivate": { + "text": "Delivers the activate notification to an entity's script code, the hook a script uses to do setup once its entity is active. The only anchor is the bare string 'DispatchActivate', which confirms the name and nothing more, so the hook's contract is unverified.", + "source": "generated" + }, + "CEntityScriptFramework::DispatchInput": { + "text": "Delivers an entity-I/O input to an entity's script code so a script can handle inputs aimed at its entity. The only anchor is the bare string 'DispatchInput', confirming the name alone; how the input and its value reach the script side is unverified.", + "source": "generated" + }, + "CEntityScriptFramework::DispatchUpdateOnRemove": { + "text": "Delivers the UpdateOnRemove notification to an entity's script code, the teardown hook a script uses to clean up as its entity goes away. The only anchor is the bare string 'DispatchUpdateOnRemove'; the timing relative to actual destruction is not established.", + "source": "generated" + }, + "CEntitySubclassGameSystem::LoadSubclasses": { + "text": "Loads the entity subclass definitions the game system holds \u2014 the named data-driven variants that let one entity class ship several configurations. The only anchor is the bare string 'LoadSubclasses', so the source of the definitions and when they load are name-level readings.", + "source": "generated" + }, + "CEntitySubclassGameSystem::ParseVDataFile": { + "text": "Parses a VData file, Source 2's data-driven entity definition format, into the subclass data the game system keeps. The only anchor is the bare string 'ParseVDataFile'; which files are read and how parse errors surface are not established here.", + "source": "generated" + }, + "CEntitySubclassVDataBase::CEntitySubclassVDataBase": { + "text": "Constructs the base VData object that entity subclass definitions build on, setting up its initial state. Beyond construction no purpose is established by this data.", + "source": "generated" + }, + "CEntitySystem::PrecacheEntity": { + "text": "Precaches the assets an entity's class needs and reports 'Classname missing from entity!' when the entity has no classname to precache from. The anchor establishes classname-driven precaching; which resources are pulled in and when is not established here.", + "source": "generated" + }, + "CEntitySystem::RegisterAliasEntityClass": { + "text": "Registers an alternate classname for an entity class so a map spawning the alias gets the same implementation \u2014 how legacy or renamed classnames keep working. The only anchor is the bare string 'RegisterAliasEntityClass', confirming the name; what the registration record holds is unverified.", + "source": "generated" + }, + "CEntitySystem::RegisterComponentType": { + "text": "Registers an entity component type with the entity system so components of that type can be created and attached to entities. The only anchor is the bare string 'RegisterComponentType'; CEntityComponentHelper is among the classes this batch's parameters reference, but the registration's contents are unverified.", + "source": "generated" + }, + "CEntitySystem::RegisterEntityClass": { + "text": "Registers an entity class with the entity system, binding a classname to the code that creates and runs entities of that type. The only anchor is the bare string 'RegisterEntityClass'; CEntitySystem::RegisterAliasEntityClass is, by name, the variant that adds an alternate classname.", + "source": "generated" + }, + "CEnvBeam::InputStrikeOnce": { + "text": "Handles the `StrikeOnce` entity-IO input on `CEnvBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvBeam::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CEnvBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvBeam::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CEnvBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvBeam::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CEnvBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvBeverage::InputActivate": { + "text": "Handles the `Activate` entity-IO input on `CEnvBeverage`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvCombinedLightProbeVolume::CEnvCombinedLightProbeVolume": { + "text": "Constructs the light-probe volume entity that the anchor string `CEnvCombinedLightProbeVolumeAlias_func_combined_light_probe_volume` ties to that map class, bringing up its cubemap and light-probe texture handles, volume bounds (m_Entity_vBoxMins, m_Entity_vBoxMaxs) and m_Entity_bStartDisabled. Which defaults the constructor actually writes is not established by this data.", + "source": "generated" + }, + "CEnvCubemapFog::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CEnvCubemapFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvCubemapFog::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvCubemapFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvEntityIgniter::InputIgnite": { + "text": "Handles the `Ignite` entity-IO input on `CEnvEntityIgniter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvEntityMaker::CheckSpawnThink": { + "text": "Think routine that tests whether the entity maker may spawn its template (m_iszTemplate), weighing the tracked instance and blocker handles (m_hCurrentInstance, m_hCurrentBlocker) against the template bounds m_vecEntityMins and m_vecEntityMaxs. Read from the name and those fields; the exact blocking test and think interval are unverified.", + "source": "generated" + }, + "CEnvEntityMaker::InputForceSpawn": { + "text": "Handles the `ForceSpawn` entity-IO input on `CEnvEntityMaker`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvEntityMaker::InputForceSpawnAtEntityOrigin": { + "text": "Handles the `ForceSpawnAtEntityOrigin` entity-IO input on `CEnvEntityMaker`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvExplosion::DrawDebugTextOverlays": { + "text": "Prints this explosion entity's debug text overlay; the anchored format string ` magnitude: %i` shows the configured blast magnitude (m_iMagnitude) is among the lines emitted. Handy for confirming radius, damage and ignore settings on a placed explosion while debug overlays are on.", + "source": "generated" + }, + "CEnvExplosion::InputExplode": { + "text": "Handles the `Explode` entity-IO input on `CEnvExplosion`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvFade::DrawDebugTextOverlays": { + "text": "Prints the fade entity's debug text overlay; the anchored format string ` hold time: %f` shows m_HoldDuration is among the values written, alongside m_Duration and m_fadeColor. Use it to verify a screen fade's timing against what the entity really holds.", + "source": "generated" + }, + "CEnvFade::InputFade": { + "text": "Handles the `Fade` entity-IO input on `CEnvFade`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::DrawDebugTextOverlays": { + "text": "Prints the global-state entity's debug text overlay; the anchor `Value: DEAD` shows it reports the current state of m_globalstate in readable form, with m_counter and m_initialstate also carried on the class. Useful for inspecting persistent global state while debugging a map.", + "source": "generated" + }, + "CEnvGlobal::InputAddToCounter": { + "text": "Handles the `AddToCounter` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputGetCounter": { + "text": "Handles the `GetCounter` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputRemove": { + "text": "Handles the `Remove` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputSetCounter": { + "text": "Handles the `SetCounter` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvInstructorHint::InputEndHint": { + "text": "Handles the `EndHint` entity-IO input on `CEnvInstructorHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvInstructorHint::InputShowHint": { + "text": "Handles the `ShowHint` entity-IO input on `CEnvInstructorHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvInstructorVRHint::InputEndHint": { + "text": "Handles the `EndHint` entity-IO input on `CEnvInstructorVRHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvInstructorVRHint::InputShowHint": { + "text": "Handles the `ShowHint` entity-IO input on `CEnvInstructorVRHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvLaser::GetDataDescMap": { + "text": "Supplies the datadesc field map describing the laser's saved and keyvalue fields, among them m_iszLaserTarget, m_iszSpriteName and m_firePosition. The owning class is implied by the name, not by the data, since the vtable slot is unbound.", + "source": "generated" + }, + "CEnvLaser::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CEnvLaser`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvLaser::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CEnvLaser`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvLaser::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CEnvLaser`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvLaser::StrikeThink": { + "text": "Think routine that updates the laser beam for the current strike, working between m_firePosition and the entity named by m_iszLaserTarget and driving the sprite in m_pSprite. Read from the name and those fields; the damage applied and the striking cadence are unverified.", + "source": "generated" + }, + "CEnvMuzzleFlash::InputFire": { + "text": "Handles the `Fire` entity-IO input on `CEnvMuzzleFlash`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvParticleGlow::InputSetAlphaScale": { + "text": "Handles the `setalphascale` entity-IO input on `CEnvParticleGlow`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvParticleGlow::InputSetColorTint": { + "text": "Handles the `setcolortint` entity-IO input on `CEnvParticleGlow`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvParticleGlow::InputSetScale": { + "text": "Handles the `setscale` entity-IO input on `CEnvParticleGlow`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvShake::DrawDebugTextOverlays": { + "text": "Prints the shake entity's debug text overlay; the anchored format string ` frequency: %f` shows m_Frequency is among the values written, with m_Amplitude, m_Duration and m_Radius also configured on the class. Useful for checking a screen shake's tuning in-game.", + "source": "generated" + }, + "CEnvShake::InputAmplitude": { + "text": "Handles the `Amplitude` entity-IO input on `CEnvShake`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvShake::InputFrequency": { + "text": "Handles the `Frequency` entity-IO input on `CEnvShake`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvShake::InputStartShake": { + "text": "Handles the `StartShake` entity-IO input on `CEnvShake`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvShake::InputStopShake": { + "text": "Handles the `StopShake` entity-IO input on `CEnvShake`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSoundscape::CEnvSoundscape": { + "text": "Constructs the soundscape entity, bringing up its playback state \u2014 m_soundscapeName, m_soundEventName, m_flRadius, the m_positionNames array and m_bDisabled. Read from the name and those fields; the specific defaults written at construction are unverified.", + "source": "generated" + }, + "CEnvSoundscape::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CEnvSoundscape`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSoundscape::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvSoundscape`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSoundscape::InputToggleEnabled": { + "text": "Handles the `ToggleEnabled` entity-IO input on `CEnvSoundscape`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSoundscapeProxy::CEnvSoundscapeProxy": { + "text": "Constructs the soundscape proxy, whose one field m_MainSoundscapeName points at the soundscape it mirrors. Read from the name and that field; what the constructor initialises is unverified.", + "source": "generated" + }, + "CEnvSoundscapeTriggerable::CEnvSoundscapeTriggerable": { + "text": "Constructs the triggerable soundscape entity, a soundscape variant that carries no schema fields of its own and works from inherited soundscape state. Read from the name; what the constructor initialises is not established by this data.", + "source": "generated" + }, + "CEnvSpark::InputSparkOnce": { + "text": "Handles the `SparkOnce` entity-IO input on `CEnvSpark`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSpark::InputStartSpark": { + "text": "Handles the `StartSpark` entity-IO input on `CEnvSpark`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSpark::InputStopSpark": { + "text": "Handles the `StopSpark` entity-IO input on `CEnvSpark`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSpark::InputToggleSpark": { + "text": "Handles the `ToggleSpark` entity-IO input on `CEnvSpark`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSpark::SparkThink": { + "text": "Think routine that produces the entity's spark effect from its configured m_nMagnitude, m_nTrailLength and m_nType, with m_flDelay governing the gap between sparks and m_OnSpark available as its output. Read from the name and those fields; the effect detail and timing are unverified.", + "source": "generated" + }, + "CEnvTilt::DrawDebugTextOverlays": { + "text": "Prints the tilt entity's debug text overlay, exposing its configured m_Duration, m_Radius and m_TiltTime plus the running m_stopTime. The owning class is implied by the name; the slot is unbound and no anchor pins the exact lines printed.", + "source": "generated" + }, + "CEnvTilt::InputStartTilt": { + "text": "Handles the `StartTilt` entity-IO input on `CEnvTilt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvTilt::InputStopTilt": { + "text": "Handles the `StopTilt` entity-IO input on `CEnvTilt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvViewPunch::InputViewPunch": { + "text": "Handles the `ViewPunch` entity-IO input on `CEnvViewPunch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputSetAnisotropy": { + "text": "Handles the `SetAnisotropy` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputSetDrawDistance": { + "text": "Handles the `SetDrawDistance` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputSetScattering": { + "text": "Handles the `SetFogStrength` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputSetToDefaults": { + "text": "Handles the `SetToDefaults` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogVolume::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvVolumetricFogVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvWindVolume::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvWindVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEventQueue_SaveRestoreBlockHandler::GetBlockName": { + "text": "Supplies the identifying block name under which this handler's event-queue data is written to and found in a save file. The owning class is implied by the name; the actual string it yields is not established by this data.", + "source": "generated" + }, + "CExplosionTypeData::CExplosionTypeData": { + "text": "Constructs an explosion-type data record \u2014 the anchor `CExplosionTypeData` names the type \u2014 holding the sound and particle to play (m_SoundName, m_ParticleEffect), m_DecalType, and the m_bIsIncindiary and m_bHasForces flags. Useful when reading or overriding per-explosion presentation data.", + "source": "generated" + }, + "CFieldPath::Path_AddToTail": { + "text": "Appends one element to the end of a field path's list of path components. Read from the name; the element type and how the list grows are unverified, and the class carries no schema fields.", + "source": "generated" + }, + "CFieldPath::SetCount": { + "text": "Sets how many components a field path holds, sizing its element list to that count. Read from the name; whether existing entries are preserved, cleared or default-filled is unverified.", + "source": "generated" + }, + "CFieldPathHuffmanEncoder::InternalNode::IsLeafNode": { + "text": "Answers the shared leaf test for an interior node of the field-path Huffman tree, marking it as a branch rather than a terminal. The owning class is implied by the name, not by the data, and the vtable slot is unbound.", + "source": "generated" + }, + "CFieldPathHuffmanEncoder::InternalNode::~InternalNode": { + "text": "Destroys an interior node of the field-path Huffman tree, releasing what that node owns. The owning class is implied by the name; what exactly is freed is not established by this data.", + "source": "generated" + }, + "CFieldPathHuffmanEncoder::LeafNode::IsLeafNode": { + "text": "Answers the shared leaf test for a terminal node of the field-path Huffman tree, marking it as the end of a walk down the tree. The owning class is implied by the name, not by the data, and the vtable slot is unbound.", + "source": "generated" + }, + "CFieldPathHuffmanEncoder::LeafNode::~LeafNode": { + "text": "Destroys a leaf node of the field-path Huffman tree, releasing what that node owns. The owning class is implied by the name; what exactly is freed is not established by this data.", + "source": "generated" + }, + "CFileHandle::~CFileHandle": { + "text": "Destroys a filesystem file-handle object, tearing down the open file it wraps. The owning class is implied by the name; whether it closes the underlying file or only frees bookkeeping is unverified.", + "source": "generated" + }, + "CFileSystem_Stdio::ReadEx": { + "text": "Reads bytes from an open file through the stdio-backed filesystem implementation, the extended read variant of the interface's plain read. The owning class is implied by the name; how short reads and end-of-file are reported is unverified.", + "source": "generated" + }, + "CFilterClass::PassesFilterImpl": { + "text": "Decides whether a candidate entity passes this filter by matching it against the class name held in m_iFilterClass. The owning class is implied by the name; hook it when you want to change which entities a class-based filter accepts.", + "source": "generated" + }, + "CFilterContext::PassesFilterImpl": { + "text": "Decides whether a candidate entity passes this filter by testing it against the context value in m_iFilterContext. The owning class is implied by the name; what the context is compared against, beyond that field, is not established here.", + "source": "generated" + }, + "CFilterEnemy::PassesFilterImpl": { + "text": "Decides whether a candidate entity qualifies as an enemy under this filter, weighing m_iszEnemyName, the m_flRadius and m_flOuterRadius bands, m_nMaxSquadmatesPerEnemy and m_iszPlayerName. The owning class is implied by the name; how the two radius bands combine is unverified.", + "source": "generated" + }, + "CFilterMassGreater::PassesFilterImpl": { + "text": "Decides whether a candidate entity passes by testing its mass against the threshold in m_fFilterMass. The owning class is implied by the name; the greater-than sense follows the name, and how the mass is obtained is unverified.", + "source": "generated" + }, + "CFilterModel::PassesFilterImpl": { + "text": "Decides whether a candidate entity passes by matching its model against the one named in m_iFilterModel. The owning class is implied by the name; whether the match is an exact model path or something looser is unverified.", + "source": "generated" + }, + "CFilterMultiple::PassesDamageFilterImpl": { + "text": "Decides whether a damage event passes this combining filter, evaluating the sub-filters it references (m_hFilter, m_iFilterName) under the mode held in m_nFilterType. The owning class is implied by the name; the exact combination rule is read from that field rather than verified.", + "source": "generated" + }, + "CFilterMultiple::PassesFilterImpl": { + "text": "Decides whether a candidate entity passes this combining filter by evaluating the sub-filters it references (m_hFilter, m_iFilterName) under the mode in m_nFilterType. The owning class is implied by the name; whether that mode means all-must-pass or any-may-pass is unverified.", + "source": "generated" + }, + "CFilterName::PassesFilterImpl": { + "text": "Decides whether a candidate entity passes by matching its targetname against the string in m_iFilterName. The owning class is implied by the name; whether wildcard matching is honoured is not established by this data.", + "source": "generated" + }, + "CFioReadOnlyFile::FS_fread": { + "text": "Reads bytes from a read-only file object, the fread-style entry point backing reads for that file type. The owning class is implied by the name; how short reads and end-of-file are signalled is unverified.", + "source": "generated" + }, + "CFish::GetDataDescMap": { + "text": "Supplies the datadesc field map for the fish entity, covering fields such as m_pool, m_speed, m_panicSpeed and the movement timers. The owning class is implied by the name; read it when you need the fish's keyvalue and save-field layout.", + "source": "generated" + }, + "CFishPool::FireGameEvent": { + "text": "Handles a game event delivered to the fish pool, letting the school react to world state changes rather than polling for them. The owning class is implied by the name rather than recovered from the slot data, and which events it accepts is unverified.", + "source": "generated" + }, + "CFishPool::GetDataDescMap": { + "text": "Returns the fish pool's data description map, the table its map keyvalues and save/restore fields resolve through, such as m_fishCount, m_maxRange and m_swimDepth. The class is implied by the name, so treat that association as a name-level reading.", + "source": "generated" + }, + "CFishPool::Update": { + "text": "Advances the fish pool's simulation, stepping the CFish entities it owns and the state in m_fishes, m_isDormant and m_visTimer. Located by signature in libserver and read from the name, so the tick cadence and dormancy rules are unverified.", + "source": "generated" + }, + "CFlashbang::EmitGrenade": { + "text": "Spawns and launches the thrown flashbang from the weapon, handing off to a live projectile in the world. The class is implied by the name and the reading comes from the name alone, so the throw parameters are unverified.", + "source": "generated" + }, + "CFlashbangProjectile::EmitGrenade": { + "text": "Creates and launches the in-flight flashbang entity, whose fuse is carried in m_flTimeToDetonate. Read from the name; m_numOpponentsHit and m_numTeammatesHit are the per-throw blind counters a modder reads alongside it, though this function's own inputs are unverified.", + "source": "generated" + }, + "CFlattenedSerializer::ApplyOverrides_R": { + "text": "Applies per-field overrides onto a flattened serializer's field tree, the _R suffix indicating it recurses into nested serializers. Read from the name and its home in libnetworksystem; which override sources it consults is unverified.", + "source": "generated" + }, + "CFlattenedSerializer::BuildDeltaProperties": { + "text": "Builds the property set the network layer uses to compute per-tick deltas for a flattened serializer's fields. Read from the name; the delta representation and the conditions under which it is rebuilt are unverified.", + "source": "generated" + }, + "CFlattenedSerializer::BuildHierarchy_R": { + "text": "Constructs the nested field hierarchy of a flattened serializer, recursing into embedded sub-serializers as the _R suffix suggests. Read from the name and matched with low confidence, so treat both the location and the behaviour as provisional.", + "source": "generated" + }, + "CFlattenedSerializer::Encode": { + "text": "Encodes an entity's field values into the wire form described by a flattened serializer. Read from the name; the entity representation it consumes and the buffer it fills are unverified.", + "source": "generated" + }, + "CFlattenedSerializer::EncodeField": { + "text": "Encodes one individual field of a flattened serializer into its network representation, the per-field counterpart of whole-entity encoding. Read from the name; how the field is addressed and what encoding is chosen are unverified.", + "source": "generated" + }, + "CFlattenedSerializer::GatherSendProxyResults_R": { + "text": "Collects send-proxy results across a serializer's field tree, recursing through nested serializers as the _R suffix suggests. Read from the name and matched with low confidence, so both the location and the described behaviour are provisional.", + "source": "generated" + }, + "CFlattenedSerializer::MaybeWriteFlattenedSerializers_R": { + "text": "Conditionally emits flattened serializer definitions, recursing into nested ones, with the Maybe prefix indicating it skips entries that need no writing. Read from the name; the skip condition and the write destination are unverified.", + "source": "generated" + }, + "CFlattenedSerializer::RemoveFakeFields": { + "text": "Strips fields marked fake from a flattened serializer so they are excluded from the network field layout. Read from the name; what marks a field fake, and whether removal is permanent for the serializer, are not established by this data.", + "source": "generated" + }, + "CFlattenedSerializer::SetRecursiveProxyIndices_R": { + "text": "Assigns proxy indices throughout a serializer's nested field tree so recursive sub-serializers can be referenced by index. Read from the name; the index space and what consumes it are unverified.", + "source": "generated" + }, + "CFlattenedSerializer::ValidateSerializedEntity": { + "text": "Checks a serialized entity against its flattened serializer, catching field or layout mismatches before the data is trusted. Read from the name and matched with low confidence, so the identification is provisional and the failure handling is unverified.", + "source": "generated" + }, + "CFlattenedSerializer::WriteFieldList": { + "text": "Writes out a flattened serializer's field list, the flat table describing how an entity class is laid out for transmission. Read from the name; the output target and its format are unverified.", + "source": "generated" + }, + "CFlattenedSerializerSpewFunc_Log::Spew": { + "text": "Emits a flattened-serializer diagnostic message through the log sink this type represents, the hook to watch when serializer construction misbehaves. The class is implied by the name, and the message content and log channel are unverified.", + "source": "generated" + }, + "CFlattenedSerializerSpewFunc_Log::~CFlattenedSerializerSpewFunc_Log": { + "text": "Tears down the flattened-serializer log spew sink and releases what it holds. The class is implied by the name; beyond ordinary destruction, no further purpose is established.", + "source": "generated" + }, + "CFlattenedSerializers::BuildEntityClassNetworkSerializer": { + "text": "Builds the network serializer for a single entity class, producing the flattened field layout that class is transmitted with. The class is implied by the name; the inputs it takes and whether results are cached are unverified.", + "source": "generated" + }, + "CFlexSceneFileManager::FindSceneFile": { + "text": "Resolves a facial-expression scene file, building the path from the anchor expressions/%s.vfe around a requested scene name. Read from that string and the name; whether it loads on a miss or only searches already-resident files is unverified.", + "source": "generated" + }, + "CFogController::InputSet2DSkyboxFogFactor": { + "text": "Handles the `Set2DSkyboxFogFactor` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSet2DSkyboxFogFactorLerpTo": { + "text": "Handles the `Set2DSkyboxFogFactorLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetAngles": { + "text": "Handles the `SetAngles` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetColor": { + "text": "Handles the `SetColor` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetColorLerpTo": { + "text": "Handles the `SetColorLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetColorSecondary": { + "text": "Handles the `SetColorSecondary` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetColorSecondaryLerpTo": { + "text": "Handles the `SetColorSecondaryLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetEndDist": { + "text": "Handles the `SetEndDist` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetEndDistLerpTo": { + "text": "Handles the `SetEndDistLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetFarZ": { + "text": "Handles the `SetFarZ` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetMaxDensity": { + "text": "Handles the `SetMaxDensity` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetMaxDensityLerpTo": { + "text": "Handles the `SetMaxDensityLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetStartDist": { + "text": "Handles the `SetStartDist` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetStartDistLerpTo": { + "text": "Handles the `SetStartDistLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputStartFogTransition": { + "text": "Handles the `StartFogTransition` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::SetLerpValues": { + "text": "Sets the target values a fog transition interpolates toward on the fog controller, working with m_fog for the current fog parameters and m_iChangedVariables for which of them are changing. Read from the name, so the specific values accepted and the transition duration are unverified.", + "source": "generated" + }, + "CFogController::~CFogController": { + "text": "Tears down the fog controller entity and releases its state, including the fog parameters in m_fog. The class is implied by the name; nothing beyond ordinary destruction is established.", + "source": "generated" + }, + "CFogVolume::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CFogVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogVolume::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CFogVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFunFact_GenericEvalFunction::Evaluate": { + "text": "Computes a fun-fact value through a generic evaluation function, producing this fun-fact type's candidate for end-of-round stat display. The class is implied by the name; what it evaluates over and how a candidate is scored are unverified.", + "source": "generated" + }, + "CFunFact_StatSum::Evaluate": { + "text": "Computes a fun fact by summing a player statistic into a single candidate value. The class is implied by the name; which statistic is summed and over which players are unverified.", + "source": "generated" + }, + "CFuncBrush::CFuncBrush": { + "text": "Constructs a func_brush entity and initialises its brush state, including m_iSolidity, m_iDisabled and m_iszExcludedClass, before map keyvalues are applied. Read from the name and the class's fields; the default values it writes are unverified.", + "source": "generated" + }, + "CFuncBrush::DrawDebugTextOverlays": { + "text": "Draws the developer debug text lines for a func_brush, the on-screen readout of its current state such as m_iSolidity and m_iDisabled. The class is implied by the name, and the exact lines drawn are unverified.", + "source": "generated" + }, + "CFuncBrush::GetDataDescMap": { + "text": "Returns the func_brush data description map, the table its keyvalues and save/restore fields such as m_iSolidity and m_iszExcludedClass are bound through. The class is implied by the name.", + "source": "generated" + }, + "CFuncBrush::InputSetExcluded": { + "text": "Handles the `SetExcluded` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputSetInvert": { + "text": "Handles the `SetInvert` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputSetNonsolid": { + "text": "Handles the `SetNonsolid` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputSetSolid": { + "text": "Handles the `SetSolid` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputTurnOff": { + "text": "Handles the `Disable` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputTurnOn": { + "text": "Handles the `Enable` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncElectrifiedVolume::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CFuncElectrifiedVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncElectrifiedVolume::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CFuncElectrifiedVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncInteractionLayerClip::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CFuncInteractionLayerClip`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncInteractionLayerClip::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CFuncInteractionLayerClip`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncLadder::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CFuncLadder`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncLadder::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CFuncLadder`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMonitor::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CFuncMonitor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMonitor::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CFuncMonitor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMonitor::InputSetCamera": { + "text": "Handles the `SetCamera` entity-IO input on `CFuncMonitor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMonitor::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncMonitor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::GetDataDescMap": { + "text": "Returns the data description map for the linearly moving brush entity, the table keyvalues such as m_flSpeed, m_flStartPosition and m_flBlockDamage resolve through. The class is implied by the name.", + "source": "generated" + }, + "CFuncMoveLinear::InputClose": { + "text": "Handles the `Close` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputOpen": { + "text": "Handles the `Open` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputResetPosition": { + "text": "Handles the `ResetPosition` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputSetMoveDistanceFromEnd": { + "text": "Handles the `SetMoveDistanceFromEnd` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputSetMoveDistanceFromStart": { + "text": "Handles the `SetMoveDistanceFromStart` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputSetPosition": { + "text": "Handles the `SetPosition` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputTeleportToTarget": { + "text": "Handles the `TeleportToTarget` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoverRouter::InputClearFollowMoverEntity": { + "text": "Handles the `ClearFollowMoverEntity` entity-IO input on `CFuncMoverRouter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoverRouter::InputSetMoverIndex": { + "text": "Handles the `SetMoverIndex` entity-IO input on `CFuncMoverRouter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoverRouter::InputStart": { + "text": "Handles the `Start` entity-IO input on `CFuncMoverRouter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncNavBlocker::InputBlockNav": { + "text": "Handles the `BlockNav` entity-IO input on `CFuncNavBlocker`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncNavBlocker::InputUnblockNav": { + "text": "Handles the `UnblockNav` entity-IO input on `CFuncNavBlocker`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncPlat::Blocked": { + "text": "Handles the platform being obstructed mid-travel, producing the log line '%s Blocked by %s' naming the platform and the blocker. Read from that anchor and the name; m_flSpeed is the platform's travel rate, while what it does to the blocker is not established.", + "source": "generated" + }, + "CFuncPlat::InputGoDown": { + "text": "Handles the `GoDown` entity-IO input on `CFuncPlat`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncPlat::InputGoUp": { + "text": "Handles the `GoUp` entity-IO input on `CFuncPlat`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncPlat::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncPlat`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::DrawDebugTextOverlays": { + "text": "Draws developer debug text for the rotating brush, including the line 'Speed cur (target): %3.2f (%3.2f)' reporting current against commanded rotation speed, the pair held in m_flSpeed and m_flTargetSpeed. Useful when diagnosing a func_rotating that never reaches its target speed.", + "source": "generated" + }, + "CFuncRotating::GetDataDescMap": { + "text": "Returns the rotating brush's data description map, the table its keyvalues and save/restore fields such as m_flMaxSpeed, m_flFanFriction and m_flBlockDamage resolve through. The class is implied by the name.", + "source": "generated" + }, + "CFuncRotating::InputDisableAccelDecel": { + "text": "Handles the `DisableAccelDecel` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputEnableAccelDecel": { + "text": "Handles the `EnableAccelDecel` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputReverse": { + "text": "Handles the `Reverse` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputSetStartPos": { + "text": "Handles the `SetStartPos` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputSnapToStartPos": { + "text": "Handles the `SnapToStartPos` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStart": { + "text": "Handles the `Start` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStartBackward": { + "text": "Handles the `StartBackward` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStartForward": { + "text": "Handles the `StartForward` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStopAtStartPos": { + "text": "Handles the `StopAtStartPos` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::KeyValue": { + "text": "Parses a map-authored keyvalue for the rotating brush, turning Hammer keys into fields such as m_flFanFriction, m_flVolume and m_flMaxSpeed. The class is implied by the name, and which keys are handled here rather than by the data description map is unverified.", + "source": "generated" + }, + "CFuncRotator::InputPitch": { + "text": "Handles the `Pitch` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputReturnToInitialOrientation": { + "text": "Handles the `ReturnToInitialOrientation` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputReturnToPreviousOrientation": { + "text": "Handles the `ReturnToPreviousOrientation` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputRoll": { + "text": "Handles the `Roll` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputSetRotateType": { + "text": "Handles the `SetRotateType` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputSetRotatorTarget": { + "text": "Handles the `SetRotatorTarget` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputStart": { + "text": "Handles the `Start` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputStartForward": { + "text": "Handles the `StartForward` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputYaw": { + "text": "Handles the `Yaw` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncShatterglass::InputHit": { + "text": "Handles the `Hit` entity-IO input on `CFuncShatterglass`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncShatterglass::InputRestore": { + "text": "Handles the `Restore` entity-IO input on `CFuncShatterglass`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncShatterglass::InputShatter": { + "text": "Handles the `Shatter` entity-IO input on `CFuncShatterglass`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTimescale::InputReset": { + "text": "Handles the `Reset` entity-IO input on `CFuncTimescale`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTimescale::InputStart": { + "text": "Handles the `Start` entity-IO input on `CFuncTimescale`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTimescale::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncTimescale`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::CFuncTrackTrain": { + "text": "Constructs a track-train entity and brings its movement state into a starting condition; the movement fields on this class include m_flSpeed, m_maxSpeed, m_dir and m_ppath. Read as a constructor from the name \u2014 which defaults it actually writes is not established here.", + "source": "generated" + }, + "CFuncTrackTrain::DrawDebugTextOverlays": { + "text": "Draws the train's debug text overlay, emitting lines such as `current speed (goal): %g (%g)` \u2014 its present speed against the speed it is working toward (compare m_flSpeed and m_flDesiredSpeed). Use it when diagnosing a train that will not reach or hold a commanded speed.", + "source": "generated" + }, + "CFuncTrackTrain::GetDataDescMap": { + "text": "Returns the entity's data description map, the table naming its data fields for save/restore and keyvalue handling. Both the purpose and the owning class are implied by the name; the entry is an unbound vtable slot.", + "source": "generated" + }, + "CFuncTrackTrain::InputLockOrientation": { + "text": "Handles the `LockOrientation` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputMoveToPathNode": { + "text": "Handles the `MoveToPathNode` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputResume": { + "text": "Handles the `Resume` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputReverse": { + "text": "Handles the `Reverse` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetMaxSpeed": { + "text": "Handles the `SetMaxSpeed` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetSpeedDir": { + "text": "Handles the `SetSpeedDir` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetSpeedDirAccel": { + "text": "Handles the `SetSpeedDirAccel` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetSpeedReal": { + "text": "Handles the `SetSpeedReal` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputStartBackward": { + "text": "Handles the `StartBackward` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputStartForward": { + "text": "Handles the `StartForward` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputTeleportToPathNode": { + "text": "Handles the `TeleportToPathNode` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputUnlockOrientation": { + "text": "Handles the `UnlockOrientation` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::NearestPath": { + "text": "Finds the nearest track node to the train and reports it as `TRAIN: %s, Nearest track is %s`, naming the train and the node chosen. Read alongside m_ppath, the class's current path pointer (CPathTrack); useful when a train has been moved or teleported and must reacquire its path.", + "source": "generated" + }, + "CFuncTrackTrain::SetSpeed": { + "text": "Sets the train's travel speed, logging `TRAIN(%s), speed to %.2f` with the entity and the new value; the fields in play are m_flSpeed, m_oldSpeed and m_maxSpeed. Whether it clamps against m_maxSpeed or ramps via m_flAccelSpeed and m_bAccelToSpeed is not established here.", + "source": "generated" + }, + "CFuncTrain::InputStart": { + "text": "Handles the `Start` entity-IO input on `CFuncTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrain::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrain::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrainControls::Find": { + "text": "Locates the train that a set of train controls belongs to, resolving the controls entity to its CFuncTrackTrain. Read from the name and the class pairing; no prototype is derived, so the search criteria and the result are unverified.", + "source": "generated" + }, + "CGameConfiguration::PreservePlayerNetworkables": { + "text": "Preserves player-associated networkable objects across a game configuration change, logging `SV: PreservePlayerNetworkables(%d)` with the count or flag involved. Confidence is low: beyond that anchor and the name, what is retained and under what conditions are not established.", + "source": "generated" + }, + "CGameEntitySystem::AddEntityIOEvent": { + "text": "Queues an entity I/O event with the game entity system \u2014 an input directed at a target entity, part of the entity input/output mechanism maps rely on. Use it to fire inputs on entities from code; the queued event's fields and timing are not established here.", + "source": "generated" + }, + "CGameEntitySystem::AddListenerEntity": { + "text": "Registers an entity as a listener with the game entity system so it is notified of entity-system activity such as creations and removals. Pair it with CGameEntitySystem::RemoveListenerEntity; the exact notifications delivered are read from the name and unverified.", + "source": "generated" + }, + "CGameEntitySystem::AllocPooledString": { + "text": "Interns a string in the entity system's string pool and hands back the pooled handle that entity name and classname fields use. Use it when an entity API expects a pooled string rather than a raw character pointer; the pool's lifetime rules are not established here.", + "source": "generated" + }, + "CGameEntitySystem::AllocateEntity": { + "text": "Allocates a new entity together with its identity record \u2014 the anchor `AllocateEntityIdentity` names the identity part of that allocation. Confidence is low: this reads as raw allocation from the name, and what it initialises beyond that is not established.", + "source": "generated" + }, + "CGameEntitySystem::CreateEntityByName": { + "text": "Creates an entity instance from a classname string, the code-side counterpart to an entity placed in a map. Also shipped as CBaseEntity::CreateEntityByName, CreateEntityByName and UTIL::CreateEntityByName \u2014 the same function under several names \u2014 and commonly used with CGameEntitySystem::DispatchSpawn.", + "source": "generated" + }, + "CGameEntitySystem::DispatchSpawn": { + "text": "Spawns an entity, running the spawn-time setup that makes a created entity active in the world. Used alongside CGameEntitySystem::CreateEntityByName when building entities from code, typically once the new entity's keyvalues have been set.", + "source": "generated" + }, + "CGameEntitySystem::FindByClassname": { + "text": "Searches the entity system for an entity of a given classname, a lookup for locating map entities at runtime. Shipped also as CGameEntitySystem::FindEntityByClassName \u2014 the same function \u2014 with CGameEntitySystem::FindByName covering targetname lookups instead.", + "source": "generated" + }, + "CGameEntitySystem::FindByName": { + "text": "Finds an entity by its targetname, the name a mapper gives an entity so others can address it. Shipped also as CGameEntitySystem::FindEntityByName \u2014 the same function; reach for CGameEntitySystem::FindByClassname when you have a classname instead.", + "source": "generated" + }, + "CGameEntitySystem::FindEntityByClassName": { + "text": "Looks up an entity by classname within the game entity system. Shipped also as CGameEntitySystem::FindByClassname \u2014 the same function under a second name, so a hook or detour placed on one affects both.", + "source": "generated" + }, + "CGameEntitySystem::FindEntityByIndex": { + "text": "Resolves an entity index \u2014 the slot number that appears in networking and console output \u2014 to the live entity occupying it. Handy for turning an index taken from a game event or a console command into a CEntityInstance you can work with.", + "source": "generated" + }, + "CGameEntitySystem::FindEntityByName": { + "text": "Finds an entity by its targetname string. Shipped also as CGameEntitySystem::FindByName \u2014 the same function under a second name, so hooking or detouring one covers both.", + "source": "generated" + }, + "CGameEntitySystem::FindEntityClassByClassname": { + "text": "Maps a designer-facing classname to the engine's entity class record; the anchor `GetScriptClassForDesignerName` describes that same designer-name-to-class lookup. Use it to confirm a classname is registered before trying to create an entity with it.", + "source": "generated" + }, + "CGameEntitySystem::FindInSphere": { + "text": "Finds entities within a spherical region of the world \u2014 a proximity query over the entity system. Useful for radius effects such as area damage, pickup ranges or proximity triggers; any filtering it applies is not established here.", + "source": "generated" + }, + "CGameEntitySystem::GetSpawnOriginOffset": { + "text": "Returns the offset applied to a spawn origin, the correction between a stored spawn position and where the entity is actually placed. Read from the name; what the offset is measured against, and which entities it covers, are not established here.", + "source": "generated" + }, + "CGameEntitySystem::RemoveListenerEntity": { + "text": "Unregisters an entity that was registered through CGameEntitySystem::AddListenerEntity, stopping further entity-system notifications to it. Call it when a listener is torn down so the system does not retain a stale registration.", + "source": "generated" + }, + "CGameEntitySystem::SortEntities": { + "text": "Sorts the entity system's entities into the \"entity islands\" named in its own assert \u2014 `Memory trash in SortEntities.. overran the number of entity islands supported!` fires when that island budget is exceeded. Relevant when a map builds very many separate entity groupings; the sort key is not established here.", + "source": "generated" + }, + "CGameEvent::GetFloat": { + "text": "Reads a named floating-point value out of a game event's payload, such as a coordinate or a duration. The owning class is implied by the name \u2014 the entry is an unbound vtable slot \u2014 and no prototype is derived, so the key lookup is unverified.", + "source": "generated" + }, + "CGameEvent::GetInt": { + "text": "Reads a named integer value out of a game event's payload, an accessor for fields like userids and entity indices. The owning class is implied by the name; the entry is an unbound vtable slot.", + "source": "generated" + }, + "CGameEvent::GetPtr": { + "text": "Reads a named pointer value out of a game event's payload, for fields carrying an object rather than a scalar. The owning class is implied by the name; the entry is an unbound vtable slot, so treat the pointee's type as unverified.", + "source": "generated" + }, + "CGameEvent::GetUint64": { + "text": "Reads a named 64-bit unsigned value out of a game event's payload \u2014 a width suited to identifier-sized fields such as account or Steam IDs. The owning class is implied by the name; the entry is an unbound vtable slot.", + "source": "generated" + }, + "CGameEventManager::FireEvent": { + "text": "Fires a game event into the event system so subscribers see it, a code-side way to raise events. The owning class is implied by the name; the entry is an unbound vtable slot, so ownership of the event object after firing is unverified.", + "source": "generated" + }, + "CGameEventManager::OnSource1LegacyGameEventListenBitsReceived": { + "text": "Handles the legacy Source 1 listen-bits message, by which a client declares the game events it wants using bit indices; unrecognised indices log `OnSource1LegacyGameEventListenBitsReceived: game event %i not found.`. Relevant to compatibility with older event subscription; beyond that anchor, confidence is low.", + "source": "generated" + }, + "CGameEventManager_Init": { + "text": "Brings up the game event manager, drawing event definitions from resource/core.gameevents so events can be fired and listened for by name. That resource string is the direct evidence; whether other event files are also taken in is not established.", + "source": "generated" + }, + "CGameEventSystem::Connect": { + "text": "Hooks the game-event system into the engine's system framework so it can begin operating, the standard connect step for an engine module. Read from the name; the CGameEventSystem class is implied by the name rather than derived, so what it acquires here is unverified.", + "source": "generated" + }, + "CGameEventSystem::Disconnect": { + "text": "Tears down the game-event system's links to the engine framework, releasing what a connect step established. Read from the name; the CGameEventSystem class is implied by the name rather than derived, so the exact teardown is unverified.", + "source": "generated" + }, + "CGameEventSystem::GetBuildType": { + "text": "Reports the build type the game-event system was compiled or configured for, which matters if a plugin must branch on debug versus release behaviour. Read from the name; the CGameEventSystem class is implied by the name, and the value's encoding is unverified.", + "source": "generated" + }, + "CGameEventSystem::GetDependencies": { + "text": "Reports which other engine systems the game-event system requires, the dependency information the engine's module machinery consumes. Read from the name; the CGameEventSystem class is implied by the name rather than derived, so the form of the result is unverified.", + "source": "generated" + }, + "CGameEventSystem::GetEventSource": { + "text": "Returns the event-source object the system publishes through, the handle to reach event plumbing directly instead of going via a wrapper. Read from the name; the CGameEventSystem class is implied by the name, and what the result points at is unverified.", + "source": "generated" + }, + "CGameEventSystem::GetTier": { + "text": "Reports the initialization tier the game-event system belongs to in the engine's layered system model. Read from the name; the CGameEventSystem class is implied by the name rather than derived, and the tier numbering is unverified.", + "source": "generated" + }, + "CGameEventSystem::Init": { + "text": "Purpose is not established beyond generic initialization of the game-event system. The CGameEventSystem class is implied by the name, not derived from the data.", + "source": "generated" + }, + "CGameEventSystem::IsSingleton": { + "text": "Reports whether the game-event system exists as one shared instance for the process rather than one per consumer. Read from the name; the CGameEventSystem class is implied by the name, and the exact condition it tests is unverified.", + "source": "generated" + }, + "CGameEventSystem::PostEntityEventAbstract": { + "text": "Posts a game event scoped to a particular entity, the entity-targeted form of event publication for effects and notifications tied to one object. Read from the name; the CGameEventSystem class is implied by the name, and the abstract payload form is unverified.", + "source": "generated" + }, + "CGameEventSystem::PostEventAbstract": { + "text": "Publishes a game event into the system in an untyped, abstract payload form, the general-purpose path for firing an event that listeners will receive. Read from the name; the CGameEventSystem class is implied by the name, and the payload encoding is unverified.", + "source": "generated" + }, + "CGameEventSystem::PostEventAbstract_Local": { + "text": "Publishes a game event confined to the local machine rather than propagated onward, the local-only variant of abstract event posting. Read from the name; the CGameEventSystem class is implied by the name, and the precise meaning of local here is unverified.", + "source": "generated" + }, + "CGameEventSystem::PreShutdown": { + "text": "Performs the early teardown pass on the game-event system, the stage for quiescing outstanding work while the rest of the engine is still alive. Read from the name; the CGameEventSystem class is implied by the name, and what it releases is unverified.", + "source": "generated" + }, + "CGameEventSystem::ProcessQueuedEvents": { + "text": "Works through the events accumulated in the system's queue so deferred events reach their listeners, the flush point for queued event traffic. Read from the name; the CGameEventSystem class is implied by the name, and the queue's ownership and timing are unverified.", + "source": "generated" + }, + "CGameEventSystem::PurgeQueuedEvents": { + "text": "Discards events still waiting in the system's queue without delivering them, useful for clearing stale event state around a level change or teardown. Read from the name; the CGameEventSystem class is implied by the name, and which events are affected is unverified.", + "source": "generated" + }, + "CGameEventSystem::QueryInterface": { + "text": "Looks up an interface exposed by the game-event system and hands back a usable pointer to it. Read from the name; the CGameEventSystem class is implied by the name rather than derived, and the lookup key is unverified.", + "source": "generated" + }, + "CGameEventSystem::Reconnect": { + "text": "Re-establishes the game-event system's links to engine services, the refresh path used when interfaces are swapped or reloaded. Read from the name; the CGameEventSystem class is implied by the name, and the conditions that require it are unverified.", + "source": "generated" + }, + "CGameEventSystem::RegisterGameEvent": { + "text": "Registers a game-event definition with the system so that event name becomes postable and listenable. Read from the name; the CGameEventSystem class is implied by the name rather than derived, and the descriptor it accepts is unverified.", + "source": "generated" + }, + "CGameEventSystem::RegisterGameEventHandlerAbstract": { + "text": "Registers a listener to receive posted game events, the subscription entry point a plugin uses to start hooking events. Read from the name; the CGameEventSystem class is implied by the name, and the handler representation is unverified.", + "source": "generated" + }, + "CGameEventSystem::Shutdown": { + "text": "Shuts the game-event system down as part of engine teardown. Read from the name; the CGameEventSystem class is implied by the name rather than derived, so what it releases is unverified.", + "source": "generated" + }, + "CGameEventSystem::UnregisterGameEventHandlerAbstract": { + "text": "Removes a previously registered game-event listener so it stops receiving events, the unsubscribe path a plugin needs when unloading to avoid a stale handler. Read from the name; the CGameEventSystem class is implied by the name, and the handle it matches on is unverified.", + "source": "generated" + }, + "CGameGibManager::InputSetMaxPieces": { + "text": "Handles the `SetMaxPieces` entity-IO input on `CGameGibManager`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGameGibManager::InputSetMaxPiecesDX8": { + "text": "Handles the `SetMaxPiecesDX8` entity-IO input on `CGameGibManager`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGameParticleManager::SetParticleControlEnt": { + "text": "Binds a particle effect's control point to an entity, optionally to a named attachment on that entity's model; its own error string reports being unable to look up an attachment on a model for an entity when that attachment is missing. Use it to make an effect follow a player, weapon, or prop.", + "source": "generated" + }, + "CGamePhysicsQueryInterface::EntitiesAlongRay": { + "text": "Gathers the entities a ray passes through in the world, the trace-style spatial query behind line-of-sight, hitscan, and area checks. Read from the name; no string anchor pins down the filtering or the output container, so those remain unverified.", + "source": "generated" + }, + "CGamePlayerEquip::InputTriggerForActivatedPlayer": { + "text": "Hands the configured equipment to the one player who activated CGamePlayerEquip, the map input a level designer fires to arm a specific player rather than a group. Read from the name; it also ships under the bare name InputTriggerForActivatedPlayer, and the item-selection rules are unverified.", + "source": "generated" + }, + "CGamePlayerEquip::KeyValue": { + "text": "Consumes one key/value pair from the map entity's properties, how CGamePlayerEquip picks up its authored equipment settings at spawn time. Read from the name; the class is implied by the name rather than derived, and which keys it accepts is unverified.", + "source": "generated" + }, + "CGamePlayerZone::InputCountPlayersInZone": { + "text": "Handles the `CountPlayersInZone` entity-IO input on `CGamePlayerZone`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGameResourceService::BuildResourceManifest": { + "text": "Assembles the manifest of resources the current content requires, the enumeration side of resource loading. Read from the name; the CGameResourceService class is implied by the name rather than derived, and what it enumerates is unverified.", + "source": "generated" + }, + "CGameResourceService::PrecacheEntitiesAndConfirmResourcesAreLoaded": { + "text": "Precaches the assets referenced by a level's entities and confirms those resources actually finished loading, the guard against missing models and sounds appearing at spawn time. The CGameResourceService class is implied by the name rather than derived, and the behaviour on a failed confirmation is unverified.", + "source": "generated" + }, + "CGameRulesGameSystem::FrameUpdatePostEntityThink": { + "text": "Gives the game-rules system its per-frame update at the post-entity-think stage of the server frame. The class is implied by the name, and what it actually updates is a name-level reading only.", + "source": "generated" + }, + "CGameRulesGameSystem::FrameUpdatePreEntityThink": { + "text": "Gives the game-rules system its per-frame update at the pre-entity-think stage of the server frame. The class is implied by the name, and what it actually updates is a name-level reading only.", + "source": "generated" + }, + "CGameRulesGameSystem::GameActivate": { + "text": "Notifies the game-rules system that the level is going active, the stage where rules can set themselves up for the loaded map. The class is implied by the name, and the activation semantics are a name-level reading.", + "source": "generated" + }, + "CGameRulesGameSystem::GameDeactivate": { + "text": "Notifies the game-rules system that the active level is being deactivated, giving rules a place to release per-map state. The class is implied by the name, and the teardown semantics are a name-level reading.", + "source": "generated" + }, + "CGameRulesGameSystem::GameInit": { + "text": "Initialises the game-rules system at game start-up. The class is implied by the name, and beyond 'initialise the system' the name establishes no specific work.", + "source": "generated" + }, + "CGameRulesGameSystem::GamePostInit": { + "text": "Runs the game-rules system's post-initialisation stage, intended for set-up that needs the rest of initialisation already in place. The class is implied by the name, and the specific work is a name-level reading.", + "source": "generated" + }, + "CGameRulesGameSystem::GamePreShutdown": { + "text": "Runs the game-rules system's pre-shutdown stage, where rules can flush or release state while the game is still up. The class is implied by the name, and the specific work is read from the name only.", + "source": "generated" + }, + "CGameRulesGameSystem::GameShutdown": { + "text": "Shuts the game-rules system down, tearing down what it established at game start-up. The class is implied by the name, and the teardown detail is a name-level reading.", + "source": "generated" + }, + "CGameRulesGameSystem::OnPostSpawnGroupLoad": { + "text": "Notifies the game-rules system that a spawn group has finished loading, so rules can react to entities that came in with it. The class is implied by the name, and the notification's contents are unverified.", + "source": "generated" + }, + "CGameRulesGameSystem::OnPrecacheResource": { + "text": "Gives the game-rules system its opportunity to precache the resources the current rules need. The class is implied by the name, and what it precaches is a name-level reading.", + "source": "generated" + }, + "CGameRulesProxy::CGameRulesProxy": { + "text": "Constructs the game-rules proxy entity, initialising the instance's fields as it is created. The name establishes construction only; treat it as the creation point for that entity rather than evidence of what the proxy carries.", + "source": "generated" + }, + "CGameSceneNode::BuildBoneMergeWork": { + "text": "Builds the bone-merge work data for a scene node driven by another entity's skeleton, and rejects the setup with 'Invalid use of bonemerge-based hierarchy in non-skeleton instance based entity' when the target entity has no skeleton instance. Node state a modder would read alongside it includes m_bBoneMergeFlex, m_bDirtyBoneMergeInfo and m_bDirtyBoneMergeBoneToRoot.", + "source": "generated" + }, + "CGameSceneNode::StartHierarchicalAttachment": { + "text": "Begins attaching this scene node into a parent's hierarchy at a named attachment point, erroring with 'Cannot specify a skeleton instance that has no owner!' when the supplied skeleton instance has no owner entity. Fields to inspect alongside it are m_hParent, m_hierarchyAttachName and m_nParentAttachmentOrBone.", + "source": "generated" + }, + "CGameSystemManager::SetGameSystemState": { + "text": "Moves a game system to a new state, logging the change as \"SetGameSystemState( %d : '%s' to '%s' )\" with the system's index and its old and new state names. That log line is the strongest evidence here; the state values themselves are not enumerated in this data.", + "source": "generated" + }, + "CGameText::InputDisplay": { + "text": "Handles the `Display` entity-IO input on `CGameText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGameText::InputSetText": { + "text": "Handles the `SetText` entity-IO input on `CGameText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGameText::KeyValue": { + "text": "Parses keyvalues for the game_text entity, including the secondary colour key anchored as 'color2', and applies them to the entity's text setup. The class is implied by the name; m_iszMessage and m_textParms hold the resulting message and its formatting.", + "source": "generated" + }, + "CGameUIService::Init": { + "text": "Initialises the game UI service; beyond initialisation the name does not establish what it sets up. The class is implied by the name.", + "source": "generated" + }, + "CGenericConstraint::InputSetAngularDampingRatioX": { + "text": "Handles the `SetAngularDampingRatioX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularDampingRatioY": { + "text": "Handles the `SetAngularDampingRatioY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularDampingRatioZ": { + "text": "Handles the `SetAngularDampingRatioZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularFrequencyX": { + "text": "Handles the `SetAngularFrequencyX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularFrequencyY": { + "text": "Handles the `SetAngularFrequencyY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularFrequencyZ": { + "text": "Handles the `SetAngularFrequencyZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularMotionLockedX": { + "text": "Handles the `SetAngularMotionLockedX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularMotionLockedY": { + "text": "Handles the `SetAngularMotionLockedY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularMotionLockedZ": { + "text": "Handles the `SetAngularMotionLockedZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearDampingRatioX": { + "text": "Handles the `SetLinearDampingRatioX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearDampingRatioY": { + "text": "Handles the `SetLinearDampingRatioY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearDampingRatioZ": { + "text": "Handles the `SetLinearDampingRatioZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearFrequencyX": { + "text": "Handles the `SetLinearFrequencyX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearFrequencyY": { + "text": "Handles the `SetLinearFrequencyY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearFrequencyZ": { + "text": "Handles the `SetLinearFrequencyZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearMotionLockedX": { + "text": "Handles the `SetLinearMotionLockedX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearMotionLockedY": { + "text": "Handles the `SetLinearMotionLockedY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearMotionLockedZ": { + "text": "Handles the `SetLinearMotionLockedZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::UpdateThink": { + "text": "Services the generic constraint on its periodic think, the stage where its per-axis break timers and force notification tracking are maintained. Read from the name plus fields such as m_flBreakAfterTimeX, m_flNotifyForceLastTimeX and m_bAxisNotifiedX; the exact per-tick work is unverified.", + "source": "generated" + }, + "CGlobalThreadPool::Start": { + "text": "Starts the global thread pool, bringing its worker threads up so queued jobs can run. The class is implied by the name, and what it configures at start-up is a name-level reading.", + "source": "generated" + }, + "CGradientFog::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGradientFog::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGradientFog::InputSetFarZ": { + "text": "Handles the `SetFarZ` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGradientFog::InputSetFogColor": { + "text": "Handles the `SetFogColor` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGradientFog::InputSetFogEndHeight": { + "text": "Handles the `SetFogEndHeight` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGradientFog::InputSetFogFalloffExponent": { + "text": "Handles the `SetFogFalloffExponent` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGradientFog::InputSetFogMaxOpacity": { + "text": "Handles the `SetFogMaxOpacity` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGradientFog::InputSetFogStartHeight": { + "text": "Handles the `SetFogStartHeight` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGradientFog::InputSetFogStrength": { + "text": "Handles the `SetFogStrength` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGradientFog::InputSetFogVerticalExponent": { + "text": "Handles the `SetFogVerticalExponent` entity-IO input on `CGradientFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGunTarget::InputStart": { + "text": "Handles the `Start` entity-IO input on `CGunTarget`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGunTarget::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CGunTarget`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGunTarget::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CGunTarget`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CHEGrenade::EmitGrenade": { + "text": "Emits the HE grenade from the weapon, creating and launching the thrown projectile. The class is implied by the name, and the launch details are read from the name only.", + "source": "generated" + }, + "CHEGrenadeProjectile::EmitGrenade": { + "text": "Creates and launches the in-flight HE grenade, with the string anchor 'hegrenade_projectile' naming the entity it produces. Use it as the point where an HE projectile enters the world; its inputs and initial velocity handling are unverified.", + "source": "generated" + }, + "CHLTVClient::ActivatePlayer": { + "text": "Activates an HLTV spectator client, moving it from merely connected into the state where it participates in the broadcast. The class is implied by the name, and the activation steps are a name-level reading.", + "source": "generated" + }, + "CHLTVClient::Connect": { + "text": "Handles an HLTV client connecting to the server, establishing the spectator connection and its identifying details. The class is implied by the name; whether it can reject a connection, and on what grounds, is unverified.", + "source": "generated" + }, + "CHLTVDirector::OnHLTVUncompressedSnapshot": { + "text": "Handles an uncompressed HLTV snapshot reaching the director, the event at which it can inspect broadcast world state for shot and camera decisions. Read from the name; what the director records or changes on that event is unverified.", + "source": "generated" + }, + "CHLTVFrame::IsMemPoolAllocated": { + "text": "Reports whether this HLTV frame was allocated from a memory pool rather than general heap memory, which determines how it must be released. The class is implied by the name.", + "source": "generated" + }, + "CHLTVFrame::~CHLTVFrame": { + "text": "Destroys an HLTV frame, releasing the snapshot data it holds. The class is implied by the name, and which buffers it frees is not established here.", + "source": "generated" + }, + "CHostStateMgr::QueueNewRequest": { + "text": "Queues a new host-state request \u2014 a pending change to what the host is doing, such as loading a level \u2014 on the host state manager. The class is implied by the name, and the request's contents are unverified.", + "source": "generated" + }, + "CHostStateMgr::StartNewRequest": { + "text": "Starts a new host-state request on the manager, putting the requested host transition into motion. It also ships under the name HostStateRequest, which is the same function; the transition kinds it handles are not established here.", + "source": "generated" + }, + "CHostStateRequest::Start": { + "text": "Starts the host-state request this object represents, beginning the host transition it was created for. Read from the name; what the request carries and how completion is signalled are unverified.", + "source": "generated" + }, + "CHostage::CHostage": { + "text": "Constructs the hostage entity; a string anchor associates the class with the info_hostage_spawn entity alias. Initial state a modder would inspect includes m_nHostageState, m_isRescued and m_leader, though the constructor's own work is unverified.", + "source": "generated" + }, + "CHostage::Pickup": { + "text": "Handles a player picking the hostage up, refusing the grab with the notice '#SFUI_Notice_Hostage_Pickup_Must_Be_On_Ground' when that condition is not satisfied. Related state includes m_hHostageGrabber, m_flGrabSuccessTime and m_nPickupEventCount.", + "source": "generated" + }, + "CHostageRescueZone::HostageRescueTouch": { + "text": "Handles a touch on the hostage rescue zone, the point at which a hostage in the zone volume is treated as rescued. Read from the name; the rescue conditions are unverified, and m_isRescued and m_flRescueStartTime are the hostage-side fields to watch.", + "source": "generated" + }, + "CIODelayAlarmThread::~CIODelayAlarmThread": { + "text": "Destroys the I/O delay alarm thread helper, shutting it down and releasing what it held. The class is implied by the name, and the shutdown detail is not established here.", + "source": "generated" + }, + "CInferno::CheckExpired": { + "text": "Checks whether the inferno's fire has outlived its lifetime and should stop burning. Read from the name and the class's timing fields \u2014 m_nFireLifetime, m_nFireEffectTickBegin and m_bInPostEffectTime \u2014 so the exact expiry test is unverified.", + "source": "generated" + }, + "CInferno::FadeOut": { + "text": "Fades the inferno out, winding its flames down rather than cutting the fire off instantly. Read from the name alongside m_bFireIsBurning, m_fireCount and m_bInPostEffectTime; the fade's timing and what it clears are unverified.", + "source": "generated" + }, + "CInfernoLOSTraceFilter::ShouldHitEntity": { + "text": "Decides whether a candidate entity counts as a hit while tracing line of sight for an inferno, so fire spread ignores entities that should not block it. The CInfernoLOSTraceFilter class is implied by the name, and the acceptance criteria it applies are unverified.", + "source": "generated" + }, + "CInfoDynamicShadowHint::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CInfoDynamicShadowHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoDynamicShadowHint::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CInfoDynamicShadowHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoGameEventProxy::InputGenerateGameEvent": { + "text": "Handles the `GenerateGameEvent` entity-IO input on `CInfoGameEventProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoOffscreenPanoramaTexture::InputAddCSSClass": { + "text": "Handles the `AddCSSClass` entity-IO input on `CInfoOffscreenPanoramaTexture`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoOffscreenPanoramaTexture::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CInfoOffscreenPanoramaTexture`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoOffscreenPanoramaTexture::InputRemoveCSSClass": { + "text": "Handles the `RemoveCSSClass` entity-IO input on `CInfoOffscreenPanoramaTexture`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoPlayerStart::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CInfoPlayerStart`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoPlayerStart::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CInfoPlayerStart`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoPlayerStart::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CInfoPlayerStart`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoSpawnGroupLoadUnload::InputActivateSpawnGroup": { + "text": "Entity input that makes the targeted spawn group the active one; when the reference is bad it logs 'InputActivateSpawnGroup called with invalid spawn group, ignoring!!!' and does nothing. The group it acts on comes from m_iszSpawnGroupName, with m_bQueueActiveSpawnGroupChange holding the pending switch.", + "source": "generated" + }, + "CInfoSpawnGroupLoadUnload::InputStartSpawnGroupLoad": { + "text": "Entity input that begins loading a spawn group, logging 'InputStartSpawnGroupLoad(%s)' with the group name as it starts. Drive it from map I/O using m_iszSpawnGroupName and m_iszLandmarkName, and hook m_OnSpawnGroupLoadStarted and m_OnSpawnGroupLoadFinished to observe progress.", + "source": "generated" + }, + "CInfoSpawnGroupLoadUnload::InputStartSpawnGroupUnload": { + "text": "Entity input that begins unloading a spawn group, logging 'InputStartSpawnGroupUnload(%s)' with the group name. The related state is m_bUnloadingStarted, the m_OnSpawnGroupUnloadStarted and m_OnSpawnGroupUnloadFinished outputs, and m_flTimeoutInterval for bounding how long the operation may take.", + "source": "generated" + }, + "CInfoTarget::~CInfoTarget": { + "text": "Destructor that tears down a CInfoTarget instance when the entity is removed. The class is implied by the name, and beyond instance teardown no specific behaviour is established.", + "source": "generated" + }, + "CInfoVisibilityBox::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CInfoVisibilityBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoVisibilityBox::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CInfoVisibilityBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInputService::OnProfileStorageAvailable": { + "text": "Handles the moment profile storage becomes usable by the input service, the point at which stored input and binding preferences can be applied. The class is implied by the name, and what it reads out of the profile is not established here.", + "source": "generated" + }, + "CInventoryManager::BuildCacheSubscribed": { + "text": "Builds the subscribed inventory cache, populating the server-side view of a player's Econ items from the item records named in the 'BuildCacheSubscribed(CEconItem)' anchor. When and for whom the cache is rebuilt is unverified.", + "source": "generated" + }, + "CItemGeneric::InputStartAmbientSound": { + "text": "Handles the `StartAmbientSound` entity-IO input on `CItemGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CItemGeneric::InputStopAmbientSound": { + "text": "Handles the `StopAmbientSound` entity-IO input on `CItemGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CItemGeneric::InputToggleAmbientSound": { + "text": "Handles the `ToggleAmbientSound` entity-IO input on `CItemGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CItemGenericTriggerHelper::CItemGenericTriggerHelper": { + "text": "Constructor for the trigger-volume helper that a CItemGeneric uses to notice nearby players, setting up the instance including its m_hParentItem back-reference to the owning item. The initial values it writes are not established by this data.", + "source": "generated" + }, + "CItemGenericTriggerHelper::ItemGenericTriggerHelperTouch": { + "text": "Touch handler for the helper's trigger volume: it runs when another entity enters the volume and acts on the owning CItemGeneric through m_hParentItem. Read from the name and that field; which touchers it accepts or rejects is unverified.", + "source": "generated" + }, + "CItemKevlar::EquipArmor": { + "text": "Applies the Kevlar item's armor to the player equipping it. The class is implied by the name, so the recipient, the amount granted, and any accompanying flags are read from the name rather than verified.", + "source": "generated" + }, + "CItemSodaCan::ItemSodaCanThink": { + "text": "Per-think update for the soda can item entity, advancing whatever timed state that pickup maintains. Read from the name alone; the think interval and the state it touches are unverified.", + "source": "generated" + }, + "CJob::BYield": { + "text": "Yields the running job so other work can proceed, suspending it until something wakes it again. Read from the name and the 'BYield' anchor; the conditions under which it resumes are not established.", + "source": "generated" + }, + "CJob::DelayedStart": { + "text": "Starts a job on a delay instead of running it immediately, deferring its first execution. Read from the name and the 'DelayedStart' anchor; the delay's source and units are unverified.", + "source": "generated" + }, + "CJobMgr::BRouteMsgToJob": { + "text": "Routes an inbound message to the job it is addressed to, discarding it when the job's context is wrong and logging 'Encountered message for job %s (message ID %d) sent by %s called within an invalid context of %d. Dropping the message.' Check that log when job messages disappear.", + "source": "generated" + }, + "CJobMgr::CJobMgr": { + "text": "Constructs the job manager, bringing up its state including the worker pool identified by the 'CJobMgr::m_WorkThreadPool' anchor. How many threads it stands up and with what settings is not established here.", + "source": "generated" + }, + "CJobMgr::CheckThreadID": { + "text": "Verifies that job manager work is happening on the thread it expects, guarding the job system against cross-thread misuse. Read from the name and the 'CheckThreadID' anchor; what it does on a mismatch is unverified.", + "source": "generated" + }, + "CJobMgr::PassMsgToJob": { + "text": "Hands a message to a specific job, warning 'CJobMgr::PassMsgToJob() job %s received unexpected message %s when paused for %s' when the job is paused waiting on something else. That warning is the signal that a job is getting traffic outside the state it is waiting in.", + "source": "generated" + }, + "CJobMgr::WakeDependentJobFinished": { + "text": "Wakes a job that was sleeping on a dependency, recording that the dependency has finished so the waiter can continue. Read from the name; the bookkeeping it keeps for dependents is not established by this data.", + "source": "generated" + }, + "CKV3Interface_LoadGame::ReadTick": { + "text": "Reads a tick value out of a KeyValues3-backed load-game stream, recovering the saved simulation tick. The CKV3Interface_LoadGame class is implied by the name, and the on-disk representation it expects is unverified.", + "source": "generated" + }, + "CKeepUpright::InputSetAngularLimit": { + "text": "Handles the `SetAngularLimit` entity-IO input on `CKeepUpright`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CKeepUpright::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CKeepUpright`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CKeepUpright::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CKeepUpright`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CKeepUpright::Simulate": { + "text": "Runs the per-tick correction that torques the attached object so its m_localTestAxis lines up with m_worldGoalAxis, bounded by m_angularLimit and affected by m_bDampAllRotation while m_bActive is set. The class is implied by the name, so the solver's exact behaviour is unverified.", + "source": "generated" + }, + "CKeepUpright::~CKeepUpright": { + "text": "Destructor for the keep-upright constraint entity, tearing down the instance along with the motion controller it holds in m_pController. The class is implied by the name; cleanup beyond instance teardown is not established.", + "source": "generated" + }, + "CKeyValues3Array::EnsureElementCapacity": { + "text": "Grows a KeyValues3 array's backing storage so it can hold at least a requested number of elements, reallocating when the current capacity is too small. Read from the name and the 'EnsureElementCapacity' anchor; the growth policy is unverified.", + "source": "generated" + }, + "CKeyValues3Table::EnsureMemberCapacity": { + "text": "Grows a KeyValues3 table's storage so it can hold at least a requested number of members, reallocating when existing capacity falls short. Read from the name and the 'EnsureMemberCapacity' anchor; the growth policy is unverified.", + "source": "generated" + }, + "CKickIssue::GetDisplayString": { + "text": "Produces the display text for a kick vote using the localization token '#SFUI_vote_kick_player_other'. Hook it when you want a kick vote to read differently in the vote UI.", + "source": "generated" + }, + "CKickIssue::GetOtherTeamDisplayString": { + "text": "Produces the kick-vote display text shown to the team that did not call the vote, using the localization token '#SFUI_otherteam_vote_kick_player'. Pairs with CKickIssue::GetDisplayString when customizing how kick votes are announced.", + "source": "generated" + }, + "CKnife::PrimaryAttack": { + "text": "Performs the knife's primary attack, the fast slash swing, and is the natural hook point for changing knife damage or swing timing. The class is implied by the name; m_bFirstAttack tracks the opening swing, though its exact use here is unverified.", + "source": "generated" + }, + "CKnife::SecondaryAttack": { + "text": "Performs the knife's secondary attack, the slower heavy stab. The class is implied by the name, so the damage, reach and cooldown it applies are read from the name rather than verified.", + "source": "generated" + }, + "CLagCompensationManager::BacktrackPlayer": { + "text": "Rewinds a player to the recorded position and pose they held at a shooter's command time, so hit registration matches what the shooter saw. With no usable history it logs 'No valid positions in history for BacktrackPlayer entity %d', a useful signal when lag compensation misbehaves.", + "source": "generated" + }, + "CLagCompensationManager::CalcRestorePos": { + "text": "Computes the position a lag-compensated player should be put back to once compensation ends, so rewinding does not leave the entity displaced. Read from the name and the 'CalcRestorePos' anchor; the interpolation it uses is unverified.", + "source": "generated" + }, + "CLagCompensationManager::RecordDataIntoTrack": { + "text": "Records a player's current per-tick state into the lag compensation history track used for rewinding. Read from the name and the 'RecordDataIntoTrack' anchor; which fields are captured and how deep the track runs are not established.", + "source": "generated" + }, + "CLeaderboardRequestQueue::OnStartNewQuery": { + "text": "Handles the start of a new leaderboard query in the matchmaking library's request queue, setting up the state for that outstanding request. Read from the name; the query parameters and the queue's policy are not established by this data.", + "source": "generated" + }, + "CLightDirectionalEntity::CLightDirectionalEntity": { + "text": "Constructor for the directional light entity, initializing an instance of the sun-style light used by map lighting. Read from the name; the defaults it writes are not established here.", + "source": "generated" + }, + "CLightQueryGameSystem::OnPostSimulate": { + "text": "Game-system hook for the post-simulate phase that refreshes the light query system's cached results, the lighting samples gameplay code asks for at an entity's position. Anchored verbatim as 'CLightQueryGameSystem::OnPostSimulate' in libserver; exactly what it recomputes each tick is not established.", + "source": "generated" + }, + "CLineBatchLayoutInfo::GetCopy": { + "text": "Hands back a duplicate of a batched line's layout information so a caller can keep or mutate it independently of the original. Class is implied by the name; the slot is unbound, so how deep the copy goes and who owns it are unverified.", + "source": "generated" + }, + "CLineBatchLayoutInfo::Render": { + "text": "Draws the batched line layout, emitting its laid-out text run for display. Class is implied by the name, and with no bound owner the draw target and coordinate space are unverified.", + "source": "generated" + }, + "CLineBatchLayoutInfo::~CLineBatchLayoutInfo": { + "text": "Destroys a CLineBatchLayoutInfo, releasing the batched layout state it holds. Class is implied by the name; ordinary destructor duties are the reading, and exactly what gets freed is unverified.", + "source": "generated" + }, + "CLineLayoutInfo::GetCopy": { + "text": "Hands back a duplicate of a single line's layout information, giving the caller an independent instance to hold or modify. Class is implied by the name; with the slot unbound, copy depth and ownership are unverified.", + "source": "generated" + }, + "CLineLayoutInfo::Render": { + "text": "Draws the line layout it describes, emitting that line's laid-out text for display. Class is implied by the name; the slot is unbound, so the draw target and coordinate space are unverified.", + "source": "generated" + }, + "CLineLayoutInfo::~CLineLayoutInfo": { + "text": "Destroys a CLineLayoutInfo, releasing the per-line layout state it holds. Class is implied by the name; destructor behaviour is the reading and what it frees is unverified.", + "source": "generated" + }, + "CLoadBackupIssue::GetDetailsString": { + "text": "Builds the explanatory text for a problem hit while loading a match backup; the anchor `callvote %s ` shows it hands back the callvote syntax that names a backup file. Useful when telling players why a backup restore was not accepted.", + "source": "generated" + }, + "CLocalize::AddFile": { + "text": "Loads a localization token file into the localization system so its string keys resolve on lookup. Read from the name and its home in liblocalize; the accepted path form and language handling are not established here.", + "source": "generated" + }, + "CLoggingSystem::LogDirect": { + "text": "Writes a message straight into tier0's logging system rather than through a convenience wrapper. The binary ships this same code under CLoggingSystem::RegisterLoggingChannel as well, so one of the two names is misattributed and the real behaviour should be confirmed before hooking.", + "source": "generated" + }, + "CLoggingSystem::RegisterLoggingChannel": { + "text": "Registers a named logging channel with tier0's logging system so output can be filtered by channel. This name resolves to the same shipped code as CLoggingSystem::LogDirect, so treat the pairing as unresolved and verify which behaviour you actually get.", + "source": "generated" + }, + "CLogicAchievement::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicAchievement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAchievement::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicAchievement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAchievement::InputFireEvent": { + "text": "Handles the `FireEvent` entity-IO input on `CLogicAchievement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAchievement::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CLogicAchievement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicActiveAutosave::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicActiveAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicActiveAutosave::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicActiveAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicActiveAutosave::SaveThink": { + "text": "Runs the recurring check behind the active autosave, taking a save once the watched health condition in m_TriggerHitPoints has held for m_flTimeToTrigger from m_flStartTime. Read from the name and those fields, so the precise test and cadence are unverified.", + "source": "generated" + }, + "CLogicActiveAutosave::~CLogicActiveAutosave": { + "text": "Tears down a CLogicActiveAutosave, releasing the autosave-tracking state held in fields such as m_flStartTime and m_flDangerousTime. Class is implied by the name; destructor duties are the reading and what it frees is unverified.", + "source": "generated" + }, + "CLogicActivityEvent::InputFireEvent": { + "text": "Handles the `FireEvent` entity-IO input on `CLogicActivityEvent`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAutosave::InputSave": { + "text": "Handles the `Save` entity-IO input on `CLogicAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAutosave::InputSaveDangerous": { + "text": "Handles the `SaveDangerous` entity-IO input on `CLogicAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAutosave::InputSetMinHitpointsThreshold": { + "text": "Handles the `SetMinHitpointsThreshold` entity-IO input on `CLogicAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAutosave::~CLogicAutosave": { + "text": "Tears down a CLogicAutosave, releasing its configured save state including m_bForceNewLevelUnit and m_minHitPoints. Class is implied by the name; destructor behaviour is the reading and the exact cleanup is unverified.", + "source": "generated" + }, + "CLogicBranch::DrawDebugTextOverlays": { + "text": "Adds the branch entity's state to its on-screen debug overlay text, printing `Branch value: %s` for the stored m_bInValue. Reach for it when inspecting why a branch reads true or false through entity debug overlays.", + "source": "generated" + }, + "CLogicBranch::InputSetValue": { + "text": "Handles the `SetValue` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranch::InputSetValueTest": { + "text": "Handles the `SetValueTest` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranch::InputTest": { + "text": "Handles the `Test` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranch::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranch::InputToggleTest": { + "text": "Handles the `ToggleTest` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranchList::DrawDebugTextOverlays": { + "text": "Prints each watched branch's name and value into the entity's debug overlay text using `Branch (%s): %s`, covering the entries in m_nLogicBranchNames. Handy for spotting which member branch is holding the list in the mixed state recorded by m_eLastState.", + "source": "generated" + }, + "CLogicBranchList::InputTest": { + "text": "Handles the `Test` entity-IO input on `CLogicBranchList`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranchList::Input_OnLogicBranchChanged": { + "text": "Handles the `_OnLogicBranchChanged` entity-IO input on `CLogicBranchList`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranchList::Input_OnLogicBranchRemoved": { + "text": "Handles the `_OnLogicBranchRemoved` entity-IO input on `CLogicBranchList`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCase::InputPickRandom": { + "text": "Handles the `PickRandom` entity-IO input on `CLogicCase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCase::InputPickRandomShuffle": { + "text": "Handles the `PickRandomShuffle` entity-IO input on `CLogicCase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCase::InputResetShuffle": { + "text": "Handles the `ResetShuffle` entity-IO input on `CLogicCase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCase::InputValue": { + "text": "Handles the `InValue` entity-IO input on `CLogicCase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCollisionPair::InputDisableCollisions": { + "text": "Handles the `DisableCollisions` entity-IO input on `CLogicCollisionPair`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCollisionPair::InputDisableCollisionsWith": { + "text": "Handles the `DisableCollisionsWith` entity-IO input on `CLogicCollisionPair`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCollisionPair::InputEnableCollisions": { + "text": "Handles the `EnableCollisions` entity-IO input on `CLogicCollisionPair`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCollisionPair::~CLogicCollisionPair": { + "text": "Destroys a CLogicCollisionPair, dropping the paired-entity collision state described by m_nameAttach1 and m_nameAttach2. Class is implied by the name; whether it restores collisions the pair had disabled is unverified.", + "source": "generated" + }, + "CLogicCompare::DrawDebugTextOverlays": { + "text": "Adds the comparison entity's numbers to its debug overlay text, printing ` Compare Value: %f` for m_flCompareValue next to the input in m_flInValue. Useful when a compare entity's result does not match what you expect.", + "source": "generated" + }, + "CLogicCompare::InputCompare": { + "text": "Handles the `Compare` entity-IO input on `CLogicCompare`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCompare::InputSetCompareValue": { + "text": "Handles the `SetCompareValue` entity-IO input on `CLogicCompare`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCompare::InputSetValue": { + "text": "Handles the `SetValue` entity-IO input on `CLogicCompare`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCompare::InputSetValueCompare": { + "text": "Handles the `SetValueCompare` entity-IO input on `CLogicCompare`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicDistanceAutosave::InputSave": { + "text": "Handles the `Save` entity-IO input on `CLogicDistanceAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicDistanceAutosave::InputSaveDangerous": { + "text": "Handles the `SaveDangerous` entity-IO input on `CLogicDistanceAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicDistanceAutosave::SaveThink": { + "text": "Runs the recurring check behind the distance-based autosave, weighing the entity named in m_iszTargetEntity against m_flDistanceToPlayer and saving when the player is near enough. Read from the name and fields at low confidence, so the exact trigger test and interval are unverified.", + "source": "generated" + }, + "CLogicDistanceCheck::InputCheckDistance": { + "text": "Handles the `CheckDistance` entity-IO input on `CLogicDistanceCheck`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicEventListener::FireGameEvent": { + "text": "Handles a fired game event, matching it against m_strEventName while m_bIsEnabled is set and driving the m_OnEventFired output. Class is implied by the name; the slot is unbound, so the matching rule and the team filter in m_nTeam are unverified.", + "source": "generated" + }, + "CLogicGameEventListener::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicGameEventListener`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicGameEventListener::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicGameEventListener`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicGameEventListener::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CLogicGameEventListener`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicGameStateReport::SetGameStateReportThink": { + "text": "Sets up the recurring think that produces the entity's game-state report, subject to m_bDisabled. Read from the name at low confidence; the report's contents, destination and interval are not established here.", + "source": "generated" + }, + "CLogicMeasureMovement::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetMeasureReference": { + "text": "Handles the `SetMeasureReference` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetMeasureTarget": { + "text": "Handles the `SetMeasureTarget` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetTarget": { + "text": "Handles the `SetTarget` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetTargetReference": { + "text": "Handles the `SetTargetReference` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetTargetScale": { + "text": "Handles the `SetTargetScale` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::~CLogicMeasureMovement": { + "text": "Destroys a CLogicMeasureMovement, releasing the measure and target handles m_hMeasureTarget, m_hMeasureReference, m_hTarget and m_hTargetReference. Class is implied by the name; whether the driven target is detached rather than merely dropped is unverified.", + "source": "generated" + }, + "CLogicNPCCounter::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicNPCCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicNPCCounter::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicNPCCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicNPCCounter::InputSetSourceEntity": { + "text": "Handles the `SetSourceEntity` entity-IO input on `CLogicNPCCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicNavigation::~CLogicNavigation": { + "text": "Destroys a CLogicNavigation, dropping the navigation state kept in m_isOn and m_navProperty. Class is implied by the name; whether the property it toggled is restored on teardown is unverified.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeConsole` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Tears down a console loop-mode instance this factory produced, freeing it when the engine no longer needs that mode. Class is implied by the name; the slot is unbound, so ownership and any reuse of the freed instance are unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type tag this factory produces, identifying it as the console loop mode. Class is implied by the name; with the slot unbound, the exact identifier it yields is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Brings the console loop-mode factory into a usable state; beyond that, the purpose is not established. Class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the console loop-mode factory down, releasing whatever it holds. Class is implied by the name, and what it actually tears down is not established.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeInGameUI` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Tears down an in-game UI loop-mode instance this factory produced, freeing it when that mode is finished with. Class is implied by the name; the slot is unbound, so ownership and reuse of the freed instance are unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type tag this factory produces, identifying it as the in-game UI loop mode. Class is implied by the name; with the slot unbound, the exact identifier it yields is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Brings the in-game UI loop-mode factory into a usable state; beyond that, the purpose is not established. Class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the in-game UI loop-mode factory down, releasing whatever it holds. Class is implied by the name, and what it actually tears down is not established.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeLevelLoad` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Tears down a level-load loop-mode instance this factory produced, freeing it once loading no longer needs that mode. Class is implied by the name; the slot is unbound, so ownership and reuse of the freed instance are unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type tag this factory produces, identifying it as the level-load loop mode. Class is implied by the name; with the slot unbound, the exact identifier it yields is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Brings the level-load loop-mode factory into a usable state; beyond that, the purpose is not established. Class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the level-load loop-mode factory down, releasing whatever it holds. Class is implied by the name, and what it actually tears down is not established.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeMainMenu` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Tears down and releases a main-menu loop mode instance the factory produced, pairing with CLoopModeFactory::CreateLoopMode. The owning class is implied by the name rather than established by the data, so the concrete teardown steps are unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type tag this factory produces, identifying it as the main-menu loop as distinct from other loop modes. The owning class is implied by the name, and how the type is expressed is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Startup initialization for the main-menu loop mode factory; beyond generic setup, purpose is not established. The owning class is implied by the name rather than by the data.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the main-menu loop mode factory down and releases what it holds, pairing with CLoopModeFactory::Init. The owning class is implied by the name, and the actual teardown work is unverified.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeRemoteConnect` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Tears down and releases a remote-connect loop mode instance the factory produced, pairing with CLoopModeFactory::CreateLoopMode. The owning class is implied by the name rather than established by the data, so the concrete teardown steps are unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type tag this factory produces, identifying the remote-connect loop as distinct from other loop modes. The owning class is implied by the name, and how the type is expressed is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Startup initialization for the remote-connect loop mode factory; beyond generic setup, purpose is not established. The owning class is implied by the name rather than by the data.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the remote-connect loop mode factory down and releases what it holds, pairing with CLoopModeFactory::Init. The owning class is implied by the name, and the actual teardown work is unverified.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeSourceTVRelay` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Tears down and releases a SourceTV relay loop mode instance the factory produced, pairing with CLoopModeFactory::CreateLoopMode. The owning class is implied by the name rather than established by the data, so the concrete teardown steps are unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type tag this factory produces, identifying the SourceTV relay loop as distinct from other loop modes. The owning class is implied by the name, and how the type is expressed is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Startup initialization for the SourceTV relay loop mode factory; beyond generic setup, purpose is not established. The owning class is implied by the name rather than by the data.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the SourceTV relay loop mode factory down and releases what it holds, pairing with CLoopModeFactory::Init. The owning class is implied by the name, and the actual teardown work is unverified.", + "source": "generated" + }, + "CLoopModeGame::AddViewsToSceneSystem": { + "text": "Submits the game loop mode's views to the scene system for rendering, anchored by the literal string 'AddViewsToSceneSystem' in libserver. Read from that anchor and the name; which views it contributes, and under what conditions, is unverified.", + "source": "generated" + }, + "CLoopModeGame::CLoopModeGame": { + "text": "Constructs the game loop mode object and logs '%s: CLoopModeGame constructed' while doing so, making that line a usable marker for when a game loop mode comes into existence. The setup the constructor performs on the object is unverified.", + "source": "generated" + }, + "CLoopModeGame::OnFirstMapLoaded": { + "text": "Handles the game loop mode's first-map-load event, logging '%s: CLoopModeGame::OnFirstMapLoaded'. Read from that anchor and the name, so the one-time work it performs when the first map finishes loading is unverified.", + "source": "generated" + }, + "CLoopModeGame::StaticInit": { + "text": "Performs class-level, one-time initialization for the game loop mode, emitting the marker string 'CLoopModeGame::StaticInit-start'. Read from that anchor and the name; the specific state it prepares is unverified.", + "source": "generated" + }, + "CLoopModeGame::~CLoopModeGame": { + "text": "Destructor for the game loop mode, releasing the object's resources when the in-game loop is torn down. The owning class is implied by the name; the cleanup it performs is unverified.", + "source": "generated" + }, + "CLoopModeLevelLoad::MaybeSwitchToGameLoop": { + "text": "Tests whether the level-load loop mode should leave loading behind for the in-game loop and performs that switch when the test holds \u2014 'Maybe' marks it conditional. The owning class is implied by the name, and the condition it evaluates is unverified.", + "source": "generated" + }, + "CLoopModeLevelLoad::OnLoopActivate": { + "text": "Handles the level-load loop mode becoming the active loop, the hook where loading-screen-time state would be prepared. The owning class is implied by the name, and what it actually initializes on activation is unverified.", + "source": "generated" + }, + "CLoopTypeClientServer::AllocateLoopMode": { + "text": "Allocates a loop mode object for the combined client/server loop type, the allocation side of loop mode lifetime management. The owning class is implied by the name, and which loop mode it produces for a given request is unverified.", + "source": "generated" + }, + "CLoopTypeClientServer::PollAndProcessInput": { + "text": "Polls pending input for the client/server loop type and processes the events it finds. Read from the name and its presence in libengine2; the input sources it drains and the handling it applies are unverified.", + "source": "generated" + }, + "CLuaVM::AddSearchPath": { + "text": "Registers an extra filesystem search path the VM consults when resolving script files to load. The class is implied by the name, and no prototype is derived, so the accepted path form and its scope are unverified.", + "source": "generated" + }, + "CLuaVM::AreHandlesEqual": { + "text": "Compares two script-value handles and reports whether they refer to the same underlying script object, letting native code test identity rather than contents. The class is implied by the name, and no prototype is derived, so the comparison's exact semantics are unverified.", + "source": "generated" + }, + "CLuaVM::ArrayAddToTail": { + "text": "Appends a value to the end of a script array, the usual way native code grows a script-visible list. The class is implied by the name; a prototype is derived, but the behavior itself is still a name-level reading.", + "source": "generated" + }, + "CLuaVM::ClearValue": { + "text": "Clears a stored script value, resetting or releasing whatever the target slot held. The class is implied by the name, and no prototype is derived, so which slot is targeted and whether anything is freed are unverified.", + "source": "generated" + }, + "CLuaVM::CollectGarbage": { + "text": "Triggers a garbage-collection pass in the script VM to reclaim unreferenced script objects, useful for controlling when collection cost lands. The class is implied by the name; a prototype is derived, though whether the pass is full or incremental is unverified.", + "source": "generated" + }, + "CLuaVM::CompileScript": { + "text": "Compiles script source into an executable form held by the VM, separate from running it. The class is implied by the name, and no prototype is derived, so the input form and how compile errors surface are unverified.", + "source": "generated" + }, + "CLuaVM::ConvertFromScriptTable": { + "text": "Converts a script table into a native representation that engine-side code can consume. The class is implied by the name, and no prototype is derived, so the destination type and the conversion rules are unverified.", + "source": "generated" + }, + "CLuaVM::CopyHandle": { + "text": "Duplicates a script-value handle so a second reference to the same script object exists. The class is implied by the name, and no prototype is derived, so whether a reference count is taken is unverified.", + "source": "generated" + }, + "CLuaVM::CopyValue": { + "text": "Copies a script value from one location into another. The class is implied by the name, and no prototype is derived, so whether the copy is deep or shallow, and what the endpoints are, remain unverified.", + "source": "generated" + }, + "CLuaVM::CreateArray": { + "text": "Creates a new script array object inside the VM for the caller to populate. The class is implied by the name, and no prototype is derived, so initial sizing and who owns the result are unverified.", + "source": "generated" + }, + "CLuaVM::CreateFromScriptTableInternal": { + "text": "Constructs a native object from a script table, in the internal (non-public) form of that conversion. The class is implied by the name, and no prototype is derived, so the object type produced and its lifetime are unverified.", + "source": "generated" + }, + "CLuaVM::CreateKeyValuesFromTable": { + "text": "Builds a KeyValues structure from a script table, letting script-authored data feed engine systems that expect KeyValues. The class is implied by the name, and no prototype is derived, so nesting rules and ownership of the result are unverified.", + "source": "generated" + }, + "CLuaVM::CreateScope": { + "text": "Creates a script scope, an isolated environment scripts execute within so separate scripts do not collide in shared globals. The class is implied by the name; a prototype is derived, but the isolation guarantees are unverified.", + "source": "generated" + }, + "CLuaVM::CreateTable": { + "text": "Creates a new script table object inside the VM for the caller to fill in. The class is implied by the name, and no prototype is derived, so ownership and lifetime of the result are unverified.", + "source": "generated" + }, + "CLuaVM::DumpState": { + "text": "Dumps the VM's current state for inspection, the kind of thing reached for when debugging misbehaving scripts. The class is implied by the name, and no prototype is derived, so the output destination and level of detail are unverified.", + "source": "generated" + }, + "CLuaVM::EnableLocalDiskAccess": { + "text": "Concerns whether the VM may read scripts and data from local disk rather than only from packaged content, which matters during local development. The class is implied by the name; a prototype is derived, but whether it sets or merely reports the setting is unverified.", + "source": "generated" + }, + "CLuaVM::ExecuteFunction": { + "text": "Runs a script function inside the VM and yields its result to native code. The class is implied by the name, and no prototype is derived, so the scope it runs in and how errors are reported are unverified.", + "source": "generated" + }, + "CLuaVM::ForwardConsoleCommand": { + "text": "Forwards a console command into the script layer so scripts can react to console input. The class is implied by the name, and no prototype is derived, so which commands qualify and how they are matched are unverified.", + "source": "generated" + }, + "CLuaVM::Frame": { + "text": "Gives the script VM its periodic per-frame update slice, letting time-based script work advance. The class is implied by the name, and no prototype is derived, so what work is performed each frame is unverified.", + "source": "generated" + }, + "CLuaVM::GenerateUniqueKey": { + "text": "Produces a key that will not collide with keys already in use, for naming generated script entries. The class is implied by the name, and no prototype is derived, so the key format and its uniqueness domain are unverified.", + "source": "generated" + }, + "CLuaVM::GetArrayCount": { + "text": "Reports how many elements a script array currently holds. The class is implied by the name, and no prototype is derived, so behavior when handed a non-array value is unverified.", + "source": "generated" + }, + "CLuaVM::GetId": { + "text": "Retrieves an identifier for the VM or for a script object it holds; the name does not settle which. The class is implied by the name, and no prototype is derived, so what the identifier denotes is unverified.", + "source": "generated" + }, + "CLuaVM::GetInstanceValue": { + "text": "Reads a value out of a registered script instance, letting native code pull a field from a script-side object. The class is implied by the name; a prototype is derived, though the lookup key and the failure behavior are unverified.", + "source": "generated" + }, + "CLuaVM::GetInternalVM": { + "text": "Exposes the underlying interpreter state that CLuaVM wraps, for callers that need the raw VM rather than the wrapper. The class is implied by the name; a prototype is derived, but the exact object handed back is unverified.", + "source": "generated" + }, + "CLuaVM::GetKeyValue": { + "text": "Reads the value stored under a key in a script table. The class is implied by the name, and no prototype is derived, so key typing and what happens on a missing key are unverified.", + "source": "generated" + }, + "CLuaVM::GetLanguage": { + "text": "Reports which scripting language this VM instance runs, as an identifier rather than display text. The class is implied by the name, and no prototype is derived, so the enumeration used is unverified.", + "source": "generated" + }, + "CLuaVM::GetLanguageName": { + "text": "Returns the scripting language's name as text, handy for logging and diagnostic banners. The class is implied by the name; a prototype is derived, but the exact string produced is unverified.", + "source": "generated" + }, + "CLuaVM::GetNumElements": { + "text": "Reports how many elements a script container holds. The class is implied by the name, and no prototype is derived, so which container kinds it accepts, and how it differs from CLuaVM::GetArrayCount, are unverified.", + "source": "generated" + }, + "CLuaVM::GetNumTableEntries": { + "text": "Counts the entries present in a script table. The class is implied by the name, and no prototype is derived, so whether inherited or nil-valued keys are counted is unverified.", + "source": "generated" + }, + "CLuaVM::GetRootTable": { + "text": "Retrieves the VM's root table, the top-level environment where globals live, so callers can read or install global bindings. The class is implied by the name, and no prototype is derived, so whether the result is scope-relative is unverified.", + "source": "generated" + }, + "CLuaVM::GetScalarValue": { + "text": "Reads a scalar, non-container script value out of the VM into native form. The class is implied by the name; a prototype is derived, though which scalar types are handled is unverified.", + "source": "generated" + }, + "CLuaVM::GetValue": { + "text": "Reads a script value generally, the broad counterpart to the narrower CLuaVM::GetScalarValue. The class is implied by the name, and no prototype is derived, so what it accepts and what it yields are unverified.", + "source": "generated" + }, + "CLuaVM::Init": { + "text": "Initializes the CLuaVM instance; beyond that, purpose is not established by this data. The class is implied by the name, and although a prototype is derived, nothing here specifies what the initialization sets up.", + "source": "generated" + }, + "CLuaVM::IsArray": { + "text": "Tests whether a script value is an array. The class is implied by the name, and no prototype is derived, so how it distinguishes arrays from ordinary tables is unverified.", + "source": "generated" + }, + "CLuaVM::IsTable": { + "text": "Tests whether a script value is a Lua table, so native code can check a handle's kind before treating it as one. The CLuaVM class is implied by the name; no prototype is derived, so the input it accepts and the meaning of a negative answer are unverified.", + "source": "generated" + }, + "CLuaVM::LoadAndCompileScriptFile": { + "text": "Loads a Lua source file and compiles it into the VM in one step, the usual way a mod brings a script off disk and makes it runnable. The CLuaVM class is implied by the name; no prototype is derived, so the path form expected and the handling of compile errors are unverified.", + "source": "generated" + }, + "CLuaVM::LookupFunction": { + "text": "Finds a named Lua function in the VM so native code can hold a reference to it and call it later. A prototype is verified for this entry, but the CLuaVM class is implied by the name, so the scope it searches remains a name-level reading.", + "source": "generated" + }, + "CLuaVM::NuggetManager": { + "text": "Purpose is not established by the name, which reads as an accessor for some manager object rather than a described operation. The CLuaVM class is implied by the name.", + "source": "generated" + }, + "CLuaVM::RaiseException": { + "text": "Raises a script-level error inside the VM, surfacing a failure to the running Lua code rather than reporting it natively. The CLuaVM class is implied by the name; no prototype is derived, so the message it carries and how the error is reported are unverified.", + "source": "generated" + }, + "CLuaVM::ReadState": { + "text": "Restores the VM's script state from a serialized buffer, the load side of script-state persistence and the counterpart to CLuaVM::WriteState. A prototype is verified, but the CLuaVM class is implied by the name, so the state format and what it covers stay a name-level reading.", + "source": "generated" + }, + "CLuaVM::ReferenceScope": { + "text": "Takes a reference on a script scope, keeping that scope alive while native code holds it. A prototype is verified for this entry, but the CLuaVM class is implied by the name, so the ownership semantics are a name-level reading.", + "source": "generated" + }, + "CLuaVM::RegisterFunction": { + "text": "Exposes a native function to Lua under a script-visible name, the main way a mod adds new callable API inside the VM. A prototype is verified, but the CLuaVM class is implied by the name, so the binding conventions it expects are unverified.", + "source": "generated" + }, + "CLuaVM::RegisterInstance": { + "text": "Binds a native object instance into the script environment so Lua code can reach it and call methods on it. The CLuaVM class is implied by the name; no prototype is derived, so the class registration it requires and the lifetime of the binding are unverified.", + "source": "generated" + }, + "CLuaVM::RegisterScriptClass": { + "text": "Declares a native class to the VM so its instances can be exposed to Lua with methods and members visible from script. A prototype is verified, but the CLuaVM class is implied by the name, so the descriptor it expects is a name-level reading.", + "source": "generated" + }, + "CLuaVM::ReleaseFunction": { + "text": "Drops a held function reference, freeing the VM's hold on that Lua function. A prototype is verified, but the CLuaVM class is implied by the name, so whether it also invalidates handles duplicated via CLuaVM::CopyHandle is unverified.", + "source": "generated" + }, + "CLuaVM::ReleaseScope": { + "text": "Releases a script scope, dropping the VM-side reference so the scope's contents can be collected. The CLuaVM class is implied by the name; no prototype is derived, so its relationship to scopes made by CLuaVM::CreateScope is unverified.", + "source": "generated" + }, + "CLuaVM::ReleaseScript": { + "text": "Frees a compiled script, discarding the VM's compiled chunk and the resources kept for it. The CLuaVM class is implied by the name; no prototype is derived, so what identifies the script and what happens to code already running from it are unverified.", + "source": "generated" + }, + "CLuaVM::ReleaseValue": { + "text": "Releases a script value reference so the VM can reclaim the underlying Lua value. The CLuaVM class is implied by the name; no prototype is derived, so which value kinds it accepts and its behaviour on an already-released value are unverified.", + "source": "generated" + }, + "CLuaVM::RemoveInstance": { + "text": "Unregisters a native object instance from the script environment so Lua no longer resolves it. The CLuaVM class is implied by the name; no prototype is derived, so whether it clears script-side references or only the native binding is unverified.", + "source": "generated" + }, + "CLuaVM::Run": { + "text": "Executes a script in the VM, the step that makes a loaded chunk actually do something. The CLuaVM class is implied by the name; no prototype is derived, so what identifies the script, the scope it executes in, and how failures are reported are unverified.", + "source": "generated" + }, + "CLuaVM::SetEnumValue": { + "text": "Defines a named constant in the script environment, giving Lua a symbolic name for a native enumerated value. The CLuaVM class is implied by the name; no prototype is derived, so the table it writes into and the value forms accepted are unverified.", + "source": "generated" + }, + "CLuaVM::SetErrorCallback": { + "text": "Installs a handler the VM uses when script errors occur, letting a mod route Lua failures into its own logging instead of the default output. The CLuaVM class is implied by the name; no prototype is derived, so what the handler receives and which errors reach it are unverified.", + "source": "generated" + }, + "CLuaVM::SetInstanceUniqueId": { + "text": "Assigns a unique identifier to a registered script instance so bound objects can be told apart and found again. A prototype is verified, but the CLuaVM class is implied by the name, so the scope over which the identifier is unique is a name-level reading.", + "source": "generated" + }, + "CLuaVM::SetOutputCallback": { + "text": "Installs a handler for the VM's script output, so print-style writes from Lua can be captured into a mod's own logging. The CLuaVM class is implied by the name; no prototype is derived, so which output it covers and what the handler receives are unverified.", + "source": "generated" + }, + "CLuaVM::SetValue": { + "text": "Writes a value into a script table or scope under a key, the general way native code pushes data into Lua. A prototype is verified, but the CLuaVM class is implied by the name, so the accepted key and value forms remain a name-level reading.", + "source": "generated" + }, + "CLuaVM::Shutdown": { + "text": "Shuts the VM down, tearing down its script state and releasing what it holds. A prototype is verified, but the CLuaVM class is implied by the name, and the name supports only this general teardown reading; what it frees is unverified.", + "source": "generated" + }, + "CLuaVM::ValueExists": { + "text": "Checks whether a key is present in a script table or scope, so native code can test before reading. A prototype is verified, but the CLuaVM class is implied by the name, so which containers it accepts is a name-level reading.", + "source": "generated" + }, + "CLuaVM::WriteState": { + "text": "Serializes the VM's script state into a buffer for persistence, the save side of the pairing with CLuaVM::ReadState. The CLuaVM class is implied by the name; no prototype is derived, so the format produced and which state is included are unverified.", + "source": "generated" + }, + "CLuaVM::~CLuaVM": { + "text": "Destroys the VM object and cleans up what it owns. The CLuaVM class is implied by the name, and beyond ordinary destruction no further purpose is established by this data.", + "source": "generated" + }, + "CMD_ShowTriggers": { + "text": "Backs the showtriggers console command, which makes trigger volumes visible for debugging map logic. Also shipped as ConCommand::showtriggers at medium confidence; expect it to be cheat-gated on a normal server.", + "source": "generated" + }, + "CMapInfo::KeyValue": { + "text": "Parses keyvalues authored on the map's info entity, with 'bombradius' among the keys it recognises, feeding fields such as m_flBombRadius, m_iHostageCount and m_flEnvWetnessCoverage. Useful when tracing which map-level settings arrive from the map file rather than from convars; the full key set is unverified.", + "source": "generated" + }, + "CMapLoadEntityFilter::ShouldCreateEntity": { + "text": "Decides whether a given map entity is created during load, acting as a per-entity gate so entries can be suppressed before spawning. The owning class is implied by the name, and the criteria it applies are unverified.", + "source": "generated" + }, + "CMapSharedEnvironment::CMapSharedEnvironment": { + "text": "Constructs the shared-environment map entity, which carries m_targetMapName naming the map whose environment settings are shared. Read from the name and the 'CMapSharedEnvironment' anchor in libserver; what the constructor initializes is unverified.", + "source": "generated" + }, + "CMapSpawnGroup::OnPostSpawnGroupLoad": { + "text": "Runs the map spawn group's post-load handling and warns 'Misconfigured CInfoSpawnGroupLoadUnload(%d), couldn't find landmark named %s' when the referenced landmark does not resolve. Useful when debugging sub-map spawn groups that load without appearing where expected; the rest of its post-load work is unverified.", + "source": "generated" + }, + "CMapVetoPickController::VoteControllerThink": { + "text": "Drives the periodic update of the map veto/pick draft, working with the phase state m_nCurrentPhase, m_nPhaseStartTick and m_nPhaseDurationTicks alongside outputs m_OnMapVetoed, m_OnMapPicked and m_OnSidesPicked. Read from the name and those fields; the timing rules it applies are unverified.", + "source": "generated" + }, + "CMarkupVolume::CMarkupVolume": { + "text": "Constructs a markup volume \u2014 a world volume that tags a region for gameplay or tooling queries \u2014 whose m_bDisabled field gates whether the volume counts. Read from the name, so the constructor's initialization work is unverified.", + "source": "generated" + }, + "CMarkupVolumeTagged::CMarkupVolumeTagged": { + "text": "Constructs the tagged markup volume variant, which carries m_Tags and m_GroupNames plus the grouping flags m_bIsGroup, m_bGroupByPrefab, m_bGroupByVolume and m_bIsInGroup. Read from the name and those fields; what the constructor sets up is unverified.", + "source": "generated" + }, + "CMarkupVolumeWithRef::CMarkupVolumeWithRef": { + "text": "Constructs the reference-point markup volume variant, whose m_bUseRef, m_vRefPosEntitySpace, m_vRefPosWorldSpace and m_flRefDot fields define a reference position and a dot-product threshold for directional tests. Read from the name and the 'CMarkupVolumeWithRef' anchor; the constructor's own work is unverified.", + "source": "generated" + }, + "CMatchFramework::OnMatchSessionUpdate": { + "text": "Handles a match session state update inside the matchmaking framework, the notification point for session changes such as players joining or session settings changing. The owning class is implied by the name, and what it does with the update is unverified.", + "source": "generated" + }, + "CMaterialSystem2::FrameUpdate": { + "text": "Advances the material system by one frame, performing its per-frame material bookkeeping. The owning class is implied by the name, and the work carried out each frame is unverified.", + "source": "generated" + }, + "CMaterialTypeManager::GetErrorMaterial": { + "text": "Supplies the fallback error material the material type manager uses when a requested material is missing or fails to load \u2014 the source of the familiar missing-material look. The owning class is implied by the name; whether it creates or caches that material is unverified.", + "source": "generated" + }, + "CMaterialTypeManager::Init": { + "text": "Startup initialization for the material type manager; beyond generic setup, purpose is not established. The owning class is implied by the name rather than by the data.", + "source": "generated" + }, + "CMathColorBlend::InputValue": { + "text": "Handles the `InValue` entity-IO input on `CMathColorBlend`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::DrawDebugTextOverlays": { + "text": "Draws the counter entity's debug text overlay, printing lines including ' max value: %f' from m_flMax alongside m_flMin. Useful when inspecting a counter's clamp range through the in-game entity debug overlays; the remaining overlay contents are unverified.", + "source": "generated" + }, + "CMathCounter::InputAdd": { + "text": "Handles the `Add` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputDivide": { + "text": "Handles the `Divide` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputGetValue": { + "text": "Handles the `GetValue` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputMultiply": { + "text": "Handles the `Multiply` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSetHitMax": { + "text": "Handles the `SetHitMax` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSetHitMin": { + "text": "Handles the `SetHitMin` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSetValue": { + "text": "Handles the `SetValue` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSetValueNoFire": { + "text": "Handles the `SetValueNoFire` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSubtract": { + "text": "Handles the `Subtract` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathRemap::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CMathRemap`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathRemap::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CMathRemap`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathRemap::InputValue": { + "text": "Handles the `InValue` entity-IO input on `CMathRemap`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMeshRayTrace::AddRef": { + "text": "Increments the reference count on a mesh ray-trace object so it stays alive while a caller holds it. The CMeshRayTrace class is implied by the name, and the refcount reading comes from the name alone.", + "source": "generated" + }, + "CMeshRayTrace::GetMeshTraceData": { + "text": "Returns the mesh trace data a ray query is run against \u2014 the geometry payload the tracer consumes. The CMeshRayTrace class is implied by the name, and what the returned data actually contains is a name-level reading.", + "source": "generated" + }, + "CMeshRayTrace::GetRayTracingEnvironment": { + "text": "Returns the ray-tracing environment the object traces into, the accelerated structure holding traceable geometry. The CMeshRayTrace class is implied by the name, and the shape of that environment is not established here.", + "source": "generated" + }, + "CMeshRayTrace::IsOutOfDate": { + "text": "Reports whether the cached ray-trace data has gone stale against its source mesh, so a caller can rebuild before tracing. The CMeshRayTrace class is implied by the name, and the staleness criterion is a name-level reading.", + "source": "generated" + }, + "CMeshRayTrace::Release": { + "text": "Drops a reference to the mesh ray-trace object, freeing it once the last holder lets go. The CMeshRayTrace class is implied by the name, and the release semantics are read from the name.", + "source": "generated" + }, + "CMeshRayTrace::~CMeshRayTrace": { + "text": "Destroys a mesh ray-trace object, tearing down the trace data and acceleration state it owns. The CMeshRayTrace class is implied by the name, and what the teardown frees is not established here.", + "source": "generated" + }, + "CMeshUtils::Connect": { + "text": "Hands the mesh-utilities module its interface factory so it can bind the engine interfaces it depends on. The CMeshUtils class is implied by the name, and which interfaces get bound is a name-level reading.", + "source": "generated" + }, + "CMeshUtils::CreateSkeletonSceneObject": { + "text": "Creates a scene object for a skeleton \u2014 the renderable pairing of mesh data with a CSkeletonInstance. The CMeshUtils class is implied by the name; reach for it when building mesh-side render state for an animated model, though what the created object holds is unverified.", + "source": "generated" + }, + "CMeshUtils::Disconnect": { + "text": "Releases the engine interfaces the mesh-utilities module had bound, undoing its connection to the rest of the system. The CMeshUtils class is implied by the name, and the reading comes from the name.", + "source": "generated" + }, + "CMeshUtils::GetBuildType": { + "text": "Reports the build type the mesh-utilities module identifies itself as. The CMeshUtils class is implied by the name, and what the build-type value encodes is not established here.", + "source": "generated" + }, + "CMeshUtils::GetDependencies": { + "text": "Reports the modules or interfaces the mesh-utilities module requires to be present. The CMeshUtils class is implied by the name, and the form of that dependency listing is a name-level reading.", + "source": "generated" + }, + "CMeshUtils::GetTier": { + "text": "Reports which engine tier the mesh-utilities module belongs to, the layering rank the module system uses. The CMeshUtils class is implied by the name, and the tier values themselves are not established here.", + "source": "generated" + }, + "CMeshUtils::Init": { + "text": "Initializes the mesh-utilities module; beyond that the name does not establish what it sets up. The CMeshUtils class is implied by the name.", + "source": "generated" + }, + "CMeshUtils::IsSingleton": { + "text": "Reports whether the mesh-utilities module is a singleton \u2014 whether one shared instance serves every caller. The CMeshUtils class is implied by the name, and the answer's meaning is read from the name.", + "source": "generated" + }, + "CMeshUtils::PreShutdown": { + "text": "Runs the mesh-utilities module's early teardown stage, the pass that lets it wind work down while the system is still up. The CMeshUtils class is implied by the name, and what this stage releases is a name-level reading.", + "source": "generated" + }, + "CMeshUtils::QueryInterface": { + "text": "Looks up and returns an interface exposed by the mesh-utilities module, the standard way engine modules publish functionality to callers. The CMeshUtils class is implied by the name, and the lookup key and result are name-level readings.", + "source": "generated" + }, + "CMeshUtils::Reconnect": { + "text": "Rebinds an engine interface the mesh-utilities module uses, letting it pick up a replacement without a full teardown. The CMeshUtils class is implied by the name, and the rebinding details are read from the name.", + "source": "generated" + }, + "CMeshUtils::Shutdown": { + "text": "Shuts the mesh-utilities module down, releasing the resources it holds. The CMeshUtils class is implied by the name, and what gets torn down is not established here.", + "source": "generated" + }, + "CMessage::GetDataDescMap": { + "text": "Returns the data-description map for the message entity, the table tying its keyvalues and inputs to fields such as m_iszMessage, m_MessageVolume and m_Radius. The CMessage class is implied by the name, and the map's exact contents are a name-level reading.", + "source": "generated" + }, + "CMessage::InputShowMessage": { + "text": "Handles the `ShowMessage` entity-IO input on `CMessage`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMessageEntity::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CMessageEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMessageEntity::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CMessageEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMessageEntity::InputSetMessage": { + "text": "Handles the `SetMessage` entity-IO input on `CMessageEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CModelPointEntity::CModelPointEntity": { + "text": "Constructs a CModelPointEntity, the point-entity base that carries a model. Read from the name; what the constructor initialises is not established here.", + "source": "generated" + }, + "CModelState::DoSetupPhysics": { + "text": "Sets up the physics representation for a model's state \u2014 the collision and aggregate side of a renderable model. The name appears verbatim as a string anchor in the binary; m_hModel and m_pVPhysicsAggregate are the fields a reader would pair with it, though the exact work done stays a name-level reading.", + "source": "generated" + }, + "CModelTypeManager::FinalizeResource": { + "text": "Finalizes a loaded model resource so the manager can hand it out as usable. The CModelTypeManager class is implied by the name, and what finalization involves is a name-level reading.", + "source": "generated" + }, + "CModelTypeManager::GetErrorModel": { + "text": "Returns the fallback error model the manager substitutes when a requested model is missing or fails to load \u2014 the stand-in geometry you see instead of the real asset. The CModelTypeManager class is implied by the name, and the substitution behaviour is read from the name.", + "source": "generated" + }, + "CMolotovGrenade::EmitGrenade": { + "text": "Emits the molotov's thrown projectile from the weapon, the point at which the held grenade becomes a world entity. The CMolotovGrenade class is implied by the name, and the emission details are a name-level reading.", + "source": "generated" + }, + "CMolotovProjectile::BounceSound": { + "text": "Plays the projectile's bounce sound; the sound-event name \"IncGrenade.Bounce\" is anchored inside this function, so the incendiary-flavoured bounce audio is what it emits. Pair it with m_bIsIncGrenade if you need to tell the incendiary and molotov variants apart.", + "source": "generated" + }, + "CMolotovProjectile::EmitGrenade": { + "text": "Creates and emits the molotov projectile as a world entity, a reading taken from the name. The same function also ships under the name CMolotovProjectile_CreateFunc, so hooking either one hooks a single target; m_bIsIncGrenade, m_bDetonated and m_stillTimer hold the projectile's own state.", + "source": "generated" + }, + "CMolotovProjectile_CreateFunc": { + "text": "Creates and launches a molotov projectile into the world. Shipped also as CMolotovProjectile::EmitGrenade at medium confidence; hook it to change how incendiaries spawn or to detect thrown molotovs server-side.", + "source": "generated" + }, + "CMomentaryRotButton::DrawDebugTextOverlays": { + "text": "Draws debug text overlays for the rotating button, emitting formatted lines such as \"AVelocity: %.2f %.2f %.2f\" for its angular velocity. Enable it when debugging the button's motion against m_Position, m_IdealYaw and m_direction; the anchor confirms the angular-velocity readout, the rest is read from the name.", + "source": "generated" + }, + "CMomentaryRotButton::InputSetPosition": { + "text": "Handles the map input that commands the rotating button to a position, driving it toward the value tracked in m_Position. The anchored string \"_DisableUpdateTarget\" points at the m_bUpdateTarget flag this path manipulates, with m_start, m_end and m_returnSpeed shaping the travel; anything beyond that is a name-level reading.", + "source": "generated" + }, + "CMoverEntitySpawner::SpawnThink": { + "text": "Runs the spawner's periodic think, the tick on which it spawns mover entities. Read from the name; the spawn interval, the conditions, and what exactly gets spawned are not established here.", + "source": "generated" + }, + "CMoverPathNode::ParentedMoveThink": { + "text": "Runs the path node's think while the node is parented to a moving object, keeping it in step with that parent. Read from the name; the node's outputs m_OnPassThrough, m_OnPassThroughForward and m_OnPassThroughReverse are what map logic hangs off, though this function's exact role in firing them is unverified.", + "source": "generated" + }, + "CMultiLightProxy::InputDisableLights": { + "text": "Handles the `DisableLights` entity-IO input on `CMultiLightProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMultiLightProxy::InputFlickerLights": { + "text": "Handles the `FlickerLights` entity-IO input on `CMultiLightProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMultiLightProxy::InputSetBrightnessDelta": { + "text": "Handles the `SetBrightnessDelta` entity-IO input on `CMultiLightProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMultiLightProxy::InputSetLightsBrightnessMultiplier": { + "text": "Handles the `SetLightsBrightnessMultiplier` entity-IO input on `CMultiLightProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMultiLightProxy::RestoreFlashlightThink": { + "text": "Runs a think that restores lights the proxy had altered back toward their original brightness. Read from the name; m_flCurrentBrightnessMultiplier and m_flTargetBrightnessMultiplier track that restore, and m_vecLights holds the CLightEntity handles it acts on.", + "source": "generated" + }, + "CMultiplayRules::CMultiplayRules": { + "text": "Constructs the multiplayer rules object, the gamerules base that multiplayer modes build on. Read from the name; what the constructor sets up is not established here.", + "source": "generated" + }, + "CMultiplayRules::~CMultiplayRules": { + "text": "Destroys the multiplayer rules object, tearing down the gamerules state it owns. The CMultiplayRules class is implied by the name, and what the teardown releases is not established here.", + "source": "generated" + }, + "CNameIndex::AcquirePreindexedName": { + "text": "Acquires a name already present in the index, handing back its existing entry instead of interning the string afresh \u2014 the cheap path for names the engine has seen. The CNameIndex class is implied by the name, and the acquire semantics are read from the name.", + "source": "generated" + }, + "CNavArea::UpdateBlocked": { + "text": "Recomputes a nav area's blocked state and the team it is blocked for, warning when the area is already blocked with a different team id \u2014 which its own text calls a cause of flow bugs. Read from that anchor and the name; exact triggers and timing are unverified.", + "source": "generated" + }, + "CNavArea::~CNavArea": { + "text": "Destroys a nav area object and releases what it owns. The CNavArea class is implied by the name, not by the data, and the specific teardown work is unverified.", + "source": "generated" + }, + "CNavBreadthFirstSearch::BreadthFirstSearchCore": { + "text": "Runs the core breadth-first traversal over nav connectivity, expanding outward from a starting area one frontier at a time. Read from the name; what it visits, how it terminates, and how results are reported are unverified.", + "source": "generated" + }, + "CNavGameSystem::ActiveSpawnGroupChanged": { + "text": "Switches the active nav mesh when the active spawn group changes, naming the group in its log text. Relevant on maps where multiple spawn groups swap nav data underneath bot pathing; the swap mechanics themselves are unverified.", + "source": "generated" + }, + "CNavGameSystem::PostSpawnGroupLoad": { + "text": "Performs the nav-side work after a spawn group finishes loading, logging the group name. Read from that anchor and the name \u2014 plausibly bringing the group's nav data into use \u2014 with the specific work unverified.", + "source": "generated" + }, + "CNavGameSystem::PostSpawnGroupUnload": { + "text": "Performs the nav-side work after a spawn group is unloaded, logging the group name. Read from that anchor and the name \u2014 plausibly dropping that group's nav data \u2014 with the specific work unverified.", + "source": "generated" + }, + "CNavLadder::ConnectGeneratedLadder": { + "text": "Connects a generated ladder to the nav areas at its ends, and reports the world position when a ladder bottom is left unconnected. Useful when nav generation produces ladders bots will not use; the connection rules are unverified.", + "source": "generated" + }, + "CNavMarkerData::CreateArea": { + "text": "Creates a nav area from marker data. Read from the name and a bare CreateArea anchor, so what the marker data supplies and how the new area is registered are unverified.", + "source": "generated" + }, + "CNavMarkupManager::AddAttributeForMarkupVolume_Blocks": { + "text": "Applies a blocking attribute to the nav space covered by a markup volume; its own text reports that flood fill is not yet supported on nav space here. Useful when authoring markup volumes meant to mark regions unwalkable, though the attribute encoding is unverified.", + "source": "generated" + }, + "CNavMesh::BuildPath": { + "text": "Builds a path across the nav mesh between areas, carrying the anchor string PathFind_NavAreaBuildPath. Read from the name and that anchor; the cost function, goal handling, and the form the path takes are unverified.", + "source": "generated" + }, + "CNavMesh::CommandNavEndArea": { + "text": "Handles the nav-editing command that ends the current area operation, in the family of in-game nav edit commands. Read from the name alone, so the command's exact effect on the mesh is unverified.", + "source": "generated" + }, + "CNavMesh::GetGroundHeight": { + "text": "Resolves the ground height at a queried world position for nav purposes. Read from the name and a self-named anchor; how it probes the world and which surfaces qualify are unverified.", + "source": "generated" + }, + "CNavMesh::IslandRemoval": { + "text": "Strips disconnected islands out of the generated nav mesh, and reports when no polygon can be found near a navlink location. Useful when generation leaves unreachable pockets or dangling navlinks; the connectivity criteria are unverified.", + "source": "generated" + }, + "CNavMesh::LoadNavMesh": { + "text": "Loads a map's nav mesh, logging the name it loads. Read from that anchor and the name; the file handling and what happens on a missing or stale mesh are unverified.", + "source": "generated" + }, + "CNavMesh::LoadPlaceDatabase": { + "text": "Loads the database of nav place names used to label areas, with scripts/population.txt appearing among its referenced strings. Read from the name and that anchor, so the parse format and where entries are stored are unverified.", + "source": "generated" + }, + "CNavMesh::NameToPlace": { + "text": "Looks up a place name string against the loaded place database, warning that a NavMesh place is undefined when no entry matches. Handy when scripts or entities reference place names that the current map's database lacks; the lookup's internals are unverified.", + "source": "generated" + }, + "CNavMesh::PathfindGeneric": { + "text": "Runs a general-purpose pathfinding search over the nav mesh rather than one caller's specialised variant. Read from the name alone, so the search strategy, goal test, and result form are unverified.", + "source": "generated" + }, + "CNavMesh::UpdateVolumes": { + "text": "Refreshes the nav mesh's volumes so their current state is reflected in the mesh. Read from the name and a bare UpdateVolumes anchor; which volumes participate and what they change are unverified.", + "source": "generated" + }, + "CNavObstacleSplitMgr::AddOverlaps": { + "text": "Registers where obstacles overlap nav areas, the bookkeeping that drives obstacle-based area splitting. Read from the name and a bare AddOverlaps anchor, so what counts as an overlap and how it is stored are unverified.", + "source": "generated" + }, + "CNavObstacleSplitMgr::DebugDraw": { + "text": "Draws debug visuals for obstacle splitting and prints a removed count alongside them. Useful when checking how dynamic obstacles are carving up nav areas; the primitives drawn and the exact meaning of the count are unverified.", + "source": "generated" + }, + "CNavObstacleSplitMgr::RemoveObstacle": { + "text": "Removes a registered obstacle from the split manager, undoing the nav splitting attributed to it. Read from the name alone, so the cleanup and any re-merging of split areas are unverified.", + "source": "generated" + }, + "CNavPhysicsInterface::TraceShape": { + "text": "Traces a shape against the world on behalf of nav code \u2014 the physics query nav generation and runtime nav tests rely on. The CNavPhysicsInterface class is implied by the name, not by the data, and the supported shapes and filtering are unverified.", + "source": "generated" + }, + "CNavQuery::FindRandomConnectedPoint": { + "text": "Picks a random point reachable through nav connectivity from a given start point. Useful for roam, wander, or scatter destinations that need to be reachable rather than merely nearby; the sampling and reachability rules are unverified.", + "source": "generated" + }, + "CNavSpaceBuilder::CNavSpaceBuilder": { + "text": "Constructs the nav space builder used to assemble nav space during mesh generation. Read from the name; what it initialises and what inputs it is handed are unverified.", + "source": "generated" + }, + "CNetChan::CanPacket": { + "text": "Reports whether the net channel is allowed to send a packet at this moment, the bandwidth and rate gate on outgoing traffic. The CNetChan class is implied by the name, not by the data, and the throttling rules behind the answer are unverified.", + "source": "generated" + }, + "CNetChan::ParseMessagesSNP": { + "text": "Parses incoming net messages out of the channel's SNP transport framing, on the networksystem side rather than in game code. Read from the name; the framing details and malformed-data handling are unverified.", + "source": "generated" + }, + "CNetChan::ProcessMessages": { + "text": "Processes the net messages that have arrived on the channel. The CNetChan class is implied by the name, not by the data; what the processing entails and which messages it covers are unverified.", + "source": "generated" + }, + "CNetChan::RegisterNetMessageHandlerAbstract": { + "text": "Registers a handler for net messages on the channel \u2014 the hook point for observing or handling custom message traffic. The CNetChan class is implied by the name, not by the data, and how handlers are keyed or replaced is unverified.", + "source": "generated" + }, + "CNetChan::SendData": { + "text": "Sends a raw data payload over the net channel, as opposed to a structured message. The CNetChan class is implied by the name, not by the data; buffer form, reliability, and fragmentation behaviour are unverified.", + "source": "generated" + }, + "CNetChan::SendNetMessage": { + "text": "Sends a structured net message over the channel, the usual path for pushing a message to the peer on the other end. The CNetChan class is implied by the name, not by the data, and reliability or channel selection is unverified.", + "source": "generated" + }, + "CNetChan::Setup": { + "text": "Sets up a net channel for use, preparing it before traffic flows. Read from the name alone; what it configures is not established.", + "source": "generated" + }, + "CNetChan::Transmit": { + "text": "Transmits the channel's pending outgoing data onto the wire. The CNetChan class is implied by the name, not by the data; what it flushes and any per-call size or rate limits are unverified.", + "source": "generated" + }, + "CNetConsoleMgr::OnSocketAccepted": { + "text": "Handles a remote-console socket that has just been accepted, letting the manager take ownership of the new connection. Read from the name; the owning class is implied by the name rather than established by the data, so the per-socket bookkeeping is unverified.", + "source": "generated" + }, + "CNetConsoleMgr::OnSocketClosed": { + "text": "Handles a remote-console socket that has closed, so the manager can drop its bookkeeping for that connection. Read from the name; the owning class is implied by the name rather than established by the data, so the cleanup it performs is unverified.", + "source": "generated" + }, + "CNetConsoleMgr::ShouldAcceptSocket": { + "text": "Decides whether an incoming remote-console connection is allowed, the natural gate for netconsole access. Read from the name; the owning class is implied by the name, so the criteria it applies are unverified.", + "source": "generated" + }, + "CNetworkClientService::OnClientFrameSimulate": { + "text": "Runs the client service's work for a simulated client frame, a per-frame networking hook point. Read from the name; the owning class is implied by the name, and which frame it refers to is not established by the data.", + "source": "generated" + }, + "CNetworkEncodingStats::Clear": { + "text": "Clears accumulated network encoding statistics, resetting the collector to an empty state. Read from the name; the owning class is implied by the name, so exactly which counters are reset is unverified.", + "source": "generated" + }, + "CNetworkEncodingStats::Flush": { + "text": "Flushes buffered network encoding statistics, committing or emitting what has accumulated. Read from the name; the owning class is implied by the name, and whether it also clears the accumulators afterwards is not established.", + "source": "generated" + }, + "CNetworkEncodingStats::HookDeltaBits": { + "text": "Records the bit cost of a delta encoding into the statistics, attributing those bits to whatever produced them. Read from the name; the owning class is implied by the name, so what the bits are attributed to is unverified.", + "source": "generated" + }, + "CNetworkEncodingStats::Init": { + "text": "Sets up the network encoding-statistics collector; beyond initialisation no more specific purpose is established. The owning class is implied by the name rather than by the data.", + "source": "generated" + }, + "CNetworkEncodingStats::MessageData": { + "text": "Feeds message payload information into the encoding statistics so per-message network cost can be tallied. Read from the name; the owning class is implied by the name, so the exact quantities recorded are unverified.", + "source": "generated" + }, + "CNetworkEncodingStats::Shutdown": { + "text": "Tears down the network encoding-statistics collector; beyond teardown no more specific purpose is established. The owning class is implied by the name rather than by the data.", + "source": "generated" + }, + "CNetworkEncodingStats::Update": { + "text": "Advances the network encoding statistics, rolling accumulated counters forward for the current sampling period. Read from the name; the owning class is implied by the name, so the period and what it recomputes are unverified.", + "source": "generated" + }, + "CNetworkFieldScratchData::Alloc": { + "text": "Allocates a scratch buffer for network field data; the shipped string \"CNetworkFieldScratchData::Alloc created buffer %s of size %s\" shows it logs the buffer's name and size on creation. Useful when tracing where per-field networking scratch memory comes from and how large it grows.", + "source": "generated" + }, + "CNetworkFieldSerializerAllocator::FindOrAddField": { + "text": "Looks up a network field in the serializer allocator and adds it when absent, returning the shared entry so equivalent fields are not duplicated. Read from the name; the owning class is implied by the name, so the identity used for matching is unverified.", + "source": "generated" + }, + "CNetworkFieldSerializerAllocator::Purge": { + "text": "Releases the field-serializer storage the allocator holds. Read from the name; the owning class is implied by the name, so how much it frees and whether the allocator stays usable are unverified.", + "source": "generated" + }, + "CNetworkFieldSerializerAllocator::PurgeTemporaryData": { + "text": "Frees only the allocator's temporary field-serializer data, leaving the durable entries in place. Read from the name; the owning class is implied by the name, so which data counts as temporary is unverified.", + "source": "generated" + }, + "CNetworkFieldSerializerAllocator::Report": { + "text": "Reports on the field-serializer allocator's contents or memory use, handy when diagnosing serializer growth. Read from the name; the owning class is implied by the name, so the report's destination and format are unverified.", + "source": "generated" + }, + "CNetworkGameServer::ActivateServer": { + "text": "Brings the network game server into its active, playable state once a level is ready. Read from the name; the owning class is implied by the name, so the preconditions it expects are unverified.", + "source": "generated" + }, + "CNetworkGameServer::ActiveServer": { + "text": "Activates the network game server; this spelling is recorded at the same vtable slot as CNetworkGameServer::ActivateServer, so treat the two as one activation entry point. The owning class is implied by the name, and which spelling a given build carries is unverified.", + "source": "generated" + }, + "CNetworkGameServer::ChangeLevel": { + "text": "Switches the running server to a different level. Read from the name; nothing in the data establishes how the target map is specified or what happens to connected clients across the change.", + "source": "generated" + }, + "CNetworkGameServer::CheckTimeouts": { + "text": "Checks connected clients for network timeouts so unresponsive ones can be dropped. Read from the name; the thresholds it uses and the action it takes on a timed-out client are not established by the data.", + "source": "generated" + }, + "CNetworkGameServer::ConnectClient": { + "text": "Brings a new client onto the server, establishing its slot and networking state. Read from the name; the owning class is implied by the name, so the connection data it consumes and how it rejects clients are unverified.", + "source": "generated" + }, + "CNetworkGameServer::DeactivateSteamGameServer": { + "text": "Shuts down the server's Steam game-server presence, dropping its Steam session and listing. Read from the name; the owning class is implied by the name, so what stays live afterwards is unverified.", + "source": "generated" + }, + "CNetworkGameServer::DisconnectClient": { + "text": "Removes a client from the server, tearing down its slot and networking state. Read from the name; the owning class is implied by the name, so how a disconnect reason is carried is unverified.", + "source": "generated" + }, + "CNetworkGameServer::GetAddonName": { + "text": "Returns the addon (workshop content) name the server is running with, the value a plugin reads to learn the active addon. Read from the name; the owning class is implied by the name, so the exact form of the returned value is unverified.", + "source": "generated" + }, + "CNetworkGameServer::GetClassBaseline": { + "text": "Fetches the networking baseline for an entity class \u2014 the default state that deltas are encoded against. Read from the name; the owning class is implied by the name, so the lookup key and the shape of the baseline data are unverified.", + "source": "generated" + }, + "CNetworkGameServer::GetGlobalVars": { + "text": "Returns the server's global variables block, the shared per-frame state and timing struct gameplay code reads. Read from the name; the owning class is implied by the name, so the block's contents are not established by the data.", + "source": "generated" + }, + "CNetworkGameServer::GetMapName": { + "text": "Returns the name of the map the server currently has loaded. Read from the name; the owning class is implied by the name, so whether the value is a short name or a fuller path is unverified.", + "source": "generated" + }, + "CNetworkGameServer::Inactivate": { + "text": "Takes the network game server out of its active state, the counterpart to CNetworkGameServer::ActivateServer and a natural part of level teardown. Read from the name; what it releases, and whether clients are retained, is not established by the data.", + "source": "generated" + }, + "CNetworkGameServer::OnValidateAuthTicketResponse": { + "text": "Handles the Steam auth-ticket validation result for a player, where authentication and ban outcomes surface. Read from the name; the response contents and how the server reacts to a failure are not established by the data.", + "source": "generated" + }, + "CNetworkGameServer::PrepareForAssetLoad": { + "text": "Puts the server into a state suitable for loading assets, ahead of map or resource loading. Read from the name; the owning class is implied by the name, so what it quiesces or releases first is unverified.", + "source": "generated" + }, + "CNetworkGameServer::SendClientMessages": { + "text": "Sends the server's pending per-client network messages out to connected clients. Read from the name; the data does not establish which queues it drains or how often it runs.", + "source": "generated" + }, + "CNetworkGameServer::SpawnServer": { + "text": "Stands up the server for a map, creating the world and networking state for a new session. Read from the name; the owning class is implied by the name, so its inputs and what it initialises are unverified.", + "source": "generated" + }, + "CNetworkGameServer::SpawnServer_Unknown": { + "text": "Performs server-spawn work under a name the tooling could not fully resolve, as the \"_Unknown\" suffix marks. The reading comes from the name; how it relates to or differs from CNetworkGameServer::SpawnServer is not established by the data.", + "source": "generated" + }, + "CNetworkGameServer::WriteClassInfosAndSerializesToBuffer": { + "text": "Writes entity class information and their field serializers into a buffer \u2014 the description a receiver needs to decode networked entities. Read from the name; the buffer format and the conditions under which it is produced are not established by the data.", + "source": "generated" + }, + "CNetworkGameServerBase::BroadcastMessage": { + "text": "Sends a network message out from the engine's game server to connected clients. The class is implied by the name, and the reading is name-level: which message forms it accepts and which recipients it covers are not established here.", + "source": "generated" + }, + "CNetworkGameServerBase::CNetworkGameServerBase": { + "text": "Constructs the engine-side network game server object and sets up its initial state. Beyond construction, no more specific purpose is established.", + "source": "generated" + }, + "CNetworkGameServerBase::FinishChangeLevel": { + "text": "Completes a level change on the server, finishing the transition into the newly loaded map. The class is implied by the name; the reading comes from the name alone, so the exact end-of-transition work is unverified.", + "source": "generated" + }, + "CNetworkGameServerBase::ReplyConnection": { + "text": "Produces the server's reply to a client connection attempt, the response that accepts or rejects the incoming connection. Read from the name; what the reply carries and which connection states it covers are not established.", + "source": "generated" + }, + "CNetworkGameServerBase::ReserveServerForQueuedGame": { + "text": "Reserves the server for a queued matchmaking game, marking it as held for that pending match. The class is implied by the name; what the reservation records and how long it persists are not established.", + "source": "generated" + }, + "CNetworkGameServerBase::SetServerState": { + "text": "Sets the network game server's current state, moving it between the lifecycle states the engine tracks for a server. The class is implied by the name; which state values exist and what changing state affects are not established.", + "source": "generated" + }, + "CNetworkGameServerBase::StartChangeLevel": { + "text": "Begins a level change on the server, initiating the transition to a different map. The class is implied by the name, and the reading is name-level, so exactly what the start of the transition does is unverified.", + "source": "generated" + }, + "CNetworkGameServerBase::WriteBaselines": { + "text": "Writes entity baseline state into the server's outgoing network data, the reference snapshot against which later updates are expressed. Read from the name; the encoding, the destination, and when baselines are produced are not established.", + "source": "generated" + }, + "CNetworkGameServerBase::WriteDeltaEntity_Internal": { + "text": "Writes an entity's delta update \u2014 the state that differs from a prior reference \u2014 into the outgoing network data. Read from the name; the _Internal suffix marks it as an inner helper rather than a public entry point, and the encoding is unverified.", + "source": "generated" + }, + "CNetworkMessages::AssociateNetMessageGroupIdWithChannelCategory": { + "text": "Associates a network-message group id with a channel category, so messages belonging to that group are carried under the category's channel settings. The class is implied by the name, and the effect of the association on delivery is a name-level reading.", + "source": "generated" + }, + "CNetworkMessages::AssociateNetMessageWithChannelCategoryAbstract": { + "text": "Associates an individual network message with a channel category, tagging that message so it travels under the category's channel. The class is implied by the name, and what distinguishes the Abstract variant is not established.", + "source": "generated" + }, + "CNetworkMessages::ComputeOrderForPriority": { + "text": "Derives an ordering value from a priority level, converting a priority into the rank used when arranging networked work. The class is implied by the name; what is ordered and how priorities map to order are not established.", + "source": "generated" + }, + "CNetworkMessages::FindOrCreateGroupId": { + "text": "Looks up a network-message group id and creates it if no matching group exists yet. Read from the name; the lookup key and the id's lifetime are not established.", + "source": "generated" + }, + "CNetworkMessages::FindOrCreateNetMessage": { + "text": "Looks up a registered network message and registers a new entry if none matches, giving callers a stable handle for a message type. The class is implied by the name; the lookup key and what the resulting message binding holds are not established.", + "source": "generated" + }, + "CNetworkMessages::RegisterFieldChangeCallbackPriority": { + "text": "Registers the priority for a field-change callback, so change notifications carry an explicit relative ranking. The class is implied by the name; the callback identity and the priority scale are not established.", + "source": "generated" + }, + "CNetworkMessages::RegisterNetworkCategory": { + "text": "Registers a network channel category with the messaging system, creating the category that messages and message groups can be associated with. The class is implied by the name, and the category's properties are a name-level reading.", + "source": "generated" + }, + "CNetworkMessages::RegisterNetworkFieldSerializer": { + "text": "Registers a field serializer with the networking system, making that serializer available for encoding networked entity fields. The class is implied by the name; the registration key and what the serializer record contains are not established.", + "source": "generated" + }, + "CNetworkP2PService::BroadcastP2PNetMessageAbstract": { + "text": "Sends a peer-to-peer network message out to the peers the service tracks, taking the message in its abstract, type-erased form. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::Connect": { + "text": "Brings the peer-to-peer service into its connected, usable state, the counterpart to CNetworkP2PService::Disconnect. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::Disconnect": { + "text": "Tears the service back out of its connected state, the counterpart to CNetworkP2PService::Connect. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::GetAllPeersEventDispatcher": { + "text": "Exposes the event dispatcher covering all peers, the hook point for a mod that wants to observe peer-wide P2P events. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::GetBuildType": { + "text": "Reports the build type label the service reports for itself. What that label distinguishes is not established here, and the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::GetDependencies": { + "text": "Reports what the service depends on, useful when reasoning about what must exist alongside CNetworkP2PService. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::GetName": { + "text": "Purpose is not established beyond retrieving the service's name. The owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::GetServiceDependencies": { + "text": "Reports the other engine services this one requires, a service-scoped view distinct from CNetworkP2PService::GetDependencies. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::GetServiceIndex": { + "text": "Reports the service's index slot, the value CNetworkP2PService::SetServiceIndex assigns. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::GetTier": { + "text": "Reports the tier the service classifies itself into. What the tier governs is not established here, and the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::Init": { + "text": "Purpose is not established beyond initialising the service. The owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::IsActive": { + "text": "Reports whether the service is currently active, the state CNetworkP2PService::SetActive controls. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::IsKnownPeer": { + "text": "Tests whether a peer is one the service already knows about, handy for filtering unrecognised P2P traffic. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::IsSingleton": { + "text": "Reports whether the service is a singleton, meaning one instance per process rather than many. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::OnLoopActivate": { + "text": "Handles the service becoming active within its engine loop, a notification point for loop entry where per-loop P2P state can be set up. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::OnLoopDeactivate": { + "text": "Handles the service going inactive as its engine loop is torn down, where per-loop P2P state can be released. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::OnPeerToPeerNetChannelCreated": { + "text": "Handles notification that a peer-to-peer net channel has been created, the moment a new peer link becomes visible to the service. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::OnShutdownChannel": { + "text": "Handles a channel shutting down, letting the service drop the state tied to that peer link. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::PeerGroupChanged": { + "text": "Handles a change in the peer group's membership or composition, the kind of change relevant to handlers added through CNetworkP2PService::RegisterPeerGroupHandler. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::PreShutdown": { + "text": "Performs early teardown work while the service is still usable, ahead of its resources being released. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::QueryInterface": { + "text": "Purpose is not established beyond obtaining an interface from the service. The owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::Reconnect": { + "text": "Re-establishes the service's connection after it has been dropped, rather than doing first-time setup. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::RegisterEventMap": { + "text": "Registers the service's event map, wiring its event handlers into the engine's event system. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::RegisterP2PNetMessageAbstract": { + "text": "Registers a peer-to-peer network message type in its abstract, type-erased form so the service recognises it, the registration counterpart to CNetworkP2PService::BroadcastP2PNetMessageAbstract. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::RegisterPeerGroupHandler": { + "text": "Registers a handler to receive peer-group notifications, the way a mod subscribes to group membership activity. Read from the name; the owning class is implied by the name, and CNetworkP2PService::UnregisterPeerGroupHandler removes such a handler.", + "source": "generated" + }, + "CNetworkP2PService::SetActive": { + "text": "Sets whether the service is active, the state CNetworkP2PService::IsActive reports. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::SetName": { + "text": "Sets the service's name, the value CNetworkP2PService::GetName reports. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::SetServiceIndex": { + "text": "Assigns the service's index slot, the value CNetworkP2PService::GetServiceIndex reports. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::ShouldActivate": { + "text": "Reports whether the service ought to be activated at all, a gating predicate on activation. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::Shutdown": { + "text": "Shuts the service down, releasing the peer-to-peer state and resources it holds. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::SteamIDAllowedToP2PConnect": { + "text": "Decides whether a given Steam ID is permitted to open a peer-to-peer connection, an access-control gate on peers and an obvious interception point for a mod. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::UnregisterPeerGroupHandler": { + "text": "Removes a peer-group handler that was added with CNetworkP2PService::RegisterPeerGroupHandler, stopping further group notifications to it. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkP2PService::UpdatePeerConnectionStatus": { + "text": "Refreshes the service's recorded connection status for a peer, keeping its view of that link current. Read from the name; located by byte signature in libengine2, so the exact inputs and the conditions under which it runs are unverified.", + "source": "generated" + }, + "CNetworkP2PService::~CNetworkP2PService": { + "text": "Destroys the service instance and releases what it still holds. Read from the name; the owning class is implied by the name, not bound in this data.", + "source": "generated" + }, + "CNetworkSerializerBindingBuildFilter::GetFieldPriority": { + "text": "Reports the priority a build filter assigns to a field while a network serializer binding is being constructed, the value used to rank that field. The class is implied by the name; the priority scale and how the filter chooses it are not established.", + "source": "generated" + }, + "CNetworkSerializerFieldInfo::InitCodeGenTypes": { + "text": "Resolves code-generated type information for networked fields, binding each field to its declaring class; its shipped diagnostic reads 'unable to find class %s for field %s %s::%s' when that class cannot be located. Useful when a custom or modded networked field fails to resolve its class during serializer setup.", + "source": "generated" + }, + "CNetworkServerService::OnWriteNetworkingMetaFile": { + "text": "Handles writing the networking meta file, emitting the server's networking metadata out to a file. The class is implied by the name; the file's contents and location are not established.", + "source": "generated" + }, + "CNetworkServerService::StartupServer": { + "text": "Starts up the game server owned by the network server service, bringing it into a running state for a session. The class is implied by the name; what the startup configures is not established.", + "source": "generated" + }, + "CNetworkServerSpawnGroup::LoadEntities": { + "text": "Loads the entities belonging to a server-side spawn group, creating them as that group is brought into the world. The class is implied by the name; the source the entities are read from and the failure behaviour are not established.", + "source": "generated" + }, + "CNetworkService::ConfigureSockets": { + "text": "Configures the network sockets the service communicates over. The class CNetworkService is implied by the name; which addresses or ports it applies, and when the configuration takes effect, are not established.", + "source": "generated" + }, + "CNetworkService::Connect": { + "text": "Brings the service online by establishing the links it needs to the rest of the engine, the counterpart to CNetworkService::Disconnect. The class is implied by the name; what it attaches to and how failure is reported are unverified.", + "source": "generated" + }, + "CNetworkService::Disconnect": { + "text": "Tears down what CNetworkService::Connect established, detaching the service from the engine resources it was using. The class is implied by the name; the exact resources released are read from the name only.", + "source": "generated" + }, + "CNetworkService::GetBuildType": { + "text": "Reports the build flavour this service was compiled or configured for, useful when a mod needs to branch on debug versus release engine behaviour. The class is implied by the name; the encoding of the value and which build types it distinguishes are not established.", + "source": "generated" + }, + "CNetworkService::GetDependencies": { + "text": "Reports the modules this service requires in order to run. The class is implied by the name; a separate CNetworkService::GetServiceDependencies also exists, and which of the two covers which kind of dependency is not established.", + "source": "generated" + }, + "CNetworkService::GetName": { + "text": "Retrieves the service's name; beyond that, purpose is not established. The class CNetworkService is implied by the name, and CNetworkService::SetName writes the same value.", + "source": "generated" + }, + "CNetworkService::GetServiceDependencies": { + "text": "Reports the other services this one depends on, as distinct from the broader CNetworkService::GetDependencies. The class is implied by the name; how the dependency list is represented and what consumes it are unverified.", + "source": "generated" + }, + "CNetworkService::GetServiceIndex": { + "text": "Reports the registry index this service occupies, the value written through CNetworkService::SetServiceIndex. The class is implied by the name; what the index addresses and whether it is stable across a session are not established.", + "source": "generated" + }, + "CNetworkService::GetTier": { + "text": "Reports the service's tier classification, a grouping label the engine attaches to each service. The class is implied by the name; what the tier value means in practice is read from the name only.", + "source": "generated" + }, + "CNetworkService::Init": { + "text": "Initialises the service; the name alone does not establish what state it prepares or what it allocates. The class CNetworkService is implied by the name.", + "source": "generated" + }, + "CNetworkService::IsActive": { + "text": "Reports whether the service is currently active, the flag CNetworkService::SetActive writes. The class is implied by the name; what an inactive service stops doing is not established.", + "source": "generated" + }, + "CNetworkService::IsSingleton": { + "text": "Reports whether the engine may hold only one instance of this service. The class is implied by the name; how the engine acts on the answer is unverified.", + "source": "generated" + }, + "CNetworkService::OnLoopActivate": { + "text": "Hook that runs when the engine loop the service belongs to becomes active, letting the service pick up per-loop work. The class is implied by the name; paired with CNetworkService::OnLoopDeactivate, though what a loop activation entails is unverified.", + "source": "generated" + }, + "CNetworkService::OnLoopDeactivate": { + "text": "Hook that runs when the engine loop the service belongs to goes inactive, letting it drop per-loop work set up by CNetworkService::OnLoopActivate. The class is implied by the name; what state survives deactivation is not established.", + "source": "generated" + }, + "CNetworkService::PreShutdown": { + "text": "Gives the service an early chance to wind down before teardown proper, a hook a mod can use to release its own hooks while the service still functions. The class is implied by the name; how responsibilities split against CNetworkService::Shutdown is not established.", + "source": "generated" + }, + "CNetworkService::QueryInterface": { + "text": "Looks up an interface the service exposes and hands it back to the caller. The class is implied by the name; which interfaces can be requested and how an unknown request is answered are unverified.", + "source": "generated" + }, + "CNetworkService::Reconnect": { + "text": "Re-establishes the service's connections after they have been dropped, covering the case CNetworkService::Connect handles at startup. The class is implied by the name; whether existing state survives a reconnect is unverified.", + "source": "generated" + }, + "CNetworkService::RegisterEventMap": { + "text": "Registers the service's map of event handlers so the engine can deliver the events it subscribes to. The class is implied by the name; the map's format and which events it covers are unverified.", + "source": "generated" + }, + "CNetworkService::SetActive": { + "text": "Sets the service's active state, the flag CNetworkService::IsActive reports. The class is implied by the name; the side effects of toggling it are not established.", + "source": "generated" + }, + "CNetworkService::SetName": { + "text": "Assigns the service's name, the value read back through CNetworkService::GetName. The class is implied by the name; whether renaming is permitted once the service is running is unverified.", + "source": "generated" + }, + "CNetworkService::SetServiceIndex": { + "text": "Assigns the registry index for this service, read back through CNetworkService::GetServiceIndex. The class is implied by the name; who normally assigns the index, and whether it may change later, are not established.", + "source": "generated" + }, + "CNetworkService::ShouldActivate": { + "text": "Reports whether the service wants to be activated under the current conditions, a predicate distinct from the CNetworkService::SetActive flag. The class is implied by the name; what it examines to decide is unverified.", + "source": "generated" + }, + "CNetworkService::Shutdown": { + "text": "Shuts the service down and releases what it holds. The class is implied by the name; how the work divides against CNetworkService::PreShutdown is not established.", + "source": "generated" + }, + "CNetworkService::~CNetworkService": { + "text": "Destroys the service object and frees its storage. The class is implied by the name; what it tears down beyond the object itself is not established.", + "source": "generated" + }, + "CNetworkStringDict::Count": { + "text": "Reports how many entries the dictionary holds, giving the bound for index-based walks with CNetworkStringDict::Element. The class is implied by the name; whether removed slots are counted is unverified.", + "source": "generated" + }, + "CNetworkStringDict::Element": { + "text": "Returns the entry stored at a given position in the dictionary, for walking it by index. The class is implied by the name; how it differs from CNetworkStringDict::String is not established.", + "source": "generated" + }, + "CNetworkStringDict::Find": { + "text": "Looks up a string already in the dictionary and reports the index it occupies, the read-only counterpart to CNetworkStringDict::Insert. The class is implied by the name; how a miss is signalled is unverified, so test the result with CNetworkStringDict::IsValidIndex.", + "source": "generated" + }, + "CNetworkStringDict::Insert": { + "text": "Adds a string to the dictionary and yields the index it is stored under, interning it so later code can refer to it cheaply. The class is implied by the name; whether inserting a duplicate yields the existing index is unverified.", + "source": "generated" + }, + "CNetworkStringDict::IsValidIndex": { + "text": "Reports whether an index refers to a real entry, the guard to apply to anything CNetworkStringDict::Find returns. The class is implied by the name; what makes an index invalid is not established.", + "source": "generated" + }, + "CNetworkStringDict::Purge": { + "text": "Empties the dictionary, dropping its strings and invalidating indices handed out earlier. The class is implied by the name; whether the backing storage is released as well as cleared is unverified.", + "source": "generated" + }, + "CNetworkStringDict::String": { + "text": "Returns the string text held at a given index, the direction opposite to CNetworkStringDict::Find. The class is implied by the name; how it differs from CNetworkStringDict::Element is not established.", + "source": "generated" + }, + "CNetworkStringDict::~CNetworkStringDict": { + "text": "Destroys the dictionary and releases its entries and storage. The class is implied by the name; whether the stored strings are owned and freed here is unverified.", + "source": "generated" + }, + "CNetworkStringTable::AddString": { + "text": "Adds a string entry to a network string table, giving it a slot in the table's replicated contents. The class is implied by the name; a prototype is derived, but the duplicate handling and the effect on existing entries are unverified.", + "source": "generated" + }, + "CNetworkStringTable::SetStringUserData": { + "text": "Attaches or replaces the user-data blob carried alongside an existing string in the table. The class is implied by the name; a prototype is derived, though how the target string is addressed and whether the data is copied are unverified.", + "source": "generated" + }, + "CNetworkStringTable::UpdateMirrorTable": { + "text": "Brings a mirrored copy of the string table back in step with the live table's contents. Read from the name only, so the mirroring direction, the granularity of the update and when a mirror exists at all are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::Connect": { + "text": "Hooks the string-table container up to the interfaces it needs, the Connect step of a system-lifecycle interface. The class is implied by the name and the reading is name-level, so what it acquires is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::CreateStringTable": { + "text": "Creates a new named string table inside the container so it can later be looked up and replicated. The class is implied by the name; the reading is name-level, so the naming, sizing and option flags it accepts are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::DirectUpdate": { + "text": "Applies string-table changes immediately rather than through the container's deferred update path. Read from the name only, so which tables it touches and when the direct path is safe to use are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::Disconnect": { + "text": "Releases the interfaces the string-table container acquired, the Disconnect counterpart of its lifecycle. The class is implied by the name and the reading is name-level, so exactly what is torn down is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::FindTable": { + "text": "Looks up one of the container's string tables by name and yields the matching table. The class is implied by the name; a prototype is derived, but the match rules (exact versus case-insensitive) and the miss behaviour are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetBuildType": { + "text": "Reports the build type the string-table container identifies itself with. The class is implied by the name, and beyond that label the purpose is not established.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetDependencies": { + "text": "Reports the other systems this string-table container declares a dependency on. The class is implied by the name; the form and contents of the dependency list are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetNumTables": { + "text": "Reports how many string tables the container currently holds, the bound you need when walking them with CNetworkStringTableContainer::GetTable. The class is implied by the name; a prototype is derived, though whether removed tables leave gaps in the range is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetTable": { + "text": "Fetches one of the container's string tables by index, the companion to CNetworkStringTableContainer::GetNumTables when enumerating them. The class is implied by the name; a prototype is derived, but index validity and out-of-range behaviour are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetTier": { + "text": "Reports the tier the string-table container registers itself under. The class is implied by the name, and beyond that label the purpose is not established.", + "source": "generated" + }, + "CNetworkStringTableContainer::Init": { + "text": "Initialises the string-table container. Purpose beyond that generic lifecycle label is not established, and the class is implied by the name.", + "source": "generated" + }, + "CNetworkStringTableContainer::IsSingleton": { + "text": "Reports whether the string-table container exists as a single shared instance rather than one per user. The class is implied by the name; the reading is name-level, so what the answer changes is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::PreShutdown": { + "text": "Performs the container's pre-shutdown cleanup phase, the work done ahead of a full shutdown. The class is implied by the name, and what it releases is not established.", + "source": "generated" + }, + "CNetworkStringTableContainer::QueryInterface": { + "text": "Hands back one of the interfaces the string-table container exposes, selected by an interface identifier. The class is implied by the name, and purpose beyond generic interface lookup is not established.", + "source": "generated" + }, + "CNetworkStringTableContainer::Reconnect": { + "text": "Re-binds an interface the container previously connected to, so a replaced system can be swapped in without a full teardown. The class is implied by the name; the reading is name-level, so what it re-acquires is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::RemoveAllTables": { + "text": "Clears the container, discarding the string tables it currently holds. The class is implied by the name; a prototype is derived, though whether table storage is freed or merely emptied is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::SetAllowClientSideAddString": { + "text": "Toggles whether client-side additions to string tables are permitted rather than server-authored entries only. The class is implied by the name; the reading is name-level, so whether the switch is container-wide or per-table is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::Shutdown": { + "text": "Shuts the string-table container down, tearing down the state it established. The class is implied by the name, and what specifically is released is not established.", + "source": "generated" + }, + "CNetworkStringTableContainer::WriteBaselines": { + "text": "Serialises the baseline contents of the container's string tables \u2014 the full-state form rather than incremental changes. Read from the name only, so the wire encoding and which tables contribute a baseline are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::WriteUpdateMessageAtTick": { + "text": "Serialises string-table changes into an update message associated with a particular tick. Read from the name at low confidence, so the tick semantics, the delta window and the message contents are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::~CNetworkStringTableContainer": { + "text": "Destroys the string-table container and releases the tables and buffers it owns. The class is implied by the name; a prototype is derived, but the teardown order and what survives destruction are unverified.", + "source": "generated" + }, + "CNetworkStringTableItem::SetUserData": { + "text": "Stores the user-data payload carried by a single string-table entry. Read from the name only, so whether the payload is copied or referenced, and any size limit, are unverified.", + "source": "generated" + }, + "CNetworkSystem::CloseSocket": { + "text": "Closes a network socket the network system holds open. Read from the name only, so which socket is targeted, and whether queued traffic is flushed or dropped, are unverified.", + "source": "generated" + }, + "CNetworkSystem::InitGameServer": { + "text": "Brings up the network system's game-server side so it can host and accept client connections. The class is implied by the name; a prototype is derived, though the ports and configuration it applies are unverified.", + "source": "generated" + }, + "CNetworkSystem::Shutdown": { + "text": "Shuts the network system down. Purpose beyond that generic lifecycle label is not established, and the class is implied by the name.", + "source": "generated" + }, + "CNetworkSystem::ShutdownGameServer": { + "text": "Tears down the game-server side of the network system, the counterpart to CNetworkSystem::InitGameServer. The class is implied by the name; a prototype is derived, but what happens to live client connections is unverified.", + "source": "generated" + }, + "CNetworkTransmitComponent::FireEvent": { + "text": "Raises an event on an entity's network-transmit component, the component whose m_nTransmitStateOwnedCounter tracks owned transmit state. The class is implied by the name; a prototype is derived, though the event identifiers it accepts and their effects are unverified.", + "source": "generated" + }, + "CNetworkTransmitComponent::StateChangedBranch": { + "text": "Handles a transmit-state change on the component through shared change-info storage; the embedded text \"CNetworkTransmitComponent::StateChangedBranch( overflowed shared changeinfos )\" marks the path taken when that shared storage is exhausted. Beyond the overflow case the behaviour is unverified, so treat that message as a signal you are churning networked state too hard.", + "source": "generated" + }, + "CNextLevelIssue::GetDetailsString": { + "text": "Supplies the detail text for the next-level vote issue, the supporting line shown under the vote's headline. The class is implied by the name; the reading is name-level, so the string's source and any substitution it performs are unverified.", + "source": "generated" + }, + "CNextLevelIssue::GetDisplayString": { + "text": "Supplies the display text for the next-level vote, carrying the localisation token #SFUI_vote_nextlevel_choices for the map choices shown to voters. Useful when adding or relabelling a custom next-level vote; the surrounding formatting is unverified at this confidence.", + "source": "generated" + }, + "CNmGraphDefinition::KV3TransferPostLoadFn": { + "text": "Fixes up an animation-graph definition once its KV3 data has been read in, resolving the stored index and slot arrays such as m_nodePaths, m_referencedGraphSlots and m_externalGraphSlots. Read from the name at low confidence, so exactly what the post-load pass patches is unverified.", + "source": "generated" + }, + "CNmGraphInstance::EvaluateGraph": { + "text": "Evaluates an animation graph instance for the current frame, running its nodes to produce the resulting pose. Read from the name and the function's presence in libanimationsystem; no prototype is derived, so the inputs it consumes and when it runs are unverified.", + "source": "generated" + }, + "CNmGraphInstance::ExecutePostPhysicsPoseTasks": { + "text": "Runs the graph instance's pose tasks belonging to the post-physics phase of the frame, matching the ExecutePostPhysicsPoseTasks string anchor. Useful as a landmark when hooking animation work that needs to see simulated physics state; which tasks are involved is not derived.", + "source": "generated" + }, + "CNmGraphInstance::ExecutePrePhysicsPoseTasks": { + "text": "Runs the graph instance's pose tasks belonging to the pre-physics phase of the frame, matching the ExecutePrePhysicsPoseTasks string anchor. Relevant when you need animation evaluation that happens before physics simulation for that frame; the task contents and timing are not derived here.", + "source": "generated" + }, + "CNmGraphInstance::GetCurrentGraphTimingInfo": { + "text": "Retrieves timing information describing where the graph instance currently sits in its animation, matching the GetCurrentGraphTimingInfo string anchor. Handy for reading playback position or duration off a live graph; the exact fields reported are not derived from this data.", + "source": "generated" + }, + "CNmSampledEvent::GetPercentageThrough": { + "text": "Reports how far through a sampled animation event the current sample lies, as a proportion of the event's span. Read from the name; no anchor or prototype is derived, so the value's range and the window it is measured against are unverified.", + "source": "generated" + }, + "CNmTaskSystem::SerializeTasks": { + "text": "Serializes the animation task system's tasks into or out of a buffer, matching the SerializeTasks string anchor. Relevant if you are replicating, recording, or inspecting animation task state; the wire format and direction are not derived here.", + "source": "generated" + }, + "CNmTaskSystem::UpdatePostPhysics": { + "text": "Advances the animation task system's work for the post-physics portion of the frame, matching the UpdatePostPhysics string anchor. A useful hook point for animation state that must reflect physics results; what it reads and writes is not derived.", + "source": "generated" + }, + "CNmTaskSystem::UpdatePrePhysics": { + "text": "Advances the animation task system's work for the pre-physics portion of the frame, matching the UpdatePrePhysics string anchor. Use it when animation must be settled before physics simulation runs; the specific task processing is not derived from this data.", + "source": "generated" + }, + "CNotReadyForMatchIssue::GetVotePassedString": { + "text": "Supplies the text shown to players when a vote on the not-ready-for-match issue passes, so the vote UI can announce the result. The CNotReadyForMatchIssue class is implied by the name rather than by the data, and the string's exact wording or localization token is unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::OnCreateBlendState": { + "text": "Handles a blend-state creation request in a null render-callback set, standing in where no real graphics device exists \u2014 as on a dedicated server. CNullShaderCreateCallbacks is implied by the name rather than the data, so whether it stubs, records, or validates the request is unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::OnCreateDepthStencilState": { + "text": "Handles a depth-stencil-state creation request in a null render-callback set, standing in where no real graphics device exists. CNullShaderCreateCallbacks is implied by the name rather than the data, so the stub's actual behaviour on such a request is unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::OnCreateRasterizerState": { + "text": "Handles a rasterizer-state creation request in a null render-callback set, standing in where no real graphics device exists. CNullShaderCreateCallbacks is implied by the name rather than the data, so what it does with the request is unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::OnCreateShader": { + "text": "Handles a shader creation request in a null render-callback set, absorbing the request where no real graphics device is present. CNullShaderCreateCallbacks is implied by the name rather than the data, so whether any object is produced is unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::~CNullShaderCreateCallbacks": { + "text": "Destroys a null shader-creation callback object and releases whatever it holds. CNullShaderCreateCallbacks is implied by the name rather than the data; beyond cleanup of that object, no further purpose is established.", + "source": "generated" + }, + "COrnamentProp::InputDetach": { + "text": "Handles the `Detach` entity-IO input on `COrnamentProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "COrnamentProp::InputSetAttached": { + "text": "Handles the `SetAttached` entity-IO input on `COrnamentProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPASAttenuationFilter::~CPASAttenuationFilter": { + "text": "Tears down a recipient filter that selects players by audible-set membership and sound attenuation, typically after a sound has been emitted to nearby clients. CPASAttenuationFilter is implied by the name rather than the data; only the cleanup role is established here.", + "source": "generated" + }, + "CPASFilter::~CPASFilter": { + "text": "Tears down a recipient filter that selects players by potentially-audible-set membership, once the message or sound using it has been sent. CPASFilter is implied by the name rather than the data; only the cleanup role is established here.", + "source": "generated" + }, + "CPackedStore::Find": { + "text": "Looks up an entry inside a packed archive store so the file system can resolve a request against it. Read from the name and the function's presence in libfilesystem_stdio; no prototype is derived, so the lookup key and miss behaviour are unverified.", + "source": "generated" + }, + "CPackedStore::GrowCount": { + "text": "Grows the packed store's internal capacity so more entries can be held. Read from the name and its presence in libfilesystem_stdio; the container it resizes and the growth policy are not derived from this data.", + "source": "generated" + }, + "CParticleSystem::InputStop": { + "text": "Handles the entity's Stop input, ending a running particle effect; m_bActive tracks whether the effect is live, and m_nStopType with m_flFreezeTransitionDuration govern how abruptly it ends. Read from the name and those fields \u2014 the behaviour of each stop type is not derived.", + "source": "generated" + }, + "CPath::AssemblePrecomputedPath": { + "text": "Builds a usable path from already-computed path data instead of running a fresh search, matching the CPath::AssemblePrecomputedPath string anchor. Relevant when working with cached or authored routes; the stored form it consumes is not derived here.", + "source": "generated" + }, + "CPath::ComputePathCore": { + "text": "Performs the core path computation that fills in a path's route. Read from the name; no anchor or prototype is derived, so the goal representation, search settings, and failure handling are unverified.", + "source": "generated" + }, + "CPath::ComputePathDetails": { + "text": "Fills in the finer detail of a path beyond its coarse route, matching the CPath::ComputePathDetails string anchor. Useful when investigating why an NPC's movement along a path looks the way it does; the detail data produced is not derived.", + "source": "generated" + }, + "CPath::ComputePathPosToPosCore": { + "text": "Computes a path between two explicit world positions rather than toward an entity or goal object. Read from the name; no anchor or prototype is derived, so the coordinate handling and options are unverified.", + "source": "generated" + }, + "CPath::GetNearestNavAreaAndGravityOrientedGoalPos": { + "text": "Finds the nav area closest to a goal together with a goal position adjusted for the local gravity orientation, matching the CPath::GetNearestNavAreaAndGravityOrientedGoalPos string anchor. Useful where goals sit off the mesh or on surfaces whose up direction is not world up; the adjustment rule is not derived.", + "source": "generated" + }, + "CPathCorner::InputInPass": { + "text": "Handles the `InPass` entity-IO input on `CPathCorner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathCorner::InputSetNextPathCorner": { + "text": "Handles the `SetNextPathCorner` entity-IO input on `CPathCorner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathCorner::~CPathCorner": { + "text": "Destroys a path corner waypoint entity \u2014 the node carrying m_flSpeed, m_flWait and m_flRadius for whatever travels the path, plus its m_OnPass output. CPathCorner is implied by the name rather than the data; only the cleanup role is established here.", + "source": "generated" + }, + "CPathCornerCrash::~CPathCornerCrash": { + "text": "Destroys a crash-variant path corner waypoint entity. CPathCornerCrash is implied by the name rather than the data; beyond cleanup, what distinguishes this variant is not established.", + "source": "generated" + }, + "CPathMover::Pause": { + "text": "Pauses the path mover, holding the CFuncMover entities listed in m_vecMovers where they are. Read from the name and the class's fields; what state is preserved across the pause is not derived.", + "source": "generated" + }, + "CPathMover::SetDistanceToReachMaxSpeed": { + "text": "Sets the distance over which movers on the path accelerate up to full speed, logged through the anchor \"SetDistanceToReachMaxSpeed [distance=%.2f time=%.2f]\" which reports both the distance and its equivalent time. Use it to shape acceleration along a mover path; units and clamping are not derived.", + "source": "generated" + }, + "CPathMover::SetDistanceToReachZeroSpeed": { + "text": "Sets the distance over which movers on the path decelerate to a stop, logged through the anchor \"SetDistanceToReachZeroSpeed [distance=%.2f time=%.2f]\" which reports both the distance and its equivalent time. The braking counterpart to the max-speed distance; units and clamping are not derived.", + "source": "generated" + }, + "CPathMover::SetTimeToReachMaxSpeed": { + "text": "Sets how long movers on the path take to accelerate up to full speed, logged through the anchor \"SetTimeToReachMaxSpeed [time=%.2f]\". The time-expressed form of the same acceleration control; units and any clamping are not derived here.", + "source": "generated" + }, + "CPathMover::SetTimeToReachZeroSpeed": { + "text": "Sets how long movers on the path take to decelerate to a stop, logged through the anchor \"SetTimeToReachZeroSpeed [time=%.2f]\". The time-expressed form of the braking control; units and any clamping are not derived here.", + "source": "generated" + }, + "CPathMover::Unpause": { + "text": "Resumes a paused path mover so the CFuncMover entities in m_vecMovers travel again. Read from the name and the class's fields; whether speed ramps back up or resumes instantly is not derived.", + "source": "generated" + }, + "CPathMoverEntitySpawner::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputRemoveFromTemplate": { + "text": "Handles the `RemoveFromTemplate` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputSpawn": { + "text": "Handles the `Spawn` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputDestroy": { + "text": "Handles the `DestroyImmediately` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputDisablePin": { + "text": "Handles the `DisablePin` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputSetRadius": { + "text": "Handles the `SetRadius` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputSetSlack": { + "text": "Handles the `SetSlack` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputStart": { + "text": "Handles the `Start` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputStopEndCap": { + "text": "Handles the `StopPlayEndCap` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRopeAlias_path_particle_rope_clientside::CPathParticleRopeAlias_path_particle_rope_clientside": { + "text": "Constructs a clientside alias entity for path_particle_rope, the map-placed rope that draws a particle effect along a series of path points, matching its own name as a string anchor. What the constructor initialises is not derived from this data.", + "source": "generated" + }, + "CPathQueryComponent::CPathQueryComponent": { + "text": "Constructs a path query component, the object an entity uses to issue pathfinding queries. Read from the name; no anchor or prototype is derived, so what it initialises and which owner it attaches to are unverified.", + "source": "generated" + }, + "CPathQueryUtil::CPathQueryUtil": { + "text": "Constructs the path-query helper that holds a sampled path \u2014 m_vecPathSamplePositions, m_vecPathSampleParameters and m_vecPathSampleDistances, plus m_bIsClosedLoop \u2014 for looking up positions along that path. Read from the name and those fields; the string anchor repeats the class name, so what the constructor actually initializes is unverified.", + "source": "generated" + }, + "CPathTrack::GetDataDescMap": { + "text": "Returns the entity's data-description map, the table that drives keyvalue handling and save/restore for a path node. It sits in an unbound vtable slot, so the owning class is implied by the name rather than recorded in the data.", + "source": "generated" + }, + "CPathTrack::InputDisableAlternatePath": { + "text": "Handles the `DisableAlternatePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputDisablePath": { + "text": "Handles the `DisablePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputEnableAlternatePath": { + "text": "Handles the `EnableAlternatePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputEnablePath": { + "text": "Handles the `EnablePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputPass": { + "text": "Handles the `InPass` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputToggleAlternatePath": { + "text": "Handles the `ToggleAlternatePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputTogglePath": { + "text": "Handles the `TogglePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::ValidPath": { + "text": "Validates a path node's links, emitting \"Bad sequence of path_tracks from %s\" when the chain is malformed. Useful when debugging paths assembled from m_pnext, m_pprevious and m_paltpath connections.", + "source": "generated" + }, + "CPathfindMulti::FindBestGoal": { + "text": "Picks the best goal from among several candidates for a multi-destination pathfinding query. Read from the name; the string anchor repeats the function's own name, so the scoring criteria and inputs are unverified.", + "source": "generated" + }, + "CPathfindMulti::MultiPathfind_Core": { + "text": "Runs the core of a multi-destination pathfinding search \u2014 the shared solver work behind querying several goals at once. Read from the name; the string anchor repeats the function's own name, so the algorithm and its results are unverified.", + "source": "generated" + }, + "CPauseMatchIssue::GetVotePassedString": { + "text": "Supplies the text shown when a vote to pause the match succeeds. The class owning this unbound vtable slot is implied by the name, and the exact string or localization token is not present in the data.", + "source": "generated" + }, + "CPhysBallSocket::~CPhysBallSocket": { + "text": "Destroys a ball-socket constraint entity, releasing the joint whose behaviour is configured by m_flJointFriction, m_bEnableSwingLimit and m_bEnableTwistLimit. The owning class is implied by the name; nothing in the data binds this slot to a class.", + "source": "generated" + }, + "CPhysBox::DrawDebugTextOverlays": { + "text": "Draws the on-screen debug text for a physics box, printing lines such as \"Nav ignore = %s\". Turn on entity debug overlays to inspect a box's navigation and motion state, alongside fields like m_bNotSolidToWorld and m_damageToEnableMotion.", + "source": "generated" + }, + "CPhysBox::InputDisableMotion": { + "text": "Handles the `DisableMotion` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysBox::InputEnableMotion": { + "text": "Handles the `EnableMotion` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysBox::InputForceDrop": { + "text": "Handles the `ForceDrop` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysBox::InputSleep": { + "text": "Handles the `Sleep` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysBox::InputWake": { + "text": "Handles the `Wake` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::GetConstraintObjects": { + "text": "Resolves the entities a constraint attaches, warning \"Bogus constraint %s (attaches %s to ENTITY NOT FOUND:%s)\" when a named target cannot be found. Read it alongside m_nameAttach1, m_nameAttach2, m_hAttach1 and m_hAttach2 when debugging constraints whose endpoints fail to bind.", + "source": "generated" + }, + "CPhysConstraint::InputBreak": { + "text": "Handles the `Break` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputDisableAngularConstraint": { + "text": "Handles the `DisableAngularConstraint` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputDisableLinearConstraint": { + "text": "Handles the `DisableLinearConstraint` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputEnableAngularConstraint": { + "text": "Handles the `EnableAngularConstraint` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputEnableLinearConstraint": { + "text": "Handles the `EnableLinearConstraint` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputOnBreak": { + "text": "Handles the `ConstraintBroken` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputSetMotorTargetVelocity": { + "text": "Handles the `SetMotorTargetVelocity` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputSetMotorTorqueFactor": { + "text": "Handles the `SetMotorTorqueFactor` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputTurnMotorOff": { + "text": "Handles the `TurnMotorOff` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputTurnMotorOn": { + "text": "Handles the `TurnMotorOn` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::~CPhysConstraint": { + "text": "Destroys a physics constraint entity, releasing the joint referenced by m_hJoint together with its attachment bookkeeping. The owning class is implied by the name, since the entry is an unbound vtable slot.", + "source": "generated" + }, + "CPhysExplosion::DrawDebugTextOverlays": { + "text": "Prints the physics-explosion debug overlay, including a \" magnitude: %.2f damage %.2f\" line reflecting m_flMagnitude and m_flDamage. Use it with entity debug overlays to check an explosion's configured force, damage and m_radius before it fires.", + "source": "generated" + }, + "CPhysExplosion::InputExplode": { + "text": "Handles the `Explode` entity-IO input on `CPhysExplosion`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysFixed::InputSetAngularDampingRatio": { + "text": "Handles the `SetAngularDampingRatio` entity-IO input on `CPhysFixed`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysFixed::InputSetAngularFrequency": { + "text": "Handles the `SetAngularFrequency` entity-IO input on `CPhysFixed`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysFixed::InputSetLinearDampingRatio": { + "text": "Handles the `SetLinearDampingRatio` entity-IO input on `CPhysFixed`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysFixed::InputSetLinearFrequency": { + "text": "Handles the `SetLinearFrequency` entity-IO input on `CPhysFixed`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysFixed::~CPhysFixed": { + "text": "Destroys a fixed (weld-style) constraint, releasing the spring-like joint configured by m_flLinearFrequency, m_flLinearDampingRatio, m_flAngularFrequency and m_flAngularDampingRatio. The owning class is implied by the name; the data binds no class to this slot.", + "source": "generated" + }, + "CPhysForce::InputActivate": { + "text": "Handles the `Activate` entity-IO input on `CPhysForce`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysForce::InputDeactivate": { + "text": "Handles the `Deactivate` entity-IO input on `CPhysForce`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysForce::InputForceScale": { + "text": "Handles the `scale` entity-IO input on `CPhysForce`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetHingeFriction": { + "text": "Handles the `SetHingeFriction` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetMaxLimit": { + "text": "Handles the `SetMaxLimit` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetMinLimit": { + "text": "Handles the `SetMinLimit` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetMotorTargetAngle": { + "text": "Handles the `SetMotorTargetAngle` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetVelocity": { + "text": "Handles the `SetAngularVelocity` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::~CPhysHinge": { + "text": "Destroys a hinge constraint, releasing the axis and motor state held in m_hinge, m_hingeFriction, m_flMotorFrequency and m_flMotorDampingRatio. The owning class is implied by the name rather than recorded in the data.", + "source": "generated" + }, + "CPhysImpact::InputImpact": { + "text": "Handles the `Impact` entity-IO input on `CPhysImpact`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysLength::~CPhysLength": { + "text": "Destroys a length constraint \u2014 the fixed-distance link described by m_vecAttach, m_addLength, m_minLength and m_totalLength. The owning class is implied by the name, not established by the data.", + "source": "generated" + }, + "CPhysMagnet::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPhysMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMagnet::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CPhysMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMagnet::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CPhysMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMotor::InputSetFriction": { + "text": "Handles the `SetFriction` entity-IO input on `CPhysMotor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMotor::InputSetTargetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CPhysMotor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMotor::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CPhysMotor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMotor::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CPhysMotor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysPulley::~CPhysPulley": { + "text": "Destroys a pulley constraint, releasing the two-point rig described by m_position2, m_offset, m_addLength and m_gearRatio. The owning class is implied by the name rather than bound in the data.", + "source": "generated" + }, + "CPhysSaveRestoreBlockHandler::GetBlockName": { + "text": "Supplies the name identifying the physics block inside a save file, the tag under which physics state is written and later located. The handler class is implied by the name, and the block string itself is not present in the data.", + "source": "generated" + }, + "CPhysSaveRestoreBlockHandler::ReadRestoreHeaders": { + "text": "Reads the header records at the front of the save file's physics block \u2014 the metadata a restore needs before the block body can be interpreted. The owning handler class is implied by the name; the header layout is not derived here.", + "source": "generated" + }, + "CPhysSlideConstraint::InputSetOffset": { + "text": "Handles the `SetOffset` entity-IO input on `CPhysSlideConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysSlideConstraint::InputSetSlideFriction": { + "text": "Handles the `SetSlideFriction` entity-IO input on `CPhysSlideConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysSlideConstraint::InputSetVelocity": { + "text": "Handles the `SetVelocity` entity-IO input on `CPhysSlideConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysSlideConstraint::~CPhysSlideConstraint": { + "text": "Destroys a sliding constraint, releasing the travel axis and motor state in m_axisEnd, m_slideFriction, m_initialOffset and m_flMotorFrequency. The owning class is implied by the name rather than recorded in the data.", + "source": "generated" + }, + "CPhysThruster::~CPhysThruster": { + "text": "Destroys a thruster entity, releasing the directed-force setup anchored at m_localOrigin. The owning class is implied by the name, and the data does not record what the teardown touches.", + "source": "generated" + }, + "CPhysTorque::~CPhysTorque": { + "text": "Destroys a torque entity, releasing the rotational-force setup whose spin axis is m_axis. The owning class is implied by the name rather than bound in the data.", + "source": "generated" + }, + "CPhysWheelConstraint::InputSetMaxSuspensionOffset": { + "text": "Handles the `SetMaxSuspensionOffset` entity-IO input on `CPhysWheelConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysWheelConstraint::InputSetMinSuspensionOffset": { + "text": "Handles the `SetMinSuspensionOffset` entity-IO input on `CPhysWheelConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysWheelConstraint::InputSetSteeringMimicsEntity": { + "text": "Handles the `SetSteeringMimicsEntity` entity-IO input on `CPhysWheelConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsBodyGameMarkupData::CPhysicsBodyGameMarkupData": { + "text": "Constructs the container for per-bone physics body markup, held in m_PhysicsBodyMarkupByBoneName and keyed by bone name. Read from the name and that field; the string anchor repeats the class name, so what the constructor populates is unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::GameActivate": { + "text": "Brings the server's physics game system into its active state for a running map, logging \"%s: CPhysicsGameSystem::GameActivate\". This is the subsystem's activation hook \u2014 a useful trace point when diagnosing a map whose physics never begins simulating.", + "source": "generated" + }, + "CPhysicsGameSystem::GameDeactivate": { + "text": "Takes the physics game system out of its active state, logging \"%s: CPhysicsGameSystem::GameDeactivate\". Read from the name and that anchor; the specific teardown it performs is not derived.", + "source": "generated" + }, + "CPhysicsGameSystem::GameInit": { + "text": "Performs one-time initialization of the server physics game system, under the \"SV GameInit\" label. Read from the name and that anchor; what it allocates or configures is not established by the data.", + "source": "generated" + }, + "CPhysicsGameSystem::GameShutdown": { + "text": "Shuts the physics game system down, logging \"%s: CPhysicsGameSystem::GameShutdown\". Read from the name and that anchor; which resources it releases is not derived.", + "source": "generated" + }, + "CPhysicsGameSystem::OnSimulate": { + "text": "Advances the physics game system for a simulation tick \u2014 the server-side per-tick physics update. Read from the name; no string anchor or prototype is derived, so the exact work it does and its timing are unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::PostSpawnGroupUnload": { + "text": "Handles physics-side cleanup for a spawn group that has been unloaded, logging \"%s: CPhysicsGameSystem::PostSpawnGroupUnload(%s: %s)\" with the group's identity. Relevant on streamed maps when physics objects from a removed group appear to linger.", + "source": "generated" + }, + "CPhysicsGameSystem::PreSpawnGroupLoad": { + "text": "Prepares the physics system for a spawn group that is about to load, logging \"%s: CPhysicsGameSystem::PreSpawnGroupLoad(%s: %s)\" with the group's identity. Read from the name and that anchor; what it actually prepares is unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::PullKinematicTransformsWorker": { + "text": "Pulls current transforms for kinematic, animation-driven bodies into the physics world, as one worker unit of that job. Read from the name and the \"PullKinematicTransformsWorker\" anchor; which bodies it covers and how the work is divided are not derived.", + "source": "generated" + }, + "CPhysicsGameSystemFrameBoundary": { + "text": "Handles the physics game system's per-frame boundary work, the frame-edge hook named directly by the anchor CPhysicsGameSystem::FrameBoundary. Worth knowing when timing custom physics work against the frame; what it actually performs at that boundary is not spelled out by this data.", + "source": "generated" + }, + "CPhysicsProp::CreateVPhysics": { + "text": "Creates the physics body for a physics prop, failing with \"Cannot create physics for %s \\\"%s\\\" (%s) @{%g,%g,%g}\" when the model offers no usable collision data. That message is the thing to look for when a prop spawns but never simulates; m_massScale and m_buoyancyScale are the related tuning fields.", + "source": "generated" + }, + "CPhysicsProp::DrawDebugTextOverlays": { + "text": "Draws the debug text overlay for a physics prop, printing \"Health: %d, collision group: %d, motion: %s %s\". Use it with entity debug overlays to read a prop's health, collision group and motion state alongside m_MotionEnabled and m_bAwake.", + "source": "generated" + }, + "CPhysicsProp::InputDisableCollisions": { + "text": "Handles the `DisableCollisions` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputDisableDrag": { + "text": "Handles the `DisableDrag` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputDisableGravity": { + "text": "Handles the `DisableGravity` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputDisableMotion": { + "text": "Handles the `DisableMotion` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputEnableCollisions": { + "text": "Handles the `EnableCollisions` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputEnableDrag": { + "text": "Handles the `SetDragEnabled` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputEnableGravity": { + "text": "Handles the `SetGravityEnabled` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputEnableMotion": { + "text": "Handles the `EnableMotion` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSetAutoConvertBackFromDebris": { + "text": "Handles the `SetAutoConvertBackFromDebris` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSetGlowOverride": { + "text": "Handles the `SetGlowOverride` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSetGlowRange": { + "text": "Handles the `SetGlowRange` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSetMass": { + "text": "Handles the `SetMass` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSleep": { + "text": "Handles the `Sleep` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputStartGlowing": { + "text": "Handles the `StartGlowing` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputStopGlowing": { + "text": "Handles the `StopGlowing` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputWake": { + "text": "Handles the `Wake` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputAddRestLength": { + "text": "Handles the `AddRestLength` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputRemoveRestLength": { + "text": "Handles the `RemoveRestLength` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputSetDampingRatio": { + "text": "Handles the `SetDampingRatio` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputSetFrequency": { + "text": "Handles the `SetFrequency` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputSetRestLength": { + "text": "Handles the `SetRestLength` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlantedC4::ShootSatchelCharge": { + "text": "Places the planted charge by tracing for a valid surface, reporting \"plant_bomb trace did not find a location to plant the bomb.\" when none is found. Relevant to bomb-plant handling and the resulting state in m_nBombSite and m_bBombTicking; beyond the anchor, its behaviour is read from the name.", + "source": "generated" + }, + "CPlatformFont::GetCharABCWidths": { + "text": "Retrieves the A, B and C spacing widths of a single character in a platform font, the per-glyph advance and side-bearing metrics used to lay text out. The class is implied by the name and the reading comes from the name alone, so the units and the font backend behind it are unverified.", + "source": "generated" + }, + "CPlatformFont::GetKernedCharWidth": { + "text": "Returns a character's advance width with kerning applied against its neighbour, giving tighter text measurement than a raw glyph width. The class is implied by the name, so the kerning source and any rounding it applies are unverified.", + "source": "generated" + }, + "CPlatformFont::~CPlatformFont": { + "text": "Destroys a platform font object, releasing the typeface and glyph resources it holds. The class is implied by the name; beyond teardown no further purpose is established.", + "source": "generated" + }, + "CPlayerInventory::SendInventoryUpdateEvent": { + "text": "Sends an event announcing that a player's inventory contents changed, so listeners can refresh loadout state. It also ships as CCSPlayerInventory::SendInventoryUpdateEvent and is the same function; the event payload and its recipients are read from the name, not verified.", + "source": "generated" + }, + "CPlayerVisibility::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPlayerVisibility`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlayerVisibility::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPlayerVisibility`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlayerVisibility::InputSetPlayerFogDistanceMultiplier": { + "text": "Handles the `SetPlayerFogDistanceMultiplier` entity-IO input on `CPlayerVisibility`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlayerVisibility::InputSetPlayerVisibilityStrength": { + "text": "Handles the `SetPlayerVisibilityStrength` entity-IO input on `CPlayerVisibility`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlayerVoiceListener::PostSpawnGroupUnload": { + "text": "Performs voice-listener bookkeeping after a spawn group is unloaded, dropping per-player voice tracking tied to entities that no longer exist. The string anchor CPlayerVoiceListener::PostSpawnGroupUnload() only repeats the name, so exactly which state is cleared remains unverified.", + "source": "generated" + }, + "CPlayer_ItemServices::CPlayer_ItemServices": { + "text": "Constructs the player's item-services component, the pawn-side object that owns item granting. Being a constructor, no purpose beyond initialising the object is established.", + "source": "generated" + }, + "CPlayer_ItemServices::GiveNamedItem": { + "text": "Gives a player an item looked up by name, creating the entity and handing it to the pawn; the anchor NULL Ent in GiveNamedItem: %s! shows it logs the requested name when creation yields no entity. This is the usual server-side entry point for granting weapons or gear.", + "source": "generated" + }, + "CPlayer_MovementServices::RunCmds": { + "text": "Processes user commands into the movement services' input state: the button masks in m_nButtons and the move axes m_flForwardMove, m_flLeftMove and m_flUpMove, with m_nLastCommandNumberProcessed tracking progress. It ships identically as CPlayer_MovementServices::RunCommand and CCSPlayer_MovementServices::RunCommand; the field mapping is read from names rather than verified.", + "source": "generated" + }, + "CPlayer_MovementServices::RunCommand": { + "text": "Applies a user command to the pawn's movement state, updating button state and the command move axes m_flCmdForwardMove, m_flCmdLeftMove and m_flCmdUpMove. It is the same function as CPlayer_MovementServices::RunCmds and CCSPlayer_MovementServices::RunCommand, so a hook placed here also catches those names.", + "source": "generated" + }, + "CPointAngleSensor::DrawDebugTextOverlays": { + "text": "Prints the angle sensor's live state as debug text on the entity; the anchor delta ang (dot) : %.2f (%f) shows it reports the angular delta together with the dot product compared against m_flDotTolerance. Useful when tuning m_hLookAtEntity facing checks in a map.", + "source": "generated" + }, + "CPointAngleSensor::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointAngleSensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointAngleSensor::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointAngleSensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointAngleSensor::InputSetTargetEntity": { + "text": "Handles the `SetTargetEntity` entity-IO input on `CPointAngleSensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointAngleSensor::InputTest": { + "text": "Handles the `Test` entity-IO input on `CPointAngleSensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointAngleSensor::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPointAngleSensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointAngularVelocitySensor::InputTest": { + "text": "Handles the `Test` entity-IO input on `CPointAngularVelocitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointAngularVelocitySensor::InputTestWithInterval": { + "text": "Handles the `TestWithInterval` entity-IO input on `CPointAngularVelocitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::CPointCamera": { + "text": "Constructs a point camera entity, setting up its view and post-processing fields such as m_FOV, m_bActive and the depth-of-field values m_flDofNearBlurry and m_flDofFarBlurry. As a constructor only initialisation is indicated; the defaults it writes are not established here.", + "source": "generated" + }, + "CPointCamera::InputChangeFOV": { + "text": "Handles the `ChangeFOV` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputDisableDOF": { + "text": "Handles the `DisableDOF` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputEnableDOF": { + "text": "Handles the `EnableDOF` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputForceActive": { + "text": "Handles the `Activate` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputForceInactive": { + "text": "Handles the `Deactivate` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFFarBlurry": { + "text": "Handles the `SetDOFFarBlurry` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFFarCrisp": { + "text": "Handles the `SetDOFFarCrisp` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFNearBlurry": { + "text": "Handles the `SetDOFNearBlurry` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFNearCrisp": { + "text": "Handles the `SetDOFNearCrisp` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFTiltToGround": { + "text": "Handles the `SetDOFTiltToGround` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetOff": { + "text": "Handles the `SetOff` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetOn": { + "text": "Handles the `SetOn` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetOnAndTurnOthersOff": { + "text": "Handles the `SetOnAndTurnOthersOff` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::~CPointCamera": { + "text": "Destroys a point camera entity and releases its per-camera state, including its position in the m_pNext camera chain. The class is implied by the name, and the chain cleanup is inferred rather than verified.", + "source": "generated" + }, + "CPointClientUIDialog::OnDialogActivatorChanged": { + "text": "Reacts when the entity that activated the client UI dialog changes, re-targeting the dialog at the new activator held in m_hActivator. The anchor OnDialogActivatorChanged restates the name, so what it pushes to the panel is unverified.", + "source": "generated" + }, + "CPointClientUIWorldPanel::InputAddCSSClass": { + "text": "Handles the `AddCSSClass` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldPanel::InputLocalPlayerAddCSSClass": { + "text": "Handles the `LocalPlayerAddCSSClass` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldPanel::InputLocalPlayerRemoveCSSClass": { + "text": "Handles the `LocalPlayerRemoveCSSClass` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldPanel::InputRemoveCSSClass": { + "text": "Handles the `RemoveCSSClass` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldTextPanel::InputSetIntMessage": { + "text": "Handles the `SetIntMessage` entity-IO input on `CPointClientUIWorldTextPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldTextPanel::InputSetMessage": { + "text": "Handles the `SetMessage` entity-IO input on `CPointClientUIWorldTextPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldTextPanel::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPointClientUIWorldTextPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCommentaryNode::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointCommentaryNode`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCommentaryNode::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointCommentaryNode`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCommentaryNode::InputStartCommentary": { + "text": "Handles the `StartCommentary` entity-IO input on `CPointCommentaryNode`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCommentaryNode::InputStartUnstoppableCommentary": { + "text": "Handles the `StartUnstoppableCommentary` entity-IO input on `CPointCommentaryNode`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointEntity::CPointEntity": { + "text": "Constructs the base point entity, the origin-only entity type that map logic entities build on. Being a constructor, no purpose beyond initialising the object is established.", + "source": "generated" + }, + "CPointEntity::~CPointEntity": { + "text": "Destroys a base point entity instance, tearing down the origin-only entity that map logic entities build on. The class is implied by the name; nothing beyond teardown is established.", + "source": "generated" + }, + "CPointEntityFinder::InputFindEntity": { + "text": "Handles the `FindEntity` entity-IO input on `CPointEntityFinder`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointGamestatsCounter::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointGamestatsCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointGamestatsCounter::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointGamestatsCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointGamestatsCounter::InputIncrement": { + "text": "Handles the `Increment` entity-IO input on `CPointGamestatsCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointGamestatsCounter::InputSetName": { + "text": "Handles the `SetName` entity-IO input on `CPointGamestatsCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointHurt::InputHurt": { + "text": "Handles the `Hurt` entity-IO input on `CPointHurt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointHurt::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPointHurt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointHurt::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CPointHurt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointHurt::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CPointHurt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointOrient::InputSetActive": { + "text": "Handles the `SetActive` entity-IO input on `CPointOrient`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointOrient::InputSetTarget": { + "text": "Handles the `SetTarget` entity-IO input on `CPointOrient`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointOrient::ReorientThink": { + "text": "Periodic think that turns the CPointOrient entity toward the entity in m_hTarget, honouring m_flMaxTurnRate and the axis limit in m_nConstraint while m_bActive is set. Read from the name and fields; the rotation maths and think interval are unverified.", + "source": "generated" + }, + "CPointProximitySensor::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointProximitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointProximitySensor::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointProximitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointProximitySensor::InputSetTargetEntity": { + "text": "Handles the `SetTargetEntity` entity-IO input on `CPointProximitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointProximitySensor::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPointProximitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointPush::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointPush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointPush::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointPush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointTemplate::~CPointTemplate": { + "text": "Destroys a point template entity, dropping the bookkeeping it keeps for its spawns in m_SpawnedEntityHandles and m_createdSpawnGroupHandles. The class is implied by the name, and whether it also destroys those spawned entities is unverified.", + "source": "generated" + }, + "CPointVelocitySensor::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointVelocitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointVelocitySensor::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointVelocitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputSetIntMessage": { + "text": "Handles the `SetIntMessage` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputSetMessage": { + "text": "Handles the `SetMessage` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputSetTextColor": { + "text": "Handles the `SetTextColor` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPreloaderGameSystem::ActivateSpawnGroup": { + "text": "Activates a preloaded spawn group so its content becomes live; the anchor %s: CPreloaderGameSystem::ActivateSpawnGroup activating %u %s shows it logs a numeric group handle and a name as it does so. Relevant when working with streamed map content or preloading.", + "source": "generated" + }, + "CPropDoorRotating::DrawDebugTextOverlays": { + "text": "Adds rotating-door state to the entity's on-screen debug text, the natural place to inspect m_eCurrentOpenDirection, m_angGoal and m_flDistance while debugging a door. The class is implied by the name, and which fields it actually prints is unverified.", + "source": "generated" + }, + "CPropDoorRotating::InputSetRotationDistance": { + "text": "Handles the `SetRotationDistance` entity-IO input on `CPropDoorRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPropDoorRotating::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CPropDoorRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPropDoorRotatingBreakable::DrawDebugTextOverlays": { + "text": "Adds the breakable door's condition to the debug text overlay, the place to read m_bBreakable and m_currentDamageState in-game. The class is implied by the name, and the exact lines it emits are unverified.", + "source": "generated" + }, + "CPulseCell_PlaySequence::OnEntityOutputListen": { + "text": "Handles an entity output that the play-sequence pulse cell is listening for; the anchor OnEntityOutputListen( %s, %s ) shows it logs an output-and-entity pair by name. Useful alongside m_SequenceName and the m_OnFinished output when scripting animation cells.", + "source": "generated" + }, + "CPulseExecCursor::CPulseExecCursor": { + "text": "Constructs a pulse execution cursor, the object carrying a running pulse graph's execution state; the anchor Cursor[ ptr:%p | id:%d | graph:%p ]: CPulseExecCursor() shows construction is traced with the cursor's pointer, id and owning graph. Handy when instrumenting pulse graph execution.", + "source": "generated" + }, + "CPulseGraphInstance::GetEntityBelowEntity": { + "text": "Pulse graph helper that finds the entity positioned below a given entity, a downward query for ground or stacking checks in graph logic. The anchor GetEntityBelowEntity restates the name, so the query shape and any filtering are unverified.", + "source": "generated" + }, + "CPulseGraphInstance::GetEntityHeightAboveWorldCollision": { + "text": "Pulse graph helper reporting how far an entity sits above the world collision beneath it, that is, its height over the ground surface. The anchor GetEntityHeightAboveWorldCollision restates the name, so the trace extent and what counts as world collision are unverified.", + "source": "generated" + }, + "CPulseGraphInstance::SetEntityOrigin": { + "text": "Pulse graph helper that repositions an entity by writing its origin, the graph-side way to move something. The anchor SetEntityOrigin restates the name, so whether collision, parenting or network state are refreshed is unverified.", + "source": "generated" + }, + "CPulseGraphInstance_GameBlackboard::ResolveDomainValue": { + "text": "Resolves a blackboard domain reference into a concrete value by looking up the named target; the anchor ResolveDomainValue entity not found: %s shows the lookup can be by entity name and that it warns when nothing matches. Check for that log when blackboard values come back empty.", + "source": "generated" + }, + "CPulseGraphInstance_ServerEntity::Think": { + "text": "Per-think update for a pulse graph instance bound to a server entity, advancing graph work for the owner in m_hOwner while m_bActivated is set. The anchor CPulseGraphInstance_ServerEntity::Think repeats the name, so the cadence and what it advances are unverified.", + "source": "generated" + }, + "CPulseServerCursor::Yield": { + "text": "Yields a running pulse cursor, suspending execution so it can resume later rather than finishing in one pass; m_hActivator and m_hCaller are the context it carries across the pause. The class is implied by the name, so the resume condition is unverified.", + "source": "generated" + }, + "CQuantizedFloatEncoder::AssignRangeMultiplier": { + "text": "Computes the multiplier that maps a float's declared value range onto its quantized bit count for network encoding, fixing the precision step of a quantized field. It lives in libnetworksystem and matters when reasoning about netprop precision loss; the reading comes from the name.", + "source": "generated" + }, + "CQueuedTextRenderable::GetCopy": { + "text": "Produces a copy of a queued text renderable so the item can be handed off or retained independently of the queue. The class is implied by the name; whether the copy is deep and who owns it are unverified.", + "source": "generated" + }, + "CQueuedTextRenderable::Render": { + "text": "Draws a queued text renderable, emitting its text when the queue is flushed. The class is implied by the name, and the target surface and text source are unverified.", + "source": "generated" + }, + "CQueuedTextRenderable::~CQueuedTextRenderable": { + "text": "Destroys a queued text renderable and frees the text and resources it held. The class is implied by the name; nothing beyond teardown is established.", + "source": "generated" + }, + "CRConClient::OnSocketAccepted": { + "text": "Handles a socket the RCON client side has just accepted, performing whatever per-connection setup that link needs. The class is implied by the name and the reading comes from the name alone, so the state it establishes is unverified.", + "source": "generated" + }, + "CRConClient::OnSocketClosed": { + "text": "Cleans up when an RCON client socket closes, dropping the bookkeeping tied to that connection. The class is implied by the name; what exactly is torn down is not established by this data.", + "source": "generated" + }, + "CRConClient::ShouldAcceptSocket": { + "text": "Gates whether an incoming socket is accepted on the RCON client side, the admission check made before a connection is put to use. The class is implied by the name, and the criteria it applies are not established here.", + "source": "generated" + }, + "CRConServer::OnSocketAccepted": { + "text": "Handles a socket the RCON server has just accepted, bringing a new remote-console connection into service. The class is implied by the name; it reads as the natural hook point for tracking RCON sessions, though the per-connection setup is unverified.", + "source": "generated" + }, + "CRConServer::OnSocketClosed": { + "text": "Handles an RCON server socket closing, releasing the bookkeeping held for that remote-console session. The class is implied by the name; a hook here observes RCON disconnects, but the state it clears is unverified.", + "source": "generated" + }, + "CRConServer::ShouldAcceptSocket": { + "text": "Decides whether the RCON server accepts an incoming socket, the point at which a connection can be refused before any console command is processed. The class is implied by the name, and the acceptance criteria are not established by this data.", + "source": "generated" + }, + "CRagdollConstraint::~CRagdollConstraint": { + "text": "Destroys a ragdoll constraint entity and releases what it holds; the joint's per-axis limits and damping live in fields from m_xmin and m_xmax through m_zfriction. The class is implied by the name, and the cleanup role is read from the destructor name.", + "source": "generated" + }, + "CRagdollMagnet::GetDataDescMap": { + "text": "Returns the data description map for the ragdoll magnet, the table binding its editable keyvalues such as m_radius, m_force, m_axis and m_bDisabled. The class is implied by the name, and the accessor role is a name-level reading.", + "source": "generated" + }, + "CRagdollMagnet::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CRagdollMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollMagnet::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CRagdollMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollManager::InputSetMaxRagdollCount": { + "text": "Handles the `SetMaxRagdollCount` entity-IO input on `CRagdollManager`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InitRagdoll": { + "text": "Builds a prop's ragdoll physics representation, setting up m_ragdoll together with the per-bone m_ragPos and m_ragAngles state, and complaining 'Ragdoll_Prop with %d bones != %d shapes (%s)' when a model's bone count disagrees with its collision shapes. Treat it as the point where a prop becomes a simulating ragdoll.", + "source": "generated" + }, + "CRagdollProp::InputDisableMotion": { + "text": "Handles the `DisableMotion` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InputEnableMotion": { + "text": "Handles the `EnableMotion` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InputFadeAndRemove": { + "text": "Handles the `FadeAndRemove` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InputTurnOff": { + "text": "Handles the `Disable` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InputTurnOn": { + "text": "Handles the `Enable` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::SettleThink": { + "text": "Runs the ragdoll's periodic settle check, the think that watches a simulating prop come to rest; m_allAsleep, m_flAwakeTime and m_vecLastOrigin are the state such a check works from. The class is implied by the name, so the sleep thresholds and interval are unverified.", + "source": "generated" + }, + "CReadyForMatchIssue::ExecuteCommand": { + "text": "Applies a passed ready-for-match vote by executing 'mp_warmup_pausetimer 0;', releasing the paused warmup timer so play can begin. Hook or replace this to change what a successful ready-up vote actually does on the server.", + "source": "generated" + }, + "CReadyForMatchIssue::GetVotePassedString": { + "text": "Supplies the localization token '#SFUI_vote_passed_ready_for_match' shown to players once the ready-for-match vote succeeds. Override it to change the passed-vote text presented for this vote issue.", + "source": "generated" + }, + "CRecipientFilter::AddAllPlayers": { + "text": "Populates a recipient filter with the players currently on the server so a network message reaches them, warning 'no recipients for this message, but %d player in process of connecting was not included' when the filter ends up empty while someone is still connecting. Use it when broadcasting a user message server-wide.", + "source": "generated" + }, + "CRefreshRateGetter::OnDeviceCreated": { + "text": "Responds to a render device being created, the moment this refresh-rate getter can pick up the new device's display timing. The class is implied by the name, and the reading is name-level only.", + "source": "generated" + }, + "CRefreshRateGetter::OnDeviceLost": { + "text": "Responds to a render device being lost, letting the refresh-rate getter discard the rate it held for the departed device. The class is implied by the name, so the exact response is unverified.", + "source": "generated" + }, + "CRefreshRateGetter::OnDeviceRestored": { + "text": "Responds to a render device being restored, the point at which a cached refresh rate would be re-read. The class is implied by the name, and what it refreshes is not established by this data.", + "source": "generated" + }, + "CRefreshRateGetter::OnModeChanged": { + "text": "Responds to a display mode change, the event that can alter the refresh rate this getter reports. The class is implied by the name, and the response is read from the name alone.", + "source": "generated" + }, + "CRenderDeviceBase::CreateConstantBufferInternal": { + "text": "Allocates a constant buffer on the render device, the block of uniform values shaders read from. This copy lives in librendersystemempty, so what the routine does in a dedicated-server build is not established here.", + "source": "generated" + }, + "CRenderDeviceBase::FindOrCreateTexture": { + "text": "Looks up a texture on the render device and creates it when none matching exists, handing back the shared object either way. The class is implied by the name; the lookup key and creation parameters are unverified.", + "source": "generated" + }, + "CRenderUtils::BeginOcclusionQueryDrawing": { + "text": "Opens an occlusion-query drawing region, so that pixels rasterized inside the region are accumulated into the query's count. The CRenderUtils class is implied by the name; the query object it operates on and the state it changes are unverified.", + "source": "generated" + }, + "CRenderUtils::Connect": { + "text": "Performs the app-system connect step for the render-utility module, wiring it to the engine interfaces it needs before use. The CRenderUtils class is implied by the name, and which interfaces it acquires is not established by this data.", + "source": "generated" + }, + "CRenderUtils::CreateOcclusionQueryObject": { + "text": "Allocates a new occlusion query object that can later measure how many pixels of drawn geometry survive depth testing. The CRenderUtils class is implied by the name; the handle's form and its lifetime rules are unverified.", + "source": "generated" + }, + "CRenderUtils::DestroyOcclusionQueryObject": { + "text": "Releases an occlusion query object previously allocated for pixel-visibility measurement, freeing whatever GPU-side resource backs it. The CRenderUtils class is implied by the name, and the handle form it expects is not established here.", + "source": "generated" + }, + "CRenderUtils::Disconnect": { + "text": "Drops the engine interface links the render-utility module holds, the app-system disconnect step. The CRenderUtils class is implied by the name, and the specific teardown it performs is not established.", + "source": "generated" + }, + "CRenderUtils::EndOcclusionQueryDrawing": { + "text": "Ends an occlusion-query drawing region so the query stops accumulating pixel counts and its result becomes readable. The CRenderUtils class is implied by the name, and which query object it closes is unverified.", + "source": "generated" + }, + "CRenderUtils::GetBuildType": { + "text": "Reports the build flavour the module was compiled as, the value app-system modules advertise for compatibility checks. The CRenderUtils class is implied by the name, and the enumeration behind the value is not established here.", + "source": "generated" + }, + "CRenderUtils::GetDependencies": { + "text": "Reports the other engine systems this module needs present before it can operate. The CRenderUtils class is implied by the name, and the contents of that dependency list are unverified.", + "source": "generated" + }, + "CRenderUtils::GetTier": { + "text": "Reports which engine tier the module belongs to, the layering value app-system modules expose. The CRenderUtils class is implied by the name, and the tier this build reports is not established.", + "source": "generated" + }, + "CRenderUtils::Init": { + "text": "Initialization entry point for the render-utility module; the specific setup it performs is not established. The CRenderUtils class is implied by the name.", + "source": "generated" + }, + "CRenderUtils::IsSingleton": { + "text": "Reports whether the module exists as one global instance rather than being created per consumer. The CRenderUtils class is implied by the name, and the answer this build gives is not established.", + "source": "generated" + }, + "CRenderUtils::OcclusionQuery_GetNumPixelsRendered": { + "text": "Reads back the pixel count an occlusion query recorded, i.e. how much of the tested geometry was actually rasterized, which visibility-driven effects use to fade or skip work. The CRenderUtils class is implied by the name, and the counting units and readback timing are unverified.", + "source": "generated" + }, + "CRenderUtils::PreShutdown": { + "text": "Runs the pre-shutdown pass for the render-utility module, releasing work it holds ahead of full teardown. The CRenderUtils class is implied by the name, and what it actually releases is not established.", + "source": "generated" + }, + "CRenderUtils::QueryInterface": { + "text": "Looks up a named interface the module implements, the standard app-system interface query. The CRenderUtils class is implied by the name, and which interface names it accepts is not established here.", + "source": "generated" + }, + "CRenderUtils::Reconnect": { + "text": "Rebinds one of the module's interface links, as used when a dependency is swapped or reloaded at runtime. The CRenderUtils class is implied by the name, and the exact rebinding behaviour is unverified.", + "source": "generated" + }, + "CRenderUtils::ResetOcclusionQueryObject": { + "text": "Clears an occlusion query object's recorded state so the same object can be reused for a fresh measurement. The CRenderUtils class is implied by the name, and the precise reset semantics are unverified.", + "source": "generated" + }, + "CRenderUtils::Shutdown": { + "text": "Shuts the render-utility module down, the teardown counterpart to its initialization. The CRenderUtils class is implied by the name, and the specific work it performs is not established.", + "source": "generated" + }, + "CResourceNameTyped::ResolveResourceName": { + "text": "Resolves a typed resource name into the canonical form the resource system stores it under, applying the naming and extension rules that the resource type expects so lookups match. Read from the name; the exact normalisation rules and the failure behaviour are unverified.", + "source": "generated" + }, + "CResourceStreamFixed::Commit": { + "text": "Finalizes the pending contents of a fixed-size resource stream, sealing the block it has been filling so it can be used as resource data. The CResourceStreamFixed class is implied by the name, and what commit makes visible is not established here.", + "source": "generated" + }, + "CResourceStreamFixed::~CResourceStreamFixed": { + "text": "Destroys a fixed-size resource stream, releasing the buffer it owns. The CResourceStreamFixed class is implied by the name, and the destructor's exact cleanup work is not established.", + "source": "generated" + }, + "CResourceSystem::BlockUntilManifestLoaded": { + "text": "Stalls until a resource manifest has finished loading, so code that follows can assume the resources it lists are present. The CResourceSystem class is implied by the name; how the manifest is identified and what happens on failure are unverified.", + "source": "generated" + }, + "CResourceSystem::FindOrCreateProceduralResource": { + "text": "Looks up a procedurally generated resource by key and creates it when none exists yet, giving callers a shared instance for runtime-built assets such as generated textures or materials. The CResourceSystem class is implied by the name, and the keying scheme is unverified.", + "source": "generated" + }, + "CResourceSystem::FrameUpdate": { + "text": "Advances the resource system's per-frame work, servicing pending loads and streaming. Read from the name at low confidence; the work performed each frame and its cadence are unverified.", + "source": "generated" + }, + "CResourceSystem::Init": { + "text": "Initialization entry point for the resource system; the specific setup it performs is not established. The CResourceSystem class is implied by the name.", + "source": "generated" + }, + "CResourceSystem::InstallResourceTypeManager": { + "text": "Registers a manager responsible for one resource type with the resource system, so files of that type can be recognised and loaded. The CResourceSystem class is implied by the name, and the registration details are unverified.", + "source": "generated" + }, + "CResourceSystem::InstallTestFilesystem": { + "text": "Substitutes a test filesystem for the resource system to read from, redirecting resource loads to an alternate source for testing. The CResourceSystem class is implied by the name, and the scope and reversibility of the substitution are unverified.", + "source": "generated" + }, + "CResourceSystem::InstallTypeManager": { + "text": "Registers a type manager with the resource system so it can service a class of resources. Read from the name alongside CResourceSystem::InstallResourceTypeManager; how the two differ is not established by this data.", + "source": "generated" + }, + "CResourceSystem::PreShutdown": { + "text": "Runs the resource system's pre-shutdown pass, quiescing outstanding work before full teardown. The CResourceSystem class is implied by the name, and the specific work it does is not established.", + "source": "generated" + }, + "CResourceSystem::Shutdown": { + "text": "Tears the resource system down, the counterpart to its initialization. The CResourceSystem class is implied by the name, and what it releases is not established here.", + "source": "generated" + }, + "CResourceSystem::Update_Internal": { + "text": "Internal update routine of the resource system, the private form the _Internal suffix marks. Read from the name; what it services and how often are unverified.", + "source": "generated" + }, + "CResponseSystem::LoadResponseSystem": { + "text": "Loads the response-rule data that drives spoken and scripted response selection into the response system. Read from the name at low confidence; the file format it consumes and where the data comes from are unverified.", + "source": "generated" + }, + "CRestore::FindOrAddRestoreLookupTable": { + "text": "Finds the lookup table used to map saved fields back onto a data class during restore, adding one when it is absent; the shipped diagnostic string \"%s: FindOrAddRestoreLookupTable( %s )\" prints the names involved. Read from that anchor and the name, so the table's contents and matching rules are unverified.", + "source": "generated" + }, + "CRevertSaved::InputReload": { + "text": "Handles the `Reload` entity-IO input on `CRevertSaved`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRopeKeyframe::InputBreak": { + "text": "Handles the `Break` entity-IO input on `CRopeKeyframe`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRopeKeyframe::InputSetForce": { + "text": "Handles the `SetForce` entity-IO input on `CRopeKeyframe`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRopeKeyframe::InputSetScrollSpeed": { + "text": "Handles the `SetScrollSpeed` entity-IO input on `CRopeKeyframe`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRuleEntity::CRuleEntity": { + "text": "Constructs a rule entity, the base used by entities that gate gameplay rules, bringing up its m_iszMaster field, which by its naming holds the entity name of a master the rule defers to. The \"CRuleEntity\" string anchor confirms the class; the constructor's actual initialization is unverified.", + "source": "generated" + }, + "CRulePointEntity::CRulePointEntity": { + "text": "Constructs the point-entity form of the rule entity, which carries the m_Score field for attaching a score value to the rule. The \"CRulePointEntity\" string anchor confirms the class; how m_Score is initialized and consumed is unverified.", + "source": "generated" + }, + "CSMovementVelocityQuantizer_t::Quantize": { + "text": "Snaps a velocity onto the coarser value grid this movement helper type defines, the kind of rounding used to keep server and client movement math agreeing bit-for-bit. Read from the name, with the string anchor merely repeating the class name, so the grid it quantizes to and where it is applied are unverified.", + "source": "generated" + }, + "CS_Script_SetModel": { + "text": "Sets an entity's model from the scripting layer, the binding a script author reaches for to swap a model at runtime. Read from the name; how the model is referenced, and whether collision or animation state is refreshed with it, are not established.", + "source": "generated" + }, + "CSaveRestoreFileSystemPassthrough::DirectoryClear": { + "text": "Wipes a directory of save/restore working files through the passthrough filesystem, emitting a traced \"WRITE DirectoryClear\" line that records the operation and the paths involved. Useful as a hook or log marker when auditing what a save or transition touches on disk.", + "source": "generated" + }, + "CSaveRestoreFileSystemPassthrough::DirectoryCopy": { + "text": "Copies save/restore files out of a directory through the passthrough filesystem, emitting a traced \"WRITE DirectoryCopy\" line naming the source and the destination it writes into. The anchor establishes the operation and its logging; the copy semantics beyond that are unverified.", + "source": "generated" + }, + "CSaveRestoreFileSystemPassthrough::DirectoryExtract": { + "text": "Extracts save/restore files from a packed directory back onto the filesystem through the passthrough layer, emitting a traced \"WRITE DirectoryExtract\" line recording both paths. Pair it with CSaveRestoreFileSystemPassthrough::DirectoryCopy when tracing how a save blob is unpacked during a restore.", + "source": "generated" + }, + "CSceneEntity::CancelPlayback": { + "text": "Aborts a choreographed scene that is currently running, ending it early rather than letting it finish; m_bIsPlayingBack, m_bCompletedEarly and the m_OnCanceled output are the state a caller should expect to be involved. The CSceneEntity class is implied by the name, and the vtable slot is unbound, so ownership is unverified.", + "source": "generated" + }, + "CSceneEntity::ClearSceneEvents": { + "text": "Discards the scene's queued choreography events, logging a timestamped \"clearing events\" line as it does so. Reach for it when a scene must be reset or torn down without its remaining speech and animation events firing.", + "source": "generated" + }, + "CSceneEntity::FindNamedActor": { + "text": "Looks up one of the scene's participating actors by name, resolving against the entity's m_ActorMap and m_hActorList membership. Read from the name and those fields; no string anchor or prototype is derived, so the lookup key format and failure behaviour are unverified.", + "source": "generated" + }, + "CSceneEntity::GenerateSceneForSequence": { + "text": "Builds a scene on the fly to play a single animation sequence, instead of loading an authored scene file; it warns \"Couldn't determine duration of %s\" when the sequence length cannot be resolved. m_bAutogenerated marks entities produced this way.", + "source": "generated" + }, + "CSceneEntity::GenerateSceneForSound": { + "text": "Builds a scene on the fly to play a single sound, instead of loading an authored scene file, warning \"Couldn't determine duration of %s\" when the sound length cannot be resolved. m_iszSoundName and m_bAutogenerated are the fields describing such a generated scene.", + "source": "generated" + }, + "CSceneEntity::InputCancelAtNextInterrupt": { + "text": "Handles the `CancelAtNextInterrupt` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputCancelPlayback": { + "text": "Handles the `Cancel` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputInterjectResponse": { + "text": "Handles the `InterjectResponse` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputPauseAtNextInterrupt": { + "text": "Handles the `PauseAtNextInterrupt` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputPausePlayback": { + "text": "Handles the `Pause` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputPitchShiftPlayback": { + "text": "Handles the `PitchShift` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputResumePlayback": { + "text": "Handles the `Resume` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputScriptPlayerDeath": { + "text": "Handles the `ScriptPlayerDeath` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputSetTarget2": { + "text": "Handles the `SetTarget2` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputStartPlayback": { + "text": "Handles the `Start` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputStopWaitingForActor": { + "text": "Handles the `StopWaitingForActor` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::LoadScene": { + "text": "Loads the choreography file named by m_iszSceneFile, complaining that the file is \"missing from scenes.vcdlist_c\" when it is absent from the compiled scene manifest; m_bSceneMissing records that outcome. That anchor is the practical clue for modders shipping custom scenes that were never compiled into the manifest.", + "source": "generated" + }, + "CSceneEntity::PauseThink": { + "text": "Drives the scene entity while it is held paused, re-evaluating whether the pause conditions still hold; m_bPaused, m_bPausedViaInput, m_bWaitingForActor and m_bWaitingForInterrupt are the pause state involved. The CSceneEntity class is implied by the name and the vtable slot is unbound, so ownership and resume conditions are unverified.", + "source": "generated" + }, + "CSceneEntityAlias_logic_choreographed_scene::PauseThink": { + "text": "Serves the paused-scene think for the logic_choreographed_scene entity alias, the mapper-facing form of the scene entity. The class is implied by the name and the vtable slot is unbound, so whether this is distinct behaviour or the alias's view of the same scene pause handling is unverified.", + "source": "generated" + }, + "CSceneListManager::InputShutdown": { + "text": "Handles the `Shutdown` entity-IO input on `CSceneListManager`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneSystem::FinishRenderingViews": { + "text": "Closes out the scene system's outstanding view-rendering work, the counterpart to whatever submitted those views. The CSceneSystem class is implied by the name and the vtable slot is unbound; on a dedicated server this path is of limited interest to gameplay modders.", + "source": "generated" + }, + "CSceneSystem::FrameUpdate": { + "text": "Advances the scene system by one frame, giving it its per-frame tick of work. The CSceneSystem class is implied by the name and the vtable slot is unbound, so what the update covers and how it is scheduled are unverified.", + "source": "generated" + }, + "CSceneSystem::WaitForRenderingToComplete": { + "text": "Blocks until the scene system's in-flight rendering work has finished, a synchronisation point rather than a gameplay operation. The CSceneSystem class is implied by the name and the vtable slot is unbound, so the exact work it waits on is unverified.", + "source": "generated" + }, + "CSchemaSystem::VerifySchemaBindingConsistency": { + "text": "Checks that the class and enum bindings registered with the schema system still agree with the schema the binary actually loaded, the sanity check that catches stale or mismatched bindings. The CSchemaSystem class is implied by the name and the vtable slot is unbound; useful to know about when a game update breaks schema-dependent tooling.", + "source": "generated" + }, + "CSchemaSystemTypeScope::InsertNewClassBinding": { + "text": "Registers a new class binding into a schema type scope, the step that makes a class's fields and offsets visible to schema lookups within that scope. Lives in libschemasystem; read from the name, so the binding structure it takes and duplicate handling are unverified.", + "source": "generated" + }, + "CSchemaSystemTypeScope::InsertNewEnumBinding": { + "text": "Registers a new enum binding into a schema type scope, making that enum's members resolvable through schema queries in the scope. Lives in libschemasystem; the counterpart to CSchemaSystemTypeScope::InsertNewClassBinding for enumerations, though the exact registration data is unverified.", + "source": "generated" + }, + "CSchemaSystemTypeScope::PromoteUnresolvedAndGlobalTypes": { + "text": "Resolves type references a scope could not bind when they were first seen and lifts globally-visible types into place, the fix-up pass that makes cross-module schema types usable. Read from the name in libschemasystem with no anchor or prototype derived, so the promotion rules and when it runs are unverified.", + "source": "generated" + }, + "CSchemaType::ToString": { + "text": "Renders a schema type into its human-readable textual form, the spelling used when a type must be printed or compared as text; the \"modifierhandle,\" anchor points at type-modifier fragments appearing in that output. Handy for dumping schema layouts, though the full grammar it produces is unverified.", + "source": "generated" + }, + "CScrambleTeams::ExecuteCommand": { + "text": "Carries out the scramble-teams action, driving the game through \"mp_scrambleteams 2;\" so team membership is shuffled. This is the execution half of the scramble vote, and the anchor shows the convar command that actually performs it.", + "source": "generated" + }, + "CScrambleTeams::GetDisplayString": { + "text": "Supplies the text shown for the scramble-teams option, returning the localisation token \"#SFUI_vote_scramble_teams\" rather than literal English. Look here when relabelling or localising the scramble entry in a vote menu.", + "source": "generated" + }, + "CScriptComponent::DispatchPrecache": { + "text": "Fires the precache pass for an entity's script side, giving the attached script a chance to declare the assets it needs before they are required; m_scriptClassName identifies which script class is involved. The anchor is the method name itself, so the precache contract is read from the name.", + "source": "generated" + }, + "CScriptComponent::InstallClasses": { + "text": "Registers script classes with the scripting VM so entity scripts can be bound to them, with m_scriptClassName naming the class an entity's component uses. The anchor repeats the method name, so what set of classes is installed and in which VM state is unverified.", + "source": "generated" + }, + "CScriptConvarAccessor::GetBool": { + "text": "Reads a convar's value as a boolean for script code, warning \"failed to parse convar '%s' (value '%s') as bool\" when the stored text is not boolean-like. That message is the thing to grep for when a script convar silently behaves as false.", + "source": "generated" + }, + "CScriptConvarAccessor::RegisterCommand": { + "text": "Registers a console command from script, wiring a script function up as the command's handler so it can be invoked from console or config. Read from the name; no string anchor or prototype is derived, so flags, help text and callback conventions are unverified.", + "source": "generated" + }, + "CScriptConvarAccessor::RegisterConvar": { + "text": "Creates a convar on behalf of script code, making a script-owned setting visible and settable through the normal console. The companion to CScriptConvarAccessor::RegisterCommand for values rather than actions; default, flags and type handling are unverified.", + "source": "generated" + }, + "CScriptGameEventListener::ScriptListenToGameEvent": { + "text": "Subscribes a script callback to a named game event, and refuses the subscription with \"error: event %s given a nil function\" when no callback is supplied. This is the script-side entry point for reacting to events such as rounds, deaths and damage.", + "source": "generated" + }, + "CScriptManager::Connect": { + "text": "Wires the script manager into the engine's interface system so it can acquire the services it needs at start-up. Class membership is implied by the name, and the reading rests on the name plus the usual Source-2 interface-connect convention, so what it actually acquires is unverified.", + "source": "generated" + }, + "CScriptManager::CreateVM": { + "text": "Creates a script virtual machine instance for the scripting system to run game scripts in. Class membership is implied by the name; the reading is name-level only, so the language, configuration and lifetime rules of the VM are unverified.", + "source": "generated" + }, + "CScriptManager::DestroyVM": { + "text": "Tears down a script virtual machine and releases the resources it holds. Class membership is implied by the name, and although this entry has a derived prototype, the destruction semantics themselves are read from the name.", + "source": "generated" + }, + "CScriptManager::Disconnect": { + "text": "Drops the engine interfaces the script manager holds, the teardown side of connecting to them. Class membership is implied by the name, and the reading comes from the name and the standard Source-2 interface convention, so it is unverified.", + "source": "generated" + }, + "CScriptManager::GetBuildType": { + "text": "Reports which build flavour the scripting module was produced as, such as debug versus release. Class membership is implied by the name; read from the name alone, and the encoding used for the answer is unverified.", + "source": "generated" + }, + "CScriptManager::GetDebugger": { + "text": "Hands back the script debugger object the manager owns, useful to tooling that wants to inspect or step running scripts. Class membership is implied by the name, and while a prototype is derived here, the debugger object's own interface is read from the name.", + "source": "generated" + }, + "CScriptManager::GetDependencies": { + "text": "Reports the other engine modules the scripting system depends on, as the appsystem dependency mechanism expects. Class membership is implied by the name, and a prototype is derived, but the form of the dependency list is read from the name.", + "source": "generated" + }, + "CScriptManager::GetTier": { + "text": "Reports the appsystem tier the script manager belongs to, the classification the engine uses to group modules. Class membership is implied by the name, and this reading comes from the name and the standard Source-2 appsystem convention.", + "source": "generated" + }, + "CScriptManager::Init": { + "text": "Purpose is not established: the name marks generic subsystem start-up and says nothing about what is set up. Class membership is implied by the name.", + "source": "generated" + }, + "CScriptManager::IsSingleton": { + "text": "Reports whether the scripting module permits only a single instance of itself, a standard appsystem query. Class membership is implied by the name, and the reading is name-level only.", + "source": "generated" + }, + "CScriptManager::PreShutdown": { + "text": "Runs the early teardown phase of the scripting system, the stage where script state would be quiesced ahead of full shutdown. Class membership is implied by the name, and what it releases is read from the name and so unverified.", + "source": "generated" + }, + "CScriptManager::QueryInterface": { + "text": "Looks up an interface the scripting module exposes, by name, and yields it to the requester. Class membership is implied by the name, and the reading follows the name and the standard Source-2 interface-query convention; the accepted interface names are unverified.", + "source": "generated" + }, + "CScriptManager::Reconnect": { + "text": "Re-acquires the engine interfaces the script manager uses, the operation the engine performs when modules are swapped or reloaded. Class membership is implied by the name, and the reading is name-level, so the conditions under which it runs are unverified.", + "source": "generated" + }, + "CScriptManager::Shutdown": { + "text": "Shuts the scripting system down and releases what it still holds. Class membership is implied by the name, and the specifics of the teardown are read from the name and remain unverified.", + "source": "generated" + }, + "CScriptedSequence::InputBeginSequence": { + "text": "Handles the `BeginSequence` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CScriptedSequence::InputCancelSequence": { + "text": "Handles the `CancelSequence` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CScriptedSequence::InputForceTarget": { + "text": "Handles the `ForceTarget` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CScriptedSequence::InputMoveToPosition": { + "text": "Handles the `MoveToPosition` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CScriptedSequence::InputScriptPlayerDeath": { + "text": "Handles the `ScriptPlayerDeath` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CScriptedSequence::ScriptThink": { + "text": "Runs the periodic update of a scripted sequence, advancing playback across the stages tracked by m_bIsPlayingPreIdle, m_bIsPlayingEntry, m_bIsPlayingAction and m_bIsPlayingPostIdle. Read from the name together with m_bThinking and m_startTime; the update interval and the exact state transitions are unverified.", + "source": "generated" + }, + "CSequentialPrerequisite::OnStatusFinished": { + "text": "Handles the notification that a prerequisite step has finished, letting the sequential prerequisite record that completion. Class membership is implied by the name, and the reading is name-level, so what counts as finished and what is recorded are unverified.", + "source": "generated" + }, + "CServerGameDLL::GetGameDescription": { + "text": "Supplies the human-readable game description the server advertises, the text seen as the game type in server browsers and query replies. Read from the name; where the text originates and whether mods can change it here are unverified.", + "source": "generated" + }, + "CServerOnlyEntity::CServerOnlyEntity": { + "text": "Constructs a server-only entity and sets up its initial state. The class name CServerOnlyEntity appears verbatim as a string anchor in libserver, and the name indicates an entity that lives on the server without being replicated to clients; the construction details are unverified.", + "source": "generated" + }, + "CServerOnlyModelEntity::CServerOnlyModelEntity": { + "text": "Constructs a server-only entity that carries a model, establishing its initial state. Read from the name, which pairs model-bearing behaviour with server-side-only existence; what the constructor initialises is unverified.", + "source": "generated" + }, + "CServerOnlyPointEntity::CServerOnlyPointEntity": { + "text": "Constructs a server-only point entity, a positional helper with no model that exists only on the server. Read from the name; the initial state it establishes is unverified.", + "source": "generated" + }, + "CServerSideClient::ActivatePlayer": { + "text": "Activates the player belonging to this client connection, taking it from connected-but-inert to a live, simulating in-game player. The class is implied by the name; a prototype is derived but the behaviour reading is name-level, so what activation touches on the player is unverified.", + "source": "generated" + }, + "CServerSideClient::Await": { + "text": "Reads as a wait or synchronisation point on a client connection, holding until some pending client-side work settles. The class is implied by the name, and the name alone does not say what is awaited, so the purpose is not established.", + "source": "generated" + }, + "CServerSideClient::CLCMsg_RespondCvarValue": { + "text": "Handles the client-to-server RespondCvarValue message, in which a client reports the value of a cvar the server asked it for. The class is implied by the name; the CLCMsg_ prefix and the name are the whole of the evidence, so the payload handling is unverified.", + "source": "generated" + }, + "CServerSideClient::CLCMsg_VoiceData": { + "text": "Handles the client-to-server VoiceData message carrying a player's voice payload for server-side handling. The class is implied by the name; it reads as the hook point for mute lists, proximity voice or voice capture, though the payload format and handling are unverified.", + "source": "generated" + }, + "CServerSideClient::ExecuteStringCommand": { + "text": "Executes a console command string submitted by this client, the server-side entry for client-typed text commands. The class is implied by the name; it reads as the natural place to filter, block or log client commands, though the parsing and handling details are unverified.", + "source": "generated" + }, + "CServerSideClient::IsHearingClient": { + "text": "Reports whether this client currently hears another client, the audibility predicate behind server-side voice. The class is implied by the name; useful for team-only or distance-based voice rules, though which client is tested and how audibility is decided are name-level readings.", + "source": "generated" + }, + "CServerSideClient::ProcessBaselineAck": { + "text": "Handles a client's acknowledgement of an entity baseline, letting the server know which baseline that client has confirmed for delta-compressed entity updates. Read from the name; confidence is low and no prototype is derived, so the acknowledgement's contents and effects are unverified.", + "source": "generated" + }, + "CServerSideClient::ProcessMove": { + "text": "Processes the movement input arriving from this client, turning the client's user commands into server-side player motion. The class is implied by the name; the reading is name-level, so what it validates, clamps or rejects is unverified.", + "source": "generated" + }, + "CServerSideClient::ProcessRespondCvarValue": { + "text": "Handles a client's response to a server cvar query, consuming the reported cvar value for that connection. The class is implied by the name; it sits at the same vtable slot as CServerSideClient::CLCMsg_RespondCvarValue, so the two names likely describe one routine, and the handling is unverified.", + "source": "generated" + }, + "CServerSideClient::SendInitialSpawnGroups": { + "text": "Sends a joining client its initial set of spawn groups, the world-content loading units the client must have resident. The class is implied by the name; relevant when a mod adds or streams extra world content, though how the set is chosen is unverified.", + "source": "generated" + }, + "CServerSideClient::SendNetMessage": { + "text": "Sends a network message to this client over its connection, the general server-to-client transmit path. The class is implied by the name; it reads as the place to inject, filter or drop per-client messages, though the message representation and delivery guarantees are unverified.", + "source": "generated" + }, + "CServerSideClient::SendSnapshot": { + "text": "Sends this client a snapshot of world state for the current tick, the per-client entity update the client renders from. Read from the name; no prototype is derived, so the snapshot contents and any delta handling are unverified.", + "source": "generated" + }, + "CServerSideClient::SetName": { + "text": "Sets the name recorded for this client connection, the counterpart to CServerSideClient::m_Name. The class is implied by the name; useful for server-side renaming or name sanitising, though whether it also informs other clients is unverified.", + "source": "generated" + }, + "CServerSideClient::SpawnGroup_LoadCompleted": { + "text": "Handles the completion of a spawn group's load for this client, marking that streamed world content is now resident for the connection. The class is implied by the name; pairs with CServerSideClient::SendInitialSpawnGroups when debugging content loading, though the specifics are name-level.", + "source": "generated" + }, + "CServerSideClient::UpdateUserSettings": { + "text": "Refreshes the server's copy of this client's user settings, the client-side convars a connection reports. The class is implied by the name; a hook point for reading or enforcing per-client settings, though which settings are covered and when they refresh is unverified.", + "source": "generated" + }, + "CServerSideClient::m_ControllerEntityIndex": { + "text": "Exposes the entity index of the player controller bound to this client connection, the link from a connection to its in-world controller. The class and the member reading are implied by the name; it appears as a vtable entry rather than a schema field, so accessor semantics are unverified.", + "source": "generated" + }, + "CServerSideClient::m_GameServer": { + "text": "Exposes the game-server object that owns this client connection, the route from a client back to its host server. The class and the member reading are implied by the name; it appears as a vtable entry rather than a schema field, so what it yields is unverified.", + "source": "generated" + }, + "CServerSideClient::m_Name": { + "text": "Exposes the name stored for this client connection, the read side matching CServerSideClient::SetName. The class and the member reading are implied by the name; it appears as a vtable entry rather than a schema field, so the exact accessor behaviour is unverified.", + "source": "generated" + }, + "CServerSideClient::m_Slot": { + "text": "Exposes the client slot index for this connection, the small per-server index that identifies a player among the server's clients. The class and the member reading are implied by the name; it appears as a vtable entry rather than a schema field, so the accessor's form is unverified.", + "source": "generated" + }, + "CServerSideClientBase::ActivatePlayer": { + "text": "Activates the player for a client connection at the base-client level, the name-suggested counterpart to CServerSideClient::ActivatePlayer. A prototype is derived, but the behaviour reading comes from the name, so the activation's effects on the player are unverified.", + "source": "generated" + }, + "CServerSideClientBase::Connect": { + "text": "Establishes a client connection on the server, populating the base client object for a newly connecting player. Read from the name with a derived prototype; the connection inputs and whether it can reject a connection are unverified.", + "source": "generated" + }, + "CServerSideClientBase::SetSignonState": { + "text": "Sets the signon state of a client connection, the staged progression a connecting client moves through before it counts as fully in-game. Read from the name; the state values and what changing them entails are unverified.", + "source": "generated" + }, + "CShaderCreateCallbacks::OnCreateBlendState": { + "text": "Handles creation of a blend-state object for the shader system, the colour-blending configuration a draw is set up with. The class is implied by the name; this is renderer-side machinery rather than gameplay, and the reading is name-level.", + "source": "generated" + }, + "CShaderCreateCallbacks::OnCreateDepthStencilState": { + "text": "Handles creation of a depth-stencil state object for the shader system, the depth and stencil test configuration a draw is set up with. The class is implied by the name; renderer-side rather than gameplay, and the reading is name-level.", + "source": "generated" + }, + "CShaderCreateCallbacks::OnCreateRasterizerState": { + "text": "Handles creation of a rasterizer state object for the shader system, the configuration governing how triangles are rasterised. The class is implied by the name; renderer-side rather than gameplay, and the reading is name-level.", + "source": "generated" + }, + "CShaderCreateCallbacks::OnCreateShader": { + "text": "Handles creation of a shader object for the render backend, the callback the shader system offers at shader instantiation. The class is implied by the name; a prototype is derived, but the creation semantics remain a name-level reading and this is renderer-side, not gameplay.", + "source": "generated" + }, + "CShaderCreateCallbacks::~CShaderCreateCallbacks": { + "text": "Destroys a shader-create-callbacks object, tearing down the callback holder and whatever it owns. The class is implied by the name; as a destructor its purpose is teardown, and nothing here establishes which resources are released.", + "source": "generated" + }, + "CShatterGlassShard::CShatterGlassShard": { + "text": "Constructs a shatter-glass shard, the record for one broken piece of a glass panel, whose fields carry panel-space geometry (m_vecPanelVertices, m_flArea) and links such as m_hParentPanel and m_hPhysicsEntity. Purpose beyond construction is not established here; confidence is low and no prototype is derived.", + "source": "generated" + }, + "CShatterGlassShardMgr::GrowCount": { + "text": "Grows the shard manager's capacity, extending the storage that holds shatter-glass shards; the literal GrowCount is present as a string anchor. Confidence is low and no prototype is derived, so the growth policy and what is counted are unverified.", + "source": "generated" + }, + "CShatterGlassShardMgr::ReadRestoreHeaders": { + "text": "Reads the headers of saved shatter-glass shard data during a restore and skips shards when the saved version does not match, logging 'skipping shards due to version mismatch (got %d, expecting %d)'. That string is the evidence; useful when restored broken glass goes missing, though the remaining parsing is unverified.", + "source": "generated" + }, + "CShatterGlassShardMgr::Restore": { + "text": "Restores the shatter-glass shard manager's state from saved data, rebuilding the broken-glass shards recorded for a level. Read from the name and its pairing with CShatterGlassShardMgr::ReadRestoreHeaders; confidence is low and no prototype is derived, so the restore's scope is unverified.", + "source": "generated" + }, + "CSkeletonAnimationController::CSkeletonAnimationController": { + "text": "Constructs a skeleton animation controller, the object driving animation for one skeleton, whose m_pSkeletonInstance field points at the CSkeletonInstance it works on. Purpose beyond construction is not established from this data.", + "source": "generated" + }, + "CSkeletonInstance::AddAnimationDecode": { + "text": "Adds an animation decode step to a skeleton instance's pending pose work, contributing to the bones evaluated for its model. Read from the name, which is also present verbatim as a string anchor in libserver; m_modelState is the field to inspect alongside it, but the inputs and timing are unverified.", + "source": "generated" + }, + "CSkeletonInstance::CalcAnimationState": { + "text": "Computes the current animation state of a skeleton instance, the per-frame result that drives its bone pose. Read from the name, which appears verbatim as a string anchor; the state it produces and what it reads to produce it are unverified, though m_modelState is the related schema field.", + "source": "generated" + }, + "CSkeletonInstance::SetAnimationController": { + "text": "Attaches or replaces the animation controller that drives a skeleton instance's animation. Read from the name and its matching string anchor in libserver; confidence is low, and neither the controller it accepts nor its effect on m_modelState is established.", + "source": "generated" + }, + "CSkeletonInstance::SetupModel": { + "text": "Prepares a skeleton instance for use with a model, the binding behind model-derived data such as m_materialGroup and m_nHitboxSet. Read from the name plus its matching string anchor in libserver; confidence is low and the specific setup work performed on m_modelState is not established.", + "source": "generated" + }, + "CSkyCamera::InputActivateSkybox": { + "text": "Handles the `ActivateSkybox` entity-IO input on `CSkyCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSmokeGrenade::EmitGrenade": { + "text": "Emits the thrown smoke grenade, the weapon-side act that puts a live smoke projectile into the world. The CSmokeGrenade class is implied by the name rather than by the data, and this entry is located at an unbound vtable slot with no derived prototype, so its behaviour is unverified.", + "source": "generated" + }, + "CSmokeGrenadeProjectile::BounceSound": { + "text": "Plays the soundscript entry SmokeGrenade.Bounce for a smoke grenade projectile striking a surface; that string is this function's anchor in libserver. m_flLastBounce is the field to read when tuning or rate-limiting bounce audio, though the conditions guarding the sound are unverified.", + "source": "generated" + }, + "CSmokeGrenadeProjectile::Detonate": { + "text": "Detonates a smoke grenade projectile, the event recorded by m_vSmokeDetonationPos, m_nSmokeEffectTickBegin and m_bDidSmokeEffect and the natural place to alter smoke behaviour. The CSmokeGrenadeProjectile class is implied by the name, not by the data, which locates this at an unbound vtable slot with no derived prototype.", + "source": "generated" + }, + "CSmokeGrenadeProjectile::EmitGrenade": { + "text": "Creates and launches the smokegrenade_projectile entity, whose classname is this function's string anchor; the same function also ships as CSmokeGrenadeProjectile_CreateFunc, naming it the projectile's creation entry point. Hook it to influence a smoke's spawn-time state such as m_nRandomSeed or m_vSmokeColor.", + "source": "generated" + }, + "CSmokeGrenadeProjectile_CreateFunc": { + "text": "Creates and launches a smoke grenade projectile, carrying the entity-class string smokegrenade_projectile. Shipped also as CSmokeGrenadeProjectile::EmitGrenade at medium confidence, making it the point to intervene in smoke spawning.", + "source": "generated" + }, + "CSosEventInfoWithFieldData_t::~CSosEventInfoWithFieldData_t": { + "text": "Destroys a sound-operator-system event-info record that carries field data with it, releasing whatever that record owns. The owning class is implied by the name, and the data gives an unbound vtable slot with no derived prototype, so the exact cleanup is unverified.", + "source": "generated" + }, + "CSosOperatorStack::ImportMembers": { + "text": "Imports member entries into a sound-operator stack, folding operators or fields defined elsewhere into one stack. Read from the name; the function lives in libsoundsystem and the source of the imported members, along with any name-collision handling, is unverified.", + "source": "generated" + }, + "CSosOperatorStack::ParseKV": { + "text": "Parses a KeyValues block into a sound-operator stack, turning authored operator-stack text into the runtime stack that sound events evaluate. Read from the name in libsoundsystem; the KeyValues layout it accepts and its behaviour on malformed input are unverified.", + "source": "generated" + }, + "CSosSetLibraryStackFieldsInfo_t::~CSosSetLibraryStackFieldsInfo_t": { + "text": "Destroys the request record describing which fields to set on a sound-operator library stack, freeing anything it holds. Its class is implied by the name rather than derived from the data, which supplies an unbound vtable slot and no prototype, so the members released are unverified.", + "source": "generated" + }, + "CSosSetSoundEventFieldsInfo_t::~CSosSetSoundEventFieldsInfo_t": { + "text": "Destroys the record describing field values to apply to a sound event, releasing its contents. The class is implied by the name rather than derived, and the entry sits at an unbound vtable slot with no prototype, so the specific cleanup is not established.", + "source": "generated" + }, + "CSosStartSoundEventQueueInfo_t::~CSosStartSoundEventQueueInfo_t": { + "text": "Destroys a queued request record for starting a sound event, releasing whatever the queue entry owns. The class is implied by the name rather than by the data, which gives an unbound vtable slot and no prototype, so its members and their cleanup are unverified.", + "source": "generated" + }, + "CSoundAreaEntityBase::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CSoundAreaEntityBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundControllerImp::ResumeSound": { + "text": "Resumes playback of a sound that was previously paused through the sound-controller implementation. The CSoundControllerImp class is implied by the name; the entry is an unbound vtable slot with no derived prototype, so how the target sound is identified and what happens if it was never paused are unverified.", + "source": "generated" + }, + "CSoundEmitterSystem::EmitSound": { + "text": "Emits a sound through the shared sound-emitter system, the server-side path for playing a sound cue, anchored to the source path ../../game/shared/soundemittersystem.cpp. It also ships as SoundEmitterSystem::EmitSoundByHandle, a handle-based emit, and its prototype is verified, making it a practical hook for intercepting or replacing server sounds.", + "source": "generated" + }, + "CSoundEventConeEntity::SoundEventConeThink": { + "text": "Runs the periodic update for a cone-shaped sound event entity, evaluating listener position against the cone and driving the operator variable named by m_iszParameterName. Read from the name; m_flEmitterAngle, m_flSweetSpotAngle, m_flAttenMin and m_flAttenMax shape the result, but confidence is low and the computation is unverified.", + "source": "generated" + }, + "CSoundEventEntity::CSoundEventEntity": { + "text": "Constructs a sound event entity, initialising the object that carries m_iszSoundName, m_bStartOnSpawn and m_hSource. Read from the name as a constructor; confidence is low and the specific default values it writes are not established.", + "source": "generated" + }, + "CSoundEventEntity::InputPauseSound": { + "text": "Handles the `PauseSound` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputSetSoundName": { + "text": "Handles the `SetSoundEventName` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputSetSourceEntity": { + "text": "Handles the `SetSourceEntity` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputStartSoundOnAllClients": { + "text": "Handles the `StartSound` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputStartSoundOnSingleClient": { + "text": "Handles the `StartSoundOnSingleClient` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputStopSound": { + "text": "Handles the `StopSound` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputUnPauseSound": { + "text": "Handles the `UnPauseSound` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::StartSound": { + "text": "Starts the sound configured on a sound event entity, playing m_iszSoundName from the source tracked in m_hSource. The CSoundEventEntity class is implied by the name, and the entry is an unbound vtable slot with no derived prototype, so the trigger conditions and audience are unverified.", + "source": "generated" + }, + "CSoundEventEntity::StartSoundOnSingleClient": { + "text": "Starts the entity's sound for one client rather than for everyone hearing it, the per-player form of sound event playback. The class is implied by the name; the data gives an unbound vtable slot with no prototype, so how the recipient is chosen \u2014 m_nEntityIndexSelection being the related field \u2014 is unverified.", + "source": "generated" + }, + "CSoundEventManager::AddSoundEvent": { + "text": "Registers a sound event with the sound event manager, making it a tracked event the manager can hand back and control. CSoundEventManager is implied by the name, and the entry is an unbound vtable slot with no derived prototype, so the identity and lifetime of the registered event are unverified.", + "source": "generated" + }, + "CSoundEventManager::GetSoundEvent": { + "text": "Looks up a sound event held by the sound event manager, yielding the matching event record. The class is implied by the name; the entry is an unbound vtable slot with no derived prototype, so the lookup key and the behaviour on a miss are unverified.", + "source": "generated" + }, + "CSoundEventManager::GetSoundEventStackHash": { + "text": "Retrieves the hash identifying the operator stack a sound event is running under, the value used to tell one stack from another. CSoundEventManager is implied by the name; its prototype is verified, but the hashing scheme and how the event is addressed are not established.", + "source": "generated" + }, + "CSoundEventOBBEntity::SoundEventOBBThink": { + "text": "Runs the periodic update for an oriented-box sound event entity, evaluating position against the volume bounded by m_vMins and m_vMaxs. Read from the name; confidence is low, and what the update computes and writes is unverified.", + "source": "generated" + }, + "CSoundEventParameter::InputSetEventGuid": { + "text": "Handles the `SetSoundEventGUID` entity-IO input on `CSoundEventParameter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventParameter::InputSetFloatValue": { + "text": "Handles the `SetFloatValue` entity-IO input on `CSoundEventParameter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventParameter::InputSetParamName": { + "text": "Handles the `SetParamName` entity-IO input on `CSoundEventParameter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventPathCornerEntity::SoundEventPathCornerThink": { + "text": "Runs the periodic update for a path-corner sound event entity, tracking position against the corner chain named by m_iszPathCorner and mirrored in m_vecCornerPairsNetworked. Read from the name; m_flDistanceMax, m_flDotProductMax and m_bPlaying bound and record the result, but confidence is low and the computation is unverified.", + "source": "generated" + }, + "CSoundEventSphereEntity::SoundEventSphereThink": { + "text": "Runs the periodic update for a spherical sound event entity, evaluating position against the sphere sized by m_flRadius. Read from the name; confidence is low and the values it computes or writes are not established.", + "source": "generated" + }, + "CSoundOpGameSystem::SetLibraryStackField": { + "text": "Sets a named field on a sound-operator library stack from game code; its string anchor is the failure log 'CSoundOpGameSystem::SetLibraryStackField: Faied library stack message to: %s, %s, %s' (Valve's typo), printed when the request cannot be applied. This is the server-side route for driving library-stack values that sound operators read.", + "source": "generated" + }, + "CSoundOpGameSystem::StopSoundEvent": { + "text": "Stops a running sound event from game code, logging 'CSoundOpGameSystem::StopSoundEvent: Attempting to stop non-existent soundevent: %s' when the named event is not currently active. That message makes this the place to look when a scripted stop appears to do nothing.", + "source": "generated" + }, + "CSoundOpSystem::SosStartup": { + "text": "Performs startup for the sound operator system behind the Sos-prefixed types, bringing its stacks and operators into a usable state. CSoundOpSystem is implied by the name, and the entry is an unbound vtable slot with no derived prototype, so what it initialises is unverified.", + "source": "generated" + }, + "CSoundOpvarSetAABBEntity::CSoundOpvarSetAABBEntity": { + "text": "Constructs an axis-aligned-box sound opvar entity, the mapper-placed volume that drives a sound operator variable from position within it. Read from the name as a constructor; confidence is low and the initial values it writes are not established.", + "source": "generated" + }, + "CSoundOpvarSetBoxEntity::CSoundOpvarSetBoxEntity": { + "text": "Constructs a box-shaped sound opvar entity, the object holding the inner and outer extents from m_vInnerMins through m_vOuterMaxs plus the axis in m_nBoxDirection used to map position onto an operator variable. Read from the name as a constructor; confidence is low and the defaults it writes are unverified.", + "source": "generated" + }, + "CSoundOpvarSetEntity::InputChangeOpvarValue": { + "text": "Handles the `ChangeOpvarValue` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputChangeOpvarValueAndSet": { + "text": "Handles the `ChangeOpvarValueAndSet` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetEventGuid": { + "text": "Handles the `SetSoundEventGUID` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetOperatorName": { + "text": "Handles the `SetOperatorName` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetOpvar": { + "text": "Handles the `SetOpvar` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetOpvarIndex": { + "text": "Handles the `SetOpvarIndex` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetOpvarName": { + "text": "Handles the `SetOpvarName` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetStackName": { + "text": "Handles the `SetStackName` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetOBBWindEntity::SetOpvarThink": { + "text": "Runs the periodic update driving a wind operator variable from an oriented box, relating distance within m_vDistanceMins and m_vDistanceMaxs to the output range m_flWindMapMin to m_flWindMapMax. Read from the name; confidence is low, and the exact mapping and the role of m_flWindMin and m_flWindMax are unverified.", + "source": "generated" + }, + "CSoundOpvarSetPathCornerEntity::SetOpvarThink": { + "text": "Runs the periodic update driving a sound operator variable from position along the path named by m_iszPathCornerEntityName, scaled between m_flDistMinSqr and m_flDistMaxSqr. Read from the name; m_bUseParentedPath selects how the path is interpreted, but confidence is low and the computed value is unverified.", + "source": "generated" + }, + "CSoundOpvarSetPointBase::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetEventGuid": { + "text": "Handles the `SetSoundEventGUID` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetOperatorName": { + "text": "Handles the `SetOperatorName` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetOpvarIndex": { + "text": "Handles the `SetOpvarIndex` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetOpvarName": { + "text": "Handles the `SetOpvarName` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetSourceEntity": { + "text": "Handles the `SetSourceEntity` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetStackName": { + "text": "Handles the `SetStackName` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointEntity::CSoundOpvarSetPointEntity": { + "text": "Constructs a sound operator-variable point entity and puts its tuning fields into a starting state, including the distance band m_flDistanceMin/m_flDistanceMax and the occlusion values m_flOcclusionMin/m_flOcclusionMax. Read from the constructor name and the class's fields; which defaults it actually writes is not established here.", + "source": "generated" + }, + "CSoundOpvarSetPointEntity::InputSetDisabledValue": { + "text": "Handles the `SetDisabledValue` entity-IO input on `CSoundOpvarSetPointEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointEntity::InputSetDistanceMapMax": { + "text": "Handles the `SetDistanceMapMax` entity-IO input on `CSoundOpvarSetPointEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointEntity::InputSetDistanceMapMin": { + "text": "Handles the `SetDistanceMapMin` entity-IO input on `CSoundOpvarSetPointEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointEntity::SetOpvarThink": { + "text": "Runs the entity's periodic think that recomputes the operator variable it drives, remapping listener distance through m_flDistanceMapMin and m_flDistanceMapMax and accounting for occlusion. Read from the name and the class's distance, occlusion and pathing fields; the think interval and the value finally pushed are unverified.", + "source": "generated" + }, + "CSoundPatch::ResumeSound": { + "text": "Resumes a sound patch that was paused, returning it to playback with its stored m_pitch and m_volume. Read from the name and the class's m_isPlaying flag; what happens when the patch was never started, or has passed m_shutdownTime, is not established.", + "source": "generated" + }, + "CSoundPatch::Update": { + "text": "Services a live sound patch, advancing its m_pitch and m_volume envelopes and refreshing m_soundOrigin; its own message \"Removing CSoundPatch (%s) with NULL EHandle\" shows it discards a patch whose m_hEnt no longer resolves. The envelope work is read from the name and fields, the removal behaviour from that anchor.", + "source": "generated" + }, + "CSource2GameClients::Active": { + "text": "Handles a client becoming active on the server, the transition after which that player is a participating part of the running game. The class is implied by the name, since the entry sits in an unbound vtable slot, and the state it changes is unverified.", + "source": "generated" + }, + "CSource2GameClients::CheckConnect": { + "text": "Vets an incoming client's connection attempt so the game side can admit or refuse the player before they enter, typically the earliest place a mod can reject someone. The class is implied by the name; the slot is unbound here, so the rejection mechanism is unverified.", + "source": "generated" + }, + "CSource2GameClients::Command": { + "text": "Handles a console command a client sent to the server, the game-side reception point for client-issued commands and chat-style input. The class is implied by the name; the slot is unbound, so which commands reach it and how they are consumed are unverified.", + "source": "generated" + }, + "CSource2GameClients::Connected": { + "text": "Handles a client reaching the connected state on the server, before it is treated as fully joined. The class is implied by the name; the slot is unbound, so exactly what a client can do at this stage is unverified.", + "source": "generated" + }, + "CSource2GameClients::Disconnect": { + "text": "Handles a client leaving the server, the notification a mod uses to tear down that player's per-session state. The class is implied by the name; the slot is unbound, so the disconnect reason it receives and the cleanup it performs are unverified.", + "source": "generated" + }, + "CSource2GameClients::FullyConnected": { + "text": "Handles a client that has completed its join, past the earlier connection stages and ready for normal gameplay traffic. The class is implied by the name; the slot is unbound, so what \"fully\" additionally requires beyond CSource2GameClients::Connected is unverified.", + "source": "generated" + }, + "CSource2GameClients::PutInServer": { + "text": "Places a connected client into the running game world, the point at which the client is paired with its server-side player entity. The class is implied by the name; the slot is unbound, so entity creation and naming details are unverified.", + "source": "generated" + }, + "CSource2GameClients::SettingsChanged": { + "text": "Handles notification that a client's settings, its user-info values such as name or network preferences, have changed while connected. The class is implied by the name; the slot is unbound, so which settings raise it is unverified.", + "source": "generated" + }, + "CSource2GameClients::StartHLTVServer": { + "text": "Brings up the HLTV/SourceTV side of the server for the current session; its own message \"game event %s not found.\" shows it resolves a named game event during that startup and complains when the lookup fails. The startup role is read from the name, the event lookup from that anchor.", + "source": "generated" + }, + "CSource2GameEntities::CheckEntities": { + "text": "Sweeps the server's entities to validate them, reporting how many it looked at through its own \"CSource2GameEntities::CheckEntities: %d ents\" message. The sweep and the count come from that anchor; what a failed check does to the offending entity is not established.", + "source": "generated" + }, + "CSource2GameEntities::ShouldClientReceiveStringTableUserData": { + "text": "Decides whether a given string-table entry's user data is networked to a particular client, consulting game rules; its warning names the table and string index when GameRules() is null. The gating role is read from the name and that anchor, but the criteria it applies are unverified.", + "source": "generated" + }, + "CSource2Server::Connect": { + "text": "Brings up the server module's link to the engine's interface factories, with its \"ConnectTier1/2/3Libraries - Start\" message marking the tier library hookup during that bring-up. Read from the name and that anchor; which individual interfaces it acquires is not established here.", + "source": "generated" + }, + "CSource2Server::GameFrame": { + "text": "Runs one server-side game frame, the per-tick entry point where the game advances its simulation, and the usual place a mod hangs per-tick work. The class is implied by the name and the \"GameFrame\" anchor; the slot is unbound, so what it advances each tick is unverified.", + "source": "generated" + }, + "CSource2Server::GameServerSteamAPIActivated": { + "text": "Signals the game that the Steam game-server API is now available, the moment Steam-dependent server features can be brought online. The class is implied by the name; the slot is unbound, so what it sets up is unverified.", + "source": "generated" + }, + "CSource2Server::GameServerSteamAPIDeactivated": { + "text": "Signals the game that the Steam game-server API is no longer available, so Steam-dependent state should be dropped. The class is implied by the name; the slot is unbound, so the teardown it performs is unverified.", + "source": "generated" + }, + "CSource2Server::GetGameEventManager": { + "text": "Provides access to the server's game event manager, the object a mod goes through to fire and listen for game events. The class is implied by the name; the slot is unbound, so the identity of what it hands back is unverified.", + "source": "generated" + }, + "CSource2Server::GetLevelsFromSaveFile": { + "text": "Reads which levels a save file records, the lookup used when restoring a saved session rather than starting a map fresh. The class is implied by the name; the slot is unbound, so the save format it parses is unverified.", + "source": "generated" + }, + "CSource2Server::Init": { + "text": "Performs server-module startup, anchored on \"CEngineServiceRegistry::RegisterEngineServices()\", which places engine service registration inside this bring-up. The same code also ships under the name CSource2Server::g_GameEventManager, so treat the two entries as one function rather than two hook targets.", + "source": "generated" + }, + "CSource2Server::g_GameEventManager": { + "text": "Performs server-module startup, carrying the \"CEngineServiceRegistry::RegisterEngineServices()\" anchor for engine service registration; this name resolves to the same code as CSource2Server::Init. The g_GameEventManager label therefore does not mark a separate event-manager accessor, and should not be hooked as one.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::ActivateSpawnGroup": { + "text": "Activates a loaded spawn group so that chunk of the level becomes live, with its own \"CSpawnGroupMgrGameSystem::PerformActivateSpawnGroup(%s)\" message naming the group being activated. Read from the name and that anchor; the conditions a group must meet before activation are not established.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::CreateLoadingSpawnGroup": { + "text": "Creates a spawn group in its loading state, the handle the manager works with while a level chunk or sub-level is still streaming in. The class is implied by the name; the slot is unbound, so the loading parameters it takes are unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::CreateLoadingSpawnGroupForSaveFile": { + "text": "Creates a loading spawn group whose contents come from a save file, the restore-time counterpart to loading a level chunk fresh. The class is implied by the name; the slot is unbound, so how the save contents are located and applied is unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::ExecuteQueuedSpawnEntityCalls": { + "text": "Flushes entity-spawn requests that were queued instead of run immediately, reporting how many it handles via \"SV: CSpawnGroupMgrGameSystem::ExecuteQueuedSpawnEntityCalls(count=%d)\". The deferred-batch reading comes from the name and that count anchor; what causes a spawn call to be queued is not established.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::FrameBoundary": { + "text": "Marks a frame boundary for the spawn-group system, the point between frames where deferred spawn-group work is allowed to settle. The class is implied by the name; the slot is unbound, so what it settles at that boundary is unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::GetSpawnGroups": { + "text": "Provides access to the spawn groups the manager is tracking, the way to enumerate which level chunks are currently loaded. Also shipped under the bare name GetSpawnGroups; the reading comes from the name, so what the collection includes is unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::SaveGame": { + "text": "Drives a game save on the spawn-group side, its \"ET: SaveGame_Start at %u %s\" trace marking the beginning of the write with a timestamp and identifying names. Read from the name and that anchor; what state is actually serialized is not established.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::SpawnGroupActuallyShutdown": { + "text": "Carries out the real teardown of a spawn group once doing so is safe, logging whether the group was precached through \"SpawnGroupActuallyShutdown - Precached? %i\". The deferred-teardown reading comes from the name and that anchor; the conditions that make it safe are unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::SpawnGroupInit": { + "text": "Initializes a spawn group before its entities exist, emitting a \"SpawnGroupInit\" trace that names the group. Read from the name and that anchor; which of the group's state it sets up is not established here.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::SpawnGroupShutdown": { + "text": "Begins shutdown of a spawn group, reporting how many entities the group holds via \"SpawnGroupShutdown: entities(%d)\". Read from the name and that anchor; whether entity removal happens here or in CSpawnGroupMgrGameSystem::SpawnGroupActuallyShutdown is not established by this data.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::SpawnGroupSpawnEntities": { + "text": "Creates the entities belonging to a spawn group, turning a loaded level chunk's entity list into real entities in the world. The class is implied by the name; the slot is unbound, so which entities it instantiates and how they are filtered is unverified.", + "source": "generated" + }, + "CSplineConstraint::InputDisableLimit": { + "text": "Handles the `DisableLimit` entity-IO input on `CSplineConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSplineConstraint::InputEnableLimit": { + "text": "Handles the `EnableLimit` entity-IO input on `CSplineConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSplineConstraint::InputSetSplineEntity": { + "text": "Handles the `SetSplineEntity` entity-IO input on `CSplineConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSplineConstraint::InputSetTransitionTime": { + "text": "Handles the `SetTransitionTime` entity-IO input on `CSplineConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSplineConstraint::TransitionThink": { + "text": "Drives the periodic think that advances a spline constraint through its timed transition, working alongside m_flTransitionTime, m_StartTransitionTime and m_vTangentSpaceAnchorAtTransitionStart. Read from the name and those fields; no prototype is derived, so the interpolation rule and think cadence are unverified.", + "source": "generated" + }, + "CSplitScreenService::OnProfileStorageAvailable": { + "text": "Handles the notification that a user profile's storage has become readable, the point at which the split-screen service can pick up per-user settings. The vtable slot is unbound, so the owning class is implied by the name and the handling is a name-level reading.", + "source": "generated" + }, + "CSprite::InputHideSprite": { + "text": "Handles the `HideSprite` entity-IO input on `CSprite`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSprite::InputShowSprite": { + "text": "Handles the `ShowSprite` entity-IO input on `CSprite`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSprite::InputToggleSprite": { + "text": "Handles the `ToggleSprite` entity-IO input on `CSprite`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CStartTimeOutIssue::ExecuteCommand": { + "text": "Applies a passed timeout vote, built around the command string timeout_terrorist_start; carried in the function. Useful when hooking or blocking vote-triggered timeouts; the anchor establishes the command text, while the team selection and guard conditions are unverified.", + "source": "generated" + }, + "CStartTimeOutIssue::GetDisplayString": { + "text": "Supplies the localization token #SFUI_vote_start_timeout, the caption shown on the timeout vote prompt for the calling team. Use it when localizing or replacing timeout vote wording.", + "source": "generated" + }, + "CStartTimeOutIssue::GetOtherTeamDisplayString": { + "text": "Supplies the localization token #SFUI_otherteam_vote_timeout, the caption shown to the team that did not call the timeout. Pair it with CStartTimeOutIssue::GetDisplayString when you want both sides of a timeout vote relabelled consistently.", + "source": "generated" + }, + "CStdFilesystemFile::FS_GetSectorSize": { + "text": "Reports the storage sector size for a filesystem file, the alignment granularity a caller sizes reads and buffers against. The vtable slot is unbound, so the owning class is implied by the name and the value's origin is a name-level reading.", + "source": "generated" + }, + "CStdioFile::FS_fclose": { + "text": "Closes a stdio-backed file and releases the handle it wraps. The vtable slot is unbound, so the owning class is implied by the name; hook it if you need to know when a file the engine opened is finished with.", + "source": "generated" + }, + "CStdioFile::FS_ferror": { + "text": "Reports whether the stdio-backed file has an error condition set, the usual check after a read or write that came up short. The vtable slot is unbound, so the owning class is implied by the name.", + "source": "generated" + }, + "CStdioFile::FS_fflush": { + "text": "Flushes buffered output for a stdio-backed file so pending bytes reach storage. The vtable slot is unbound, so the owning class is implied by the name; reach for it when data must be on disk before anything else opens the file.", + "source": "generated" + }, + "CStdioFile::FS_fread": { + "text": "Reads file data into memory for the caller from a stdio-backed file. The vtable slot is unbound, so the owning class is implied by the name, and the buffering and short-read behaviour are a name-level reading.", + "source": "generated" + }, + "CStdioFile::FS_fseek": { + "text": "Moves the read/write position of a stdio-backed file to a requested offset. The vtable slot is unbound, so the owning class is implied by the name; it is the seek half of random access, with CStdioFile::FS_ftell reporting where you are.", + "source": "generated" + }, + "CStdioFile::FS_ftell": { + "text": "Reports the current read/write position within a stdio-backed file. The vtable slot is unbound, so the owning class is implied by the name; use it to record an offset you can later restore with CStdioFile::FS_fseek.", + "source": "generated" + }, + "CStdioFile::FS_fwrite": { + "text": "Writes caller data out to a stdio-backed file. The vtable slot is unbound, so the owning class is implied by the name; whether bytes land immediately or sit in the buffer until CStdioFile::FS_fflush is not established here.", + "source": "generated" + }, + "CStdioFile::FS_setbufsize": { + "text": "Sets the I/O buffer size used for a stdio-backed file, the dial for trading memory against the number of disk round-trips. The vtable slot is unbound, so the owning class is implied by the name.", + "source": "generated" + }, + "CStdioFile::FS_setmode": { + "text": "Sets the access mode on a stdio-backed file, the text-versus-binary style of switch stdio streams carry. The vtable slot is unbound, so the owning class is implied by the name, and the accepted mode values are not established here.", + "source": "generated" + }, + "CStdioFile::~CStdioFile": { + "text": "Destroys a stdio file object, tearing down the handle and buffers it owns. The vtable slot is unbound, so the owning class is implied by the name; it is the natural place to release anything you attached to the file object.", + "source": "generated" + }, + "CSteam3Client::RunFrame": { + "text": "Services the client-side Steam3 connection for one frame, pumping Steamworks state and pending callbacks. Read from the name; this lives in libengine2 and no prototype is derived, so what it pumps and how often are unverified.", + "source": "generated" + }, + "CSteamID::Render": { + "text": "Renders a SteamID into printable text, using the format string [A:%u:%u:%u] present in the function. Use it when logging or displaying account identifiers; the anchor establishes that textual form, while the remaining formatting rules are unverified.", + "source": "generated" + }, + "CSurrender::GetDisplayString": { + "text": "Supplies the localization token #SFUI_vote_surrender, the caption shown on the surrender vote prompt. Use it when localizing or overriding surrender-vote wording in a custom UI.", + "source": "generated" + }, + "CSwapTeams::ExecuteCommand": { + "text": "Applies a passed swap-teams vote, built around the command string mp_swapteams; carried in the function. Useful when hooking or suppressing vote-driven team swaps; the anchor establishes the command text, while the guard conditions around it are unverified.", + "source": "generated" + }, + "CSwapTeams::GetDisplayString": { + "text": "Supplies the localization token #SFUI_vote_swap_teams, the caption shown on the swap-teams vote prompt. Pair it with CSwapTeams::ExecuteCommand when you are customizing both how a swap vote reads and what it does.", + "source": "generated" + }, + "CTSQueue::PopItem": { + "text": "Takes the next item off a thread-safe queue for the consumer. Read from the name; no prototype is derived, so the emptiness signalling and contention behaviour are unverified.", + "source": "generated" + }, + "CTSQueue::PushItem": { + "text": "Adds an item to a thread-safe queue, the producer side that CTSQueue::PopItem drains. Read from the name; no prototype is derived, so the locking strategy and capacity behaviour are unverified.", + "source": "generated" + }, + "CTakeDamageInfo::CTakeDamageInfo": { + "text": "Constructs and initializes a damage-info record describing a single hit, populating fields such as m_hAttacker, m_hInflictor, m_flDamage and m_bitsDamageType. Also shipped as CTakeDamageInfo::Constructor; hook it when you want to inspect or rewrite damage parameters at the moment the record is built.", + "source": "generated" + }, + "CTakeDamageInfo::Constructor": { + "text": "Builds a damage-info record, filling in the attacker, inflictor and payload fields such as m_hAttacker, m_hInflictor, m_flDamage, m_iHitGroupId and m_bitsDamageType. This is the same function as CTakeDamageInfo::CTakeDamageInfo, so a hook on either name lands on one address.", + "source": "generated" + }, + "CTankTrainAI::InputTargetEntity": { + "text": "Handles the `TargetEntity` entity-IO input on `CTankTrainAI`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantBool": { + "text": "Handles the `VariantBool` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantColor": { + "text": "Handles the `VariantColor` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantFloat": { + "text": "Handles the `VariantFloat` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantInt": { + "text": "Handles the `VariantInt` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantString": { + "text": "Handles the `VariantString` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantVector": { + "text": "Handles the `VariantVector` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantVoid": { + "text": "Handles the `VariantVoid` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestScriptMgr::LoopCount": { + "text": "Reports the loop count for the test-script manager, the repeat counter a scripted test sequence runs against. The vtable slot is unbound, so the owning class is implied by the name and the counting semantics are a name-level reading.", + "source": "generated" + }, + "CTextureBasedAnimatable::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CTextureBasedAnimatable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTextureBasedAnimatable::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CTextureBasedAnimatable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTextureBasedAnimatable::InputStart": { + "text": "Handles the `Start` entity-IO input on `CTextureBasedAnimatable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTextureBasedAnimatable::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CTextureBasedAnimatable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTextureDictionary::BindTextureToFile": { + "text": "Associates a texture entry in the dictionary with a texture file asset, so that slot resolves to the file's image data. Read from the name, and the owning class is implied by the name rather than by the data, so the identifiers involved are unverified.", + "source": "generated" + }, + "CTextureDictionary::BindTextureToMaterial": { + "text": "Points a dictionary texture entry at an existing material instead of a standalone image file. Read from the name, with the class implied by the name and not established by the data.", + "source": "generated" + }, + "CTextureDictionary::BindTextureToTextureHandle": { + "text": "Binds a dictionary entry to an already-created texture handle, letting a slot reuse a texture the engine has in hand. This is a name-level reading; the class is implied by the name, so what the handle must refer to is unverified.", + "source": "generated" + }, + "CTextureDictionary::CreateTexture": { + "text": "Allocates a new texture entry in the dictionary, identified by an id used for later lookups and binds. Read from the name, with the owning class implied by the name rather than established by the data.", + "source": "generated" + }, + "CTextureDictionary::DestroyAllTextures": { + "text": "Destroys the texture entries the dictionary currently holds, clearing it in one operation rather than slot by slot. Read from the name; the class is implied by the name, so what is released alongside the entries is unverified.", + "source": "generated" + }, + "CTextureDictionary::DestroyTexture": { + "text": "Destroys one texture entry and frees its slot in the dictionary. Read from the name, with the class implied by the name rather than by the data.", + "source": "generated" + }, + "CTextureDictionary::EnsureTextureIsLoaded": { + "text": "Makes a dictionary texture resident, loading it on demand when it has not been brought in yet. Read from the name; the class is implied by the name, so the load path and whether it blocks are unverified.", + "source": "generated" + }, + "CTextureDictionary::FindTextureIdForTextureFile": { + "text": "Looks up the dictionary id already assigned to a given texture file, so callers can reuse an entry instead of creating a duplicate. Read from the name, with the class implied by the name and the matching rules unverified.", + "source": "generated" + }, + "CTextureDictionary::GetMaterialHandle": { + "text": "Retrieves the material handle backing a dictionary texture entry. Read from the name; the class is implied by the name rather than by the data.", + "source": "generated" + }, + "CTextureDictionary::GetMaterialSpecificRenderAttributes": { + "text": "Retrieves the render attributes belonging to the material behind a texture entry, the per-material knobs the renderer consults for that entry. Read from the name; the class is implied by the name, so the attribute set and its layout are unverified.", + "source": "generated" + }, + "CTextureDictionary::GetTexCoordOffsetAndScale": { + "text": "Reads the UV offset and scale recorded for a texture entry, the values that map a sub-region of an atlas page onto a full 0..1 coordinate range. Read from the name, with the class implied by the name and the coordinate convention unverified.", + "source": "generated" + }, + "CTextureDictionary::GetTextureHandle": { + "text": "Retrieves the underlying texture handle for a dictionary id, for code that needs the raw texture rather than the dictionary slot. Read from the name; the class is implied by the name and not established by the data.", + "source": "generated" + }, + "CTextureDictionary::GetTextureSize": { + "text": "Reports the pixel dimensions recorded for a dictionary texture entry. Read from the name, with the class implied by the name rather than by the data.", + "source": "generated" + }, + "CTextureDictionary::GetTextureTexCoords": { + "text": "Retrieves the texture-coordinate rectangle for a dictionary entry, the UV bounds used when that entry is drawn. Read from the name; the class is implied by the name, so the exact coordinate layout is unverified.", + "source": "generated" + }, + "CTextureDictionary::IsValidId": { + "text": "Tests whether a texture id refers to a live dictionary entry \u2014 the guard to apply before any get or bind on an id of uncertain provenance. Read from the name, with the class implied by the name rather than by the data.", + "source": "generated" + }, + "CTextureDictionary::ProcessDeferredResourceLoading": { + "text": "Services texture loads that were queued rather than performed immediately, draining the dictionary's deferred-load work. Read from the name; the class is implied by the name, and what triggers this work is unverified.", + "source": "generated" + }, + "CTextureDictionary::SetBatchingOptions": { + "text": "Configures how the dictionary batches texture work, the options controlling how operations are grouped. Read from the name; the class is implied by the name, so which operations the options govern is unverified.", + "source": "generated" + }, + "CTextureDictionary::SetSubTextureRGBA": { + "text": "Writes RGBA pixel data into a rectangular sub-region of an existing dictionary texture, allowing partial updates without recreating the texture. Read from the name, with the class implied by the name and the pixel format and region convention unverified.", + "source": "generated" + }, + "CTextureDictionary::SetTexCoordOffsetAndScale": { + "text": "Stores the UV offset and scale for a texture entry, changing which part of the source image that entry addresses. Read from the name; the class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CTextureDictionary::SetTextureRGBA": { + "text": "Replaces a dictionary texture's pixel contents with supplied RGBA data. Read from the name, with the class implied by the name and the expected pixel format unverified.", + "source": "generated" + }, + "CThreadPool::Start": { + "text": "Brings the thread pool up so queued jobs can be executed by its worker threads. Read from the name; the class is implied by the name, and the pool's sizing and thread configuration are unverified.", + "source": "generated" + }, + "CThreadRWLock::Unlock": { + "text": "Releases a hold on a reader/writer lock so other threads can acquire it, the paired release for code that took the lock. Read from the name and located in libengine2; whether it drops a read hold or a write hold is not established here.", + "source": "generated" + }, + "CTier2AppSystemDict::Init": { + "text": "Purpose is not established beyond generic initialization \u2014 the name says no more. The owning class is implied by the name, not by the data.", + "source": "generated" + }, + "CTier2AppSystemDict::LoadStartupManifestGroup": { + "text": "Loads the startup manifest group, the resource manifest naming assets to bring in during application bring-up. Read from the name; the class is implied by the name, so which manifest and which assets are unverified.", + "source": "generated" + }, + "CTier2Application::LoadStartupManifestGroup": { + "text": "Loads a tier-2 application's startup resource manifest group, pulling in the assets that manifest names. Read from the name, with the class implied by the name rather than established by the data.", + "source": "generated" + }, + "CTimerEntity::DrawDebugTextOverlays": { + "text": "Emits the timer entity's debug overlay text, including a \"Paused: %.2f sec remaining\" line reporting how much of the countdown is left while it sits paused. Handy when inspecting m_flRemainingTime and m_bPaused live with entity debug overlays turned on.", + "source": "generated" + }, + "CTimerEntity::InputAddToTimer": { + "text": "Handles the `AddToTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputFireTimer": { + "text": "Handles the `FireTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputPauseTimer": { + "text": "Handles the `PauseTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputRefireTime": { + "text": "Handles the `RefireTime` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputResetTimer": { + "text": "Handles the `ResetTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputSubtractFromTimer": { + "text": "Handles the `SubtractFromTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputUnpauseTimer": { + "text": "Handles the `UnpauseTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputSetExposureAdaptationSpeedDown": { + "text": "Handles the `SetExposureAdaptationSpeedDown` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputSetExposureAdaptationSpeedUp": { + "text": "Handles the `SetExposureAdaptationSpeedUp` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputSetMaxExposure": { + "text": "Handles the `SetMaxExposure` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputSetMinExposure": { + "text": "Handles the `SetMinExposure` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CToolGameSimulationAPI::LoadSavegame": { + "text": "Loads a savegame through the tool-facing game simulation API, reporting \"no such save file '%s'\" when the named file cannot be found. The anchor establishes the lookup is by file name; the surrounding tool workflow and save format are not established here.", + "source": "generated" + }, + "CTouchExpansionComponent::SetTouchEventsEnabled": { + "text": "Turns touch events on or off for an entity's touch-expansion component, gating callbacks from the expanded touch volume. Read from the name; no prototype is derived here, so the scope and timing of the toggle are unverified.", + "source": "generated" + }, + "CTouchExpansionComponent::SetUp": { + "text": "Initialises an entity's touch-expansion component, logging \"TouchExpansionComponent_SetUp (ent %s [%d])%s\" with the owning entity's name and index. The anchor establishes it operates per entity; what the expanded volume is derived from is not established here.", + "source": "generated" + }, + "CTraceAABB::GetVertByIndex": { + "text": "Returns one corner vertex of an axis-aligned bounding box selected by index, for code walking the box's corners during trace work. Read from the name, with the class implied by the name rather than by the data.", + "source": "generated" + }, + "CTraceAABB::Radius": { + "text": "Gives the box's radius, the bounding-sphere extent used to cheaply reject far-away candidates before an exact test. Read from the name; the class is implied by the name, so whether this is a half-diagonal or another measure is unverified.", + "source": "generated" + }, + "CTraceAABB::SupportMap": { + "text": "Computes the box's support point for a given direction, the support-mapping primitive that convex sweep and overlap tests are built on. Read from the name; the class is implied by the name, and the direction and output conventions are unverified.", + "source": "generated" + }, + "CTraceFilter::GetTraceType": { + "text": "Reports the trace type the filter declares \u2014 the category distinguishing, for example, world-only queries from ones that also consider entities. Read from the name; the class is implied by the name, so the enumeration's values are unverified.", + "source": "generated" + }, + "CTraceFilterNoNPCsOrPlayer::ShouldHitEntity": { + "text": "Decides whether a candidate entity counts as a hit for a filter that excludes NPCs and players, so traces pass through characters and report other geometry. Read from the name, with the class implied by the name and the exact exclusion predicate unverified.", + "source": "generated" + }, + "CTraceFilterNoPlayersAndFlashbangPassableAnims::ShouldHitEntity": { + "text": "Decides whether a candidate entity blocks a trace, rejecting players and animations marked flashbang-passable so the trace passes through them. The owning class is implied by the name, and the reading is name-level only, so the exact rejection conditions are unverified.", + "source": "generated" + }, + "CTriggerActiveWeaponDetect::ActiveWeaponThink": { + "text": "Periodic check of what weapon touching players currently hold, comparing against m_iszWeaponClassName and driving the m_OnTouchedActiveWeapon output. Useful when a map should react to a specific weapon being carried into a volume; read from the name and those fields, so the polling cadence is unverified.", + "source": "generated" + }, + "CTriggerBrush::EndTouch": { + "text": "Handles an entity leaving the brush trigger's volume, the point where the m_OnEndTouch output belongs. The class is implied by the name; behavior beyond leave-handling is read from the name and the class's touch outputs and is unverified.", + "source": "generated" + }, + "CTriggerBrush::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CTriggerBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerBrush::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CTriggerBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerBrush::StartTouch": { + "text": "Handles an entity entering the brush trigger's volume, where m_iInputFilter gating and the m_OnStartTouch output apply. The class is implied by the name; the filtering rules are read from the fields rather than verified.", + "source": "generated" + }, + "CTriggerBrush::~CTriggerBrush": { + "text": "Destructor that tears down a trigger_brush instance and releases its per-entity state. The class is implied by the name; no purpose beyond destruction is established.", + "source": "generated" + }, + "CTriggerBuoyancy::InputSetFluidDensity": { + "text": "Handles the `SetFluidDensity` entity-IO input on `CTriggerBuoyancy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerFan::PushThink": { + "text": "Recurring update that pushes entities inside the fan volume along m_vDirection at m_flForce, with separate m_flPlayerForce, m_flNPCForce, m_flRopeForceScale and m_flParticleForceScale scaling, optional m_bFalloff, and wander from m_fNoiseDegrees. Ramp-in and ramp-out use m_flRampTime with m_bRampDown; read from the name and fields, so the update rate is unverified.", + "source": "generated" + }, + "CTriggerGameEvent::InputSetEndTouchEvent": { + "text": "Handles the `SetEndTouchEvent` entity-IO input on `CTriggerGameEvent`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerGameEvent::InputSetStartTouchEvent": { + "text": "Handles the `SetStartTouchEvent` entity-IO input on `CTriggerGameEvent`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerGravity::GravityTouch": { + "text": "Applies the trigger's gravity override to an entity touching the volume, the mechanism behind trigger_gravity brushes. Read from the name; the class carries no schema fields here, so where the gravity value comes from is unverified.", + "source": "generated" + }, + "CTriggerHurt::CTriggerHurt": { + "text": "Constructor that brings a hurt trigger into its initial state, including damage bookkeeping such as m_flDamage, m_flDamageCap, m_flForgivenessDelay and m_hurtThinkPeriod. No purpose beyond construction is established.", + "source": "generated" + }, + "CTriggerHurt::GetDataDescMap": { + "text": "Supplies the entity's data description map, the table that binds keyvalues, inputs and saved fields for this trigger. The class is implied by the name; useful when reasoning about which m_flDamage-style fields are mapped for map authoring.", + "source": "generated" + }, + "CTriggerHurt::InputSetDamage": { + "text": "Handles the `SetDamage` entity-IO input on `CTriggerHurt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerImpact::DisableThink": { + "text": "Stops the impact trigger's periodic thinking, leaving it idle until it is fired again. Read from the name, so what state is cleared alongside the think is unverified.", + "source": "generated" + }, + "CTriggerImpact::DrawDebugTextOverlays": { + "text": "Emits developer overlay text for the impact trigger, including a \"Magnitude: %3.2f\" line reflecting m_flMagnitude. Handy with entity text overlays when tuning m_flMagnitude, m_flNoise and m_flViewkick in a map.", + "source": "generated" + }, + "CTriggerImpact::InputImpact": { + "text": "Handles the `Impact` entity-IO input on `CTriggerImpact`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerImpact::InputSetMagnitude": { + "text": "Handles the `SetMagnitude` entity-IO input on `CTriggerImpact`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerLerpObject::LerpThink": { + "text": "Advances the in-progress interpolation of attached objects toward m_hLerpTarget over m_flLerpDuration, the update behind m_OnLerpStarted and m_OnLerpFinished. The class is implied by the name; the per-tick math is read from the fields and unverified.", + "source": "generated" + }, + "CTriggerLook::DrawDebugTextOverlays": { + "text": "Emits developer overlay text for the look trigger, including a \"Time: %3.2f\" line reflecting the accumulated look timing. Pair it with m_flLookTime, m_flLookTimeTotal and m_flFieldOfView when debugging why a trigger_look is not firing.", + "source": "generated" + }, + "CTriggerLook::TimeoutThink": { + "text": "Handles expiry of the look trigger's m_flTimeoutDuration, the path that sets m_bTimeoutFired and drives the m_OnTimeout output. Read from the name and those fields, so the exact expiry test is unverified.", + "source": "generated" + }, + "CTriggerMultiple::ActivateMultiTrigger": { + "text": "Fires the trigger's m_OnTrigger output for an activating entity and puts the trigger into its post-fire wait state. Read from the name and that output; the wait handling is unverified.", + "source": "generated" + }, + "CTriggerMultiple::CTriggerMultiple": { + "text": "Constructor that initializes a trigger_multiple instance, including its m_OnTrigger output storage. No purpose beyond construction is established.", + "source": "generated" + }, + "CTriggerPhysics::InputSetLinearForcePointAt": { + "text": "Handles the `SetLinearForcePointAt` entity-IO input on `CTriggerPhysics`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerProximity::MeasureThink": { + "text": "Periodically measures how close entities are to m_hMeasureTarget within m_fRadius, updating m_nTouchers and the m_NearestEntityDistance value a map can read. Read from the name and fields, so the sampling interval is unverified.", + "source": "generated" + }, + "CTriggerPush::InputSetPushDirection": { + "text": "Handles the `SetPushDirection` entity-IO input on `CTriggerPush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerPush::InputSetPushSpeed": { + "text": "Handles the `SetPushSpeed` entity-IO input on `CTriggerPush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerSave::RetriggerWaitOver": { + "text": "Ends the save trigger's m_flRetriggerDelay cooldown so the volume is eligible to save again. Read from the name and that field; the rearm details are unverified.", + "source": "generated" + }, + "CTriggerSave::Touch": { + "text": "Handles an entity touching the save volume and applies the save conditions m_minHitPoints, m_fDangerousTimer and m_bForceNewLevelUnit. The class is implied by the name; the acceptance test is read from those fields rather than verified.", + "source": "generated" + }, + "CTriggerSndSosOpvar::SndSosTriggerOpvarWaitOver": { + "text": "Completes the delayed sound-operator-stack opvar update for the volume, working with m_opvarName, m_stackName and m_operatorName plus the m_flMinVal to m_flMaxVal range. Read from the name and fields, so the delay length and write timing are unverified.", + "source": "generated" + }, + "CTriggerSoundscape::PlayerUpdateThink": { + "text": "Periodic pass that keeps track of which players inside the volume should have m_hSoundscape and m_SoundscapeName applied, with m_spectators held separately. Read from the name and fields, so the update rate and hand-off rules are unverified.", + "source": "generated" + }, + "CTriggerTeleport::GetDataDescMap": { + "text": "Supplies the teleport trigger's data description map, binding its keyvalues and inputs such as m_iLandmark and m_bUseLandmarkAngles. The class is implied by the name.", + "source": "generated" + }, + "CTriggerTeleport::Touch": { + "text": "Teleports a touching entity to the trigger's destination and logs \"Trigger %s is teleporting %s from ( %f %f %f ) to ( %f %f %f )\" when developer output is on. Placement respects m_iLandmark, m_bUseLandmarkAngles, m_bMirrorPlayer and the m_bCheckDestIfClearForPlayer clearance test.", + "source": "generated" + }, + "CUnpauseMatchIssue::ExecuteCommand": { + "text": "Carries out a passed unpause vote by running the \"mp_unpause_match;\" console command. Relevant when hooking or replacing the vote system's unpause path in a server plugin.", + "source": "generated" + }, + "CUnpauseMatchIssue::GetVotePassedString": { + "text": "Supplies the localization token \"#SFUI_vote_passed_unpause_match\" that clients display once the unpause vote succeeds. Override it to reword the passed-vote banner for an unpause vote.", + "source": "generated" + }, + "CUtlLeanVector::AddMultipleToTail": { + "text": "Appends several elements at once to the end of a lean vector, expanding its storage to fit them. Read from the name; the growth policy is unverified.", + "source": "generated" + }, + "CUtlLeanVector::GrowCount": { + "text": "Expands a lean vector's allocated element capacity when the current buffer is too small. Read from the name, so the growth factor and allocator used are unverified.", + "source": "generated" + }, + "CUtlLeanVector::InsertBeforeGetPtr": { + "text": "Opens a gap for a new element before a given position in a lean vector and exposes that slot for the caller to fill in place. Read from the name; the shifting and reallocation behavior is unverified.", + "source": "generated" + }, + "CUtlLeanVectorBase::InsertBeforeGetPtr": { + "text": "Base-layer insertion that makes room before a given position in the lean vector's storage and exposes the raw slot for in-place construction. Read from the name, so the storage layout it manipulates is unverified.", + "source": "generated" + }, + "CUtlLinkedList::GrowCount": { + "text": "Expands the linked list's backing element pool so more nodes can be linked in. Read from the name; the growth policy is unverified.", + "source": "generated" + }, + "CUtlMemoryPool::AddPage": { + "text": "Allocates a fresh page of memory and attaches it to the pool's page list, expanding the blocks available for handing out. Read from the name, so the page size and linkage are unverified.", + "source": "generated" + }, + "CUtlMemoryPool::Alloc": { + "text": "Hands out one fixed-size block from the pool's existing pages, expanding the pool when nothing is free. Read from the name; the free-list mechanics and out-of-memory behavior are unverified.", + "source": "generated" + }, + "CUtlMemoryPool::EnsureCapacity": { + "text": "Pre-grows the pool so it can serve a requested number of blocks without allocating later. Useful to avoid mid-frame allocation spikes; read from the name, so the rounding to whole pages is unverified.", + "source": "generated" + }, + "CUtlStackMachineBuilder::FinishCompile": { + "text": "Closes out a stack-machine program being assembled, finalizing the emitted instruction stream into a runnable form. The class is implied by the name; the finalization steps are read from the name and unverified.", + "source": "generated" + }, + "CUtlVector::AddMultipleToTail": { + "text": "Appends a run of elements to the end of a CUtlVector, growing the backing buffer as needed. Read from the name; no prototype is derived, so the growth and element-construction behaviour is unverified.", + "source": "generated" + }, + "CUtlVector::EnsureCapacity": { + "text": "Reserves backing storage so a CUtlVector can hold at least a requested element count without reallocating on later adds. Read from the name; the allocation policy and whether it can shrink are unverified.", + "source": "generated" + }, + "CUtlVector::InsertMultipleBefore": { + "text": "Inserts a run of elements into a CUtlVector immediately before a given index, shifting the existing tail up. Read from the name; the index semantics and how the new slots are initialised are unverified.", + "source": "generated" + }, + "CUtlVector::RemoveMultiple": { + "text": "Removes a contiguous run of elements from a CUtlVector and compacts what remains. Read from the name; whether element destructors run and whether ordering is preserved are unverified.", + "source": "generated" + }, + "CUtlVectorBase::EnsureCapacity": { + "text": "Reserves backing storage on the shared CUtlVectorBase implementation so a vector can hold a requested element count. Read from the name; the growth policy is unverified.", + "source": "generated" + }, + "CVDataTypeManager::LoadKV3Object": { + "text": "Loads an object from KV3 keyvalues data through the VData type manager, turning serialised data into a typed runtime object. Read from the name; useful when tracing how vdata assets become in-memory structures, though the parsing and type-resolution details are unverified.", + "source": "generated" + }, + "CVPhys2World::GenerateIntersectionNotifications": { + "text": "Produces the intersection and touch notifications for the physics world, the events that tell game code which bodies started or stopped overlapping. The class is implied by the name, not by the data, and the notification contents and conditions are unverified.", + "source": "generated" + }, + "CVPhys2World::GetTouchingList": { + "text": "Retrieves the set of physics bodies currently in contact with a given object in the Phys2 world. The class is implied by the name; a prototype is derived, but the returned list's contents and lifetime are unverified.", + "source": "generated" + }, + "CVProfService::OnFrameBoundary": { + "text": "Advances the VProf profiling service across a frame boundary, rolling accumulated per-frame timing into a new frame. Read from the name; the bookkeeping it performs and what it does when profiling is off are unverified.", + "source": "generated" + }, + "CVProfile::CVProfile": { + "text": "Constructs the VProf profiler object and brings its initial state up. Read from the name as a constructor; what it initialises is not established by this data.", + "source": "generated" + }, + "CVScriptGameSystem::ScriptDebugDraw": { + "text": "Emits debug drawing on behalf of the VScript game system, rendering script-requested overlays or geometry. The class is implied by the name; what is drawn, and what script call or convar enables it, is unverified.", + "source": "generated" + }, + "CVScriptGameSystem::ScriptDebugDumpKeys": { + "text": "Dumps script key state for debugging, carrying the anchor string ScriptDebugDumpKeys. Beyond that anchor and the name, the contents of the dump and how it is triggered are unverified.", + "source": "generated" + }, + "CVisibilityMonitor::AddEntity": { + "text": "Registers an entity with the visibility monitor, logging the line VisMon: Added Entity: %s (%s) with the entity's identifying strings. Useful when working out which entities the visibility system is tracking; the criteria for tracking are unverified.", + "source": "generated" + }, + "CVoiceGameMgr::ClientCommand": { + "text": "Handles voice-related client commands on the server, including VModEnable, whose handling logs CVoiceGameMgr::ClientCommand: VModEnable (%d). Relevant when changing voice enable or mute behaviour; other commands it accepts are not established by this data.", + "source": "generated" + }, + "CVoxelVisibilityTypeManager::AllocateResource": { + "text": "Allocates a voxel-visibility resource instance for the engine resource system, creating the runtime object that backs a loaded visibility asset. The class is implied by the name; the resource layout and where its data comes from are unverified.", + "source": "generated" + }, + "CWaterBullet::BulletThink": { + "text": "Runs the periodic think for a water-bullet entity, advancing its behaviour each think interval. Read from the name; the movement, lifetime and any damage or effect handling are unverified.", + "source": "generated" + }, + "CWaterBullet::GetDataDescMap": { + "text": "Returns the datadesc map for the water-bullet entity, the description the entity system uses for its saved and keyvalue-settable data. The class is implied by the name, and which fields the map covers is unverified.", + "source": "generated" + }, + "CWeaponElite::PrimaryAttack": { + "text": "Performs the primary-fire attack for the Elite weapon, doing the per-shot work when the trigger is pulled. The class is implied by the name; ammo handling, recoil and firing cadence are unverified.", + "source": "generated" + }, + "CWorkThreadPool::StartWorkThread": { + "text": "Starts a worker thread in the pool, logging CWorkThreadPool::StartWorkThread: Thread creation failed. when the underlying thread cannot be created. Useful when diagnosing server thread-pool startup problems; how many threads are started and how work reaches them are unverified.", + "source": "generated" + }, + "CWorkThreadPool::StopWorkThreads": { + "text": "Shuts the pool's worker threads down, warning that a thread failed to shut down and printing its name and id via the anchor Thread \"%s\" (ID %llu) failed to shut down. Relevant when chasing hangs at shutdown; the wait behaviour and any timeout are unverified.", + "source": "generated" + }, + "CWorldCompositionReference::ComputeWorldOrigin": { + "text": "Computes the world-space origin for a world-composition reference, resolving where the referenced sub-world sits. Carries the anchor string ComputeWorldOrigin; the inputs to that computation are unverified.", + "source": "generated" + }, + "CWorldRendererMgr::CreateWorld": { + "text": "Creates a world instance in the world renderer manager, producing the runtime world object for a map or world resource. The class is implied by the name; what identifies the world being created is unverified.", + "source": "generated" + }, + "CWorldRendererMgr::LockForRead": { + "text": "Takes a read lock over world-renderer data so it can be inspected safely while other threads may touch it. The class is implied by the name; the lock's scope and its matching release are unverified.", + "source": "generated" + }, + "C_BaseEntity::HitboxToWorldTransforms": { + "text": "Produces world-space transforms for an entity's hitboxes, converting model-space hitbox placement into world coordinates. Read from the name; this is the client-side entity variant, and the hitbox source and any bone-setup prerequisite are unverified.", + "source": "generated" + }, + "CalcBlocks_IntercellConnections": { + "text": "Computes the connections between cells during a block-based build, logging progress as completed count over total. The name and that progress string are the evidence; what a cell and a block represent here is not established.", + "source": "generated" + }, + "CalcBlocks_IntracellConnections": { + "text": "Computes the connections inside individual cells during a block-based build, logging progress along with a v1 tag marking the algorithm revision. Named as the intracell counterpart to CalcBlocks_IntercellConnections; this remains a name-and-log reading, so the structures involved are unverified.", + "source": "generated" + }, + "CanCharacterSeeEntity": { + "text": "Answers whether a character can see a given entity, a line-of-sight query of the kind AI and bot decisions lean on. The name and its verbatim anchor support this; whether it traces geometry, tests a view cone, or both, is not established.", + "source": "generated" + }, + "CanMove": { + "text": "Answers whether its subject is currently permitted to move, the gate that freeze time, stuns, or scripted holds would consult. Read from the name; which conditions it weighs, and what kind of subject it applies to, are not established.", + "source": "generated" + }, + "CanUnduck": { + "text": "Tests whether a crouched player has clearance to stand back up, so an unduck can be refused when the space above is blocked. Read from the name; also shipped as CCSPlayer_MovementServices::CanUnduck, and the place to change stand-up clearance rules.", + "source": "generated" + }, + "CategorizePosition": { + "text": "Determines the player's ground state for the movement pass, deciding whether they are standing on something, airborne, or on a surface too steep to hold. Read from the name and Source-movement lineage; also shipped as CCSPlayer_MovementServices::CategorizePosition.", + "source": "generated" + }, + "ChangeTeam": { + "text": "Moves a player to a different team, its debug line recording the player's identity, the current and requested team numbers, and whether the switch will actually happen. That anchor makes the role clear; the limits it enforces, such as team balance or timing, are not established.", + "source": "generated" + }, + "CheckFalling": { + "text": "Handles the end of a fall, covering landing damage and the landing sound or effect; its string anchor Land_WaterVol.StepLeft is a surface-sound token consistent with that. Also shipped as CCSPlayer_MovementServices::CheckFalling, so hook here to alter fall damage.", + "source": "generated" + }, + "CheckJumpButton": { + "text": "Tests the jump input and decides whether the player leaves the ground, read from the name. This name resolves to the same code as CCSPlayer_MovementServices::CheckJumpButtonLegacy, so treat it as the legacy jump-input path; the match is medium confidence.", + "source": "generated" + }, + "CheckJumpButtonLegacy": { + "text": "Handles jump input under the legacy jump model, deciding whether a press produces a jump. Also shipped as CCSPlayer_MovementServices::CheckJumpButtonLegacy; it pairs with the CCSPlayerLegacyJump data this batch's fields reference, which is where the old jump feel is tuned.", + "source": "generated" + }, + "CheckJumpButtonModern": { + "text": "Handles jump input under the modern jump model, deciding whether a press produces a jump. Also shipped as CCSPlayer_MovementServices::CheckJumpButtonModern; it pairs with the CCSPlayerModernJump data this batch's fields reference, so use it when targeting current jump behaviour rather than the legacy path.", + "source": "generated" + }, + "CheckJumpButtonWater": { + "text": "Handles the jump input while a player is in water, the swim-up or exit-water branch of jump handling. Read from the name; the water-level conditions it requires and the movement state it changes are not established.", + "source": "generated" + }, + "CheckTransmit": { + "text": "Decides which entities are sent to a client in a network update, the standard place to hide entities from a player or force them visible. The name plus a ./gameinterface.cpp:3135 anchor support this; the filtering rules and per-client state involved are unverified.", + "source": "generated" + }, + "CheckVelocity": { + "text": "Clamps player velocity to the legal maximum, emitting the warning string \"Got a velocity too high (>%.2f) on %s\" when a component runs past it. Also shipped as CCSPlayer_MovementServices::CheckVelocity, and the first thing to check when a speed-boost mod is silently capped.", + "source": "generated" + }, + "CheckWater": { + "text": "Determines an entity's relationship to water, whether it is in water and how deeply, the state that swimming, drowning, and splash behaviour key off. Read from the name; what it records and which water volumes it consults are not established.", + "source": "generated" + }, + "ChildPanelsVectorOffset": { + "text": "Supplies where a panel's child-panel vector sits inside the object, the kind of accessor used to reach a UI panel's children from outside. Read from the name; which panel type it applies to and how the offset is obtained are not established.", + "source": "generated" + }, + "ClientJob_EMsgGCCStrike15_v2_GC2ServerReservationUpdate::BYieldingRunJobFromMsg": { + "text": "Handles a Game Coordinator reservation-update message sent to the server, applying the revised match reservation. The class is implied by the name; the message fields it reads and the state it changes are unverified.", + "source": "generated" + }, + "ClientJob_EMsgGCCStrike15_v2_MatchEndRewardDropsNotification::BYieldingRunJobFromMsg": { + "text": "Handles the Game Coordinator's match-end reward-drop notification, logging Notification about user drop: %u %llu (%u-%u-%u) for the user and drop involved. Useful when tracing end-of-match item drops on a server; what else it does with the notification is unverified.", + "source": "generated" + }, + "ClientJob_EMsgGCCStrike15_v2_ServerNotificationForUserPenalty::BYieldingRunJobFromMsg": { + "text": "Handles the Game Coordinator's user-penalty notification, logging Notification about user penalty: %u/%u (%u sec) with the penalty identifiers and a duration in seconds. Relevant when tracing cooldowns reaching a server; the action taken on the penalised user is unverified.", + "source": "generated" + }, + "ClientPrint": { + "text": "Prints a text message to a player's client, the standard server-side way to push chat, console, hint, or centre-screen text to someone. Read from the name; which display targets it supports and how the text is formatted are not established.", + "source": "generated" + }, + "ClipPolysToHullClearanceInternal": { + "text": "Clips polygons down to the clearance a movement hull requires, iterating and warning when successive passes stop reducing the geometry. That warning string is the direct evidence; the geometry it operates on and the hull it clears for are not established.", + "source": "generated" + }, + "ClipPolysToHullClearanceInternalProcessList": { + "text": "Part of navmesh generation: clips a list of candidate polygons against hull-clearance limits, trimming areas too tight for a player hull and logging how many were clipped under a NAVGEN tag. The clipping role comes from the anchor and name; the clearance inputs it reads are unverified.", + "source": "generated" + }, + "Cmd_ExecuteCommand": { + "text": "Executes a console command inside the engine's command system, the point where a typed or scripted command actually takes effect. Read from the name; the command representation and the execution context are unverified.", + "source": "generated" + }, + "CommandMapGroup": { + "text": "Handles the mapgroup console command, selecting the map group that drives map rotation and reporting 'No mapgroup specified' when the argument is missing. Useful when changing map cycling from server code; the accepted argument forms are not established here.", + "source": "generated" + }, + "ComputeMaterialBatchableFlags": { + "text": "Computes the flags describing how a material can be batched with others for drawing, so compatible materials can share work at render time. Read from the name in the material system; the flag values and the material properties inspected are unverified.", + "source": "generated" + }, + "ConCommand::Test_CreateEntity": { + "text": "Callback bound to the `Test_CreateEntity` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::Test_EHandle": { + "text": "Callback bound to the `Test_EHandle` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::Test_RandomPlayerPosition": { + "text": "Callback bound to the `Test_RandomPlayerPosition` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::autosavedangerousissafe": { + "text": "Callback bound to the `autosavedangerousissafe` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::bot_hurt": { + "text": "Callback bound to the `bot_hurt` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::clear_bombs": { + "text": "Callback bound to the `clear_bombs` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::commentary_cvarsnotchanging": { + "text": "Callback bound to the `commentary_cvarsnotchanging` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::commentary_finishnode": { + "text": "Callback bound to the `commentary_finishnode` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::creditsdone": { + "text": "Callback bound to the `creditsdone` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dm_reset_spawns": { + "text": "Callback bound to the `dm_reset_spawns` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::firetarget": { + "text": "Callback bound to the `firetarget` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::func_mover_count": { + "text": "Callback bound to the `func_mover_count` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::func_mover_enable_debug_all": { + "text": "Callback bound to the `func_mover_enable_debug_all` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::ik_debug_fabrik_backwards_iteration_toggle": { + "text": "Callback bound to the `ik_debug_fabrik_backwards_iteration_toggle` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::ik_debug_fabrik_forwards_iteration_toggle": { + "text": "Callback bound to the `ik_debug_fabrik_forwards_iteration_toggle` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::lightbinner_precompute": { + "text": "Callback bound to the `lightbinner_precompute` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::lightbinner_test_computespheresilhouette": { + "text": "Callback bound to the `lightbinner_test_computespheresilhouette` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::lightbinner_test_computesumsilhouette": { + "text": "Callback bound to the `lightbinner_test_computesumsilhouette` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::lua_report_memory": { + "text": "Callback bound to the `lua_report_memory` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::mem_test": { + "text": "Callback bound to the `mem_test` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::nav_test_level_hull_move": { + "text": "Callback bound to the `nav_test_level_hull_move` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::progress_enable": { + "text": "Callback bound to the `progress_enable` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::replant_bomb": { + "text": "Callback bound to the `replant_bomb` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::retake_barrier_clear": { + "text": "Callback bound to the `retake_barrier_clear` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::retake_barrier_point": { + "text": "Callback bound to the `retake_barrier_point` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::retake_barrier_spawn": { + "text": "Callback bound to the `retake_barrier_spawn` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::save_clear_subdirectory": { + "text": "Callback bound to the `save_clear_subdirectory` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::save_finish_async": { + "text": "Callback bound to the `save_finish_async` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::save_set_subdirectory": { + "text": "Callback bound to the `save_set_subdirectory` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::send_round_backup_file_list": { + "text": "Callback bound to the `send_round_backup_file_list` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::shatterglass_break": { + "text": "Callback bound to the `shatterglass_break` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::shatterglass_restore": { + "text": "Callback bound to the `shatterglass_restore` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::sndplaydelay": { + "text": "Callback bound to the `sndplaydelay` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::spawnCashStack": { + "text": "Callback bound to the `spawnCashStack` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::splitscreen_testreadconfigconflict": { + "text": "Callback bound to the `splitscreen_testreadconfigconflict` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::stopsound": { + "text": "Callback bound to the `stopsound` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::timeout_ct_start": { + "text": "Callback bound to the `timeout_ct_start` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::timeout_terrorist_start": { + "text": "Callback bound to the `timeout_terrorist_start` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConfirmAllMessageHandlersInstalled": { + "text": "Checks that the network system's expected message handlers have been registered, a sanity check that catches a message type left without a handler. Read from the name; whether it asserts, logs, or reports a status is unverified.", + "source": "generated" + }, + "ConnectGameInterfaces": { + "text": "Connects the game module to the engine's app-system interfaces, reporting its registration count under an APPSYSTEM log line. This is where a server module's engine interface pointers become available; the interface list involved is not established here.", + "source": "generated" + }, + "ConvertToCopiedData": { + "text": "Converts a held value into an owned, copied representation, rejecting types it does not support and logging the offending type id. Relevant when data must outlive the buffer it came from; which types qualify is not established here.", + "source": "generated" + }, + "CreateBot": { + "text": "Creates a bot player, allocating a fake client and failing with 'Unable to create bot' when that allocation returns null. This is the server-side entry point for adding bots; the parameters choosing name, team or difficulty are unverified.", + "source": "generated" + }, + "CreateControllerToGraphBindings": { + "text": "Establishes the bindings between an animation controller and its animation graph, wiring controller-side parameters to graph inputs. Read from the name; the binding representation and the conditions under which it is rebuilt are unverified.", + "source": "generated" + }, + "CreateEntityByName": { + "text": "Creates an entity instance from a classname string, the usual entry point for spawning entities from mod code. The prototype is verified, and it also ships as CBaseEntity::CreateEntityByName, CGameEntitySystem::CreateEntityByName and UTIL::CreateEntityByName.", + "source": "generated" + }, + "CreateForFileRead": { + "text": "Creates a resource-system object configured for reading a file, the read-side form of opening resource data. Read from the name; the object it produces and how the file is identified are unverified.", + "source": "generated" + }, + "CreatePhysicsBallSocketConstraint": { + "text": "Creates a ball-and-socket physics constraint, pinning two simulated bodies at a shared point while leaving rotation free \u2014 the joint style used for ragdolls and swinging props. Read from the name; the bodies and anchor point are unverified.", + "source": "generated" + }, + "CreatePhysicsConstraint": { + "text": "Creates a physics constraint linking simulated bodies, in a generic form rather than one tied to a single joint type. Read from the name; which constraint kinds it accepts and how they are described are unverified.", + "source": "generated" + }, + "CreatePhysicsHingeConstraint": { + "text": "Creates a hinge physics constraint, letting two simulated bodies rotate about one shared axis as doors and levers do. Read from the name; the axis definition and any angular limits are unverified.", + "source": "generated" + }, + "CreatePhysicsProxy": { + "text": "Creates the physics-side proxy for an entity, giving it a body that the simulation can move and collide. Read from the name; what the proxy holds and which entities require one are unverified.", + "source": "generated" + }, + "DataDesc_BuildComponentUnserializers": { + "text": "Builds the unserializer table for a component's datadesc, preparing the per-field readers that turn stored keyvalues into live entity data. Read from the name; the table layout and when it is constructed are unverified.", + "source": "generated" + }, + "DataDesc_UnserializeKey": { + "text": "Unserializes a single datadesc key, converting one stored keyvalue into the typed entity field it names \u2014 the layer that gives map-authored keyvalues effect. Read from the name; the field lookup and type-conversion rules are unverified.", + "source": "generated" + }, + "DebugDrawMesh": { + "text": "Draws a mesh as debug geometry so its triangles or wireframe can be inspected in-world during development. Read from the name; the mesh source, color and how long the drawing persists are unverified.", + "source": "generated" + }, + "DecalTrace": { + "text": "Applies a decal at the impact point described by a trace result, the mechanism behind bullet holes and scorch marks on surfaces. Read from the name; how the decal material is selected is unverified.", + "source": "generated" + }, + "DefuseBombState::GetName": { + "text": "Returns the name of the bomb-defusal behaviour state, with the anchor string DefuseBomb supplying that name. Useful for recognising the state in behaviour debug output.", + "source": "generated" + }, + "DefuseBombState::OnEnter": { + "text": "Runs the entry work for the bomb-defusal behaviour state, preparing the actor to start defusing. The class is implied by the name; what it initialises and what it assumes is already true are unverified.", + "source": "generated" + }, + "DefuseBombState::OnExit": { + "text": "Runs the exit work for the bomb-defusal behaviour state, cleaning up whatever the state held while active. The class is implied by the name; what it tears down is unverified.", + "source": "generated" + }, + "DefuseBombState::OnUpdate": { + "text": "Drives the per-update behaviour of the bomb-defusal state, complaining In Defuse state, but don't know where the bomb is! when the bomb's location is unknown. Useful when debugging bots that sit in the defuse state without acting; the rest of the update logic is unverified.", + "source": "generated" + }, + "DeleteSceneObjectFunctionPointer": { + "text": "Destroys a scene object, the renderable representation the scene system holds for an entity. The name marks it as a function-pointer slot for that deletion; the object's ownership and what its removal invalidates are unverified.", + "source": "generated" + }, + "DetermineFieldSerializerGroup": { + "text": "Chooses which field-serializer group a networked field belongs to, part of how the network system organizes per-class field encoding. Read from the name; the grouping criteria and their effect on the wire format are unverified.", + "source": "generated" + }, + "DispatchDatamapFunction": { + "text": "Invokes a function declared in an entity's datamap, such as an input handler or a named think function. Read from the name; how the target function is identified within the datamap is unverified.", + "source": "generated" + }, + "DispatchParticleEffect": { + "text": "Spawns a particle effect in the world, with the alias name UTIL_DispatchParticleEffectFilter_Attachment indicating a form that targets an attachment point on an entity and limits which clients receive it. Use it to play a particle system from server code; the attachment and filter parameters are unverified.", + "source": "generated" + }, + "DoEntFireByInstanceHandle": { + "text": "Fires an entity input on one specific entity identified by its instance handle rather than by targetname, letting server code trigger entity I/O directly. Read from the name; the input naming, value and delay handling are unverified.", + "source": "generated" + }, + "DoSpark": { + "text": "Produces a spark effect, the short burst used for damaged or electrical props. Read from the name only; the placement, spark count and any accompanying sound are unverified.", + "source": "generated" + }, + "EmitSound": { + "text": "Plays a sound from an entity, with the CBaseEntity::EmitSoundFilter alias pointing at a recipient-filtered emit so a chosen set of players hears it. Read from the names; no prototype is derived, so the sound-identifier form and the filtering rules are unverified.", + "source": "generated" + }, + "EmitSoundVolume": { + "text": "Plays or adjusts a sound with an explicitly given volume, the volume-carrying form of sound emission. Read from the name; whether it starts a new sound or changes the volume of one already playing is not established.", + "source": "generated" + }, + "EndRestoreEntities": { + "text": "Closes out an entity restore pass, finishing the reload of saved entity state and logging the context it completed under. Relevant around save/load and level transitions; the context values in the log line are unverified.", + "source": "generated" + }, + "EnsureInstanceBaseline": { + "text": "Ensures a networking instance baseline exists for a class \u2014 the reference state that clients delta against when an entity first appears to them. Read from the name in engine networking code; when it creates versus reuses a baseline is unverified.", + "source": "generated" + }, + "EntityListOffset": { + "text": "Yields the offset at which the entity list sits inside its containing structure, the kind of accessor used to reach that list from a base pointer. Read from the name; the structure it offsets into is unverified.", + "source": "generated" + }, + "EntitySystemPointer": { + "text": "Yields the pointer to the entity system, the object through which entities are looked up, created and destroyed. Read from the name; how the pointer is obtained and its lifetime are unverified.", + "source": "generated" + }, + "EscapeFromBombState::GetName": { + "text": "Reports the bot state's name string, with the literal `EscapeFromBomb` shipped as its anchor, so that is the label this state identifies itself by. Useful for matching bot debug output or state dumps to the escape-from-bomb behaviour.", + "source": "generated" + }, + "EscapeFromBombState::OnEnter": { + "text": "Performs the entry setup a bot runs when it switches into the escape-from-bomb behaviour. The EscapeFromBombState class is implied by the name rather than established by the data, and what the entry hook initialises is unverified.", + "source": "generated" + }, + "EscapeFromBombState::OnExit": { + "text": "Performs the teardown a bot runs when it leaves the escape-from-bomb behaviour, the counterpart to that state's entry work. The EscapeFromBombState class is implied by the name, and the cleanup it does is not established here.", + "source": "generated" + }, + "EscapeFromBombState::OnUpdate": { + "text": "Runs the recurring update logic that keeps a bot moving away from the bomb while the escape-from-bomb behaviour is active. The EscapeFromBombState class is implied by the name, and the movement or timing it drives is unverified.", + "source": "generated" + }, + "EscapeFromFlamesState::GetName": { + "text": "Reports this state's name string, with the literal `EscapeFromFlames` shipped as its anchor. That label identifies the fire-avoidance behaviour in bot debug output and state traces.", + "source": "generated" + }, + "EscapeFromFlamesState::OnEnter": { + "text": "Sets up the behaviour in which a bot flees fire, doing the entry work for the escape-from-flames state. The EscapeFromFlamesState class is implied by the name, and the escape route or destination it chooses is unverified.", + "source": "generated" + }, + "ExecGameTypeCfg": { + "text": "Executes the config file tied to the current game type and mode, applying that mode's convar settings. Worth knowing when a mod's convars get overwritten at mode setup; the file naming scheme is read from the name and unverified.", + "source": "generated" + }, + "ExplosionEffect": { + "text": "Produces an explosion effect at a location \u2014 the visual and audible burst, separate from any damage that accompanies it. Read from the name; the magnitude, radius and appearance parameters are unverified.", + "source": "generated" + }, + "FX_FireBullets": { + "text": "Drives the effects side of firing a shot \u2014 tracers, muzzle flash and surface impacts \u2014 looking up the weapon's item definition and bailing out with 'GetItemDefinition failed' when that lookup fails. Central to weapon work; the shot parameters such as spread and bullet count are unverified.", + "source": "generated" + }, + "FetchBombState::GetName": { + "text": "Reports the state's name string; `FetchBomb` is shipped as its anchor, naming the behaviour in which a bot goes to retrieve a loose bomb. Useful for tying bot debug traces back to that goal.", + "source": "generated" + }, + "FetchBombState::OnEnter": { + "text": "Begins the behaviour in which a bot heads for the dropped bomb, performing that state's entry work. The FetchBombState class is implied by the name, so the goal selection and pathing it sets up are unverified.", + "source": "generated" + }, + "FetchBombState::OnUpdate": { + "text": "Drives the ongoing fetch-the-bomb behaviour, including the case its shipped string describes \u2014 `Someone else picked up the bomb.` \u2014 where another player claims the objective first. Useful when reasoning about how bots abandon a bomb-retrieval goal.", + "source": "generated" + }, + "FileNamesOffset": { + "text": "Yields the offset of a file-name table inside its containing structure, an accessor for reaching stored file names from a base pointer. Read from the name; the structure and the table's contents are unverified.", + "source": "generated" + }, + "FileSystemPointer": { + "text": "Yields the pointer to the filesystem interface, the object used for reading and writing game files and searching paths. Read from the name; how it is acquired and which interface it exposes are unverified.", + "source": "generated" + }, + "FilterDamageType::PassesDamageFilterImpl": { + "text": "Decides whether an incoming damage event passes the filter, testing the damage against the filter's configured `m_iDamageType`. The FilterDamageType class is implied by the name; this is the hook to target when gating triggers or map logic on a specific damage type.", + "source": "generated" + }, + "FilterDamageType::PassesFilterImpl": { + "text": "Handles the plain entity-passes-filter test for a damage-type filter, the non-damage query variant of its filtering check. The FilterDamageType class is implied by the name, and since `m_iDamageType` only classifies damage, the outcome for non-damage queries is unverified.", + "source": "generated" + }, + "FindConnectedBoundaryEdgesWithinCircle": { + "text": "Finds boundary edges that connect to one another inside a circular (2D radius) query region, the kind of lookup used when clipping or repairing the borders of a mesh or nav area around a point. The name ships verbatim as a string and nothing beyond it is derived, so the inputs and the geometry searched are unverified.", + "source": "generated" + }, + "FindConnectedBoundaryEdgesWithinSphere": { + "text": "Finds boundary edges that connect to one another inside a spherical (3D radius) query region, the volumetric counterpart to the circular form for trimming or stitching surface borders. The name ships verbatim as a string and nothing beyond it is derived, so the inputs and the geometry searched are unverified.", + "source": "generated" + }, + "FindOverlaps": { + "text": "Reports which members of some spatial or interval set overlap a supplied query \u2014 an intersection test rather than a single-hit lookup. Read from the name, which also appears verbatim as a string; the domain it searches (volumes, bounds, or ranges) is not established here.", + "source": "generated" + }, + "FindUseEntity": { + "text": "Picks the entity a player's +use should act on, searching in front of the player's view. Read from the name and the CCSPlayer_UseServices class this batch's fields reference; the alias CEntityClass::Unserialize and its string anchor are a medium-confidence attribution, so verify.", + "source": "generated" + }, + "FindWeaponVDataByName": { + "text": "Resolves a weapon's VData definition record from a name key, the lookup a modder uses to read or compare a weapon's configured stats by weapon name. Valve ships the same function under the second name GetWeaponCSDataFromKey, and its behaviour is derived here rather than inferred from the name alone.", + "source": "generated" + }, + "FireOutputInternal": { + "text": "Performs the internal work of firing an entity output, the low-level side of the map/entity I/O system that mods hook to observe or trigger entity events. Read from the name at medium-high confidence; the output record it acts on, and any activator or delay handling, are not established here.", + "source": "generated" + }, + "FollowState::GetName": { + "text": "Reports the name string for the bot follow behaviour, the label that identifies that state in debug output. The FollowState class is implied by the name, and the exact string reported is not established here.", + "source": "generated" + }, + "FollowState::OnEnter": { + "text": "Sets up the behaviour in which a bot follows a leader or teammate, doing that state's entry work. The FollowState class is implied by the name, and which target it latches onto is unverified.", + "source": "generated" + }, + "FollowState::OnExit": { + "text": "Cleans up when a bot stops following and the follow behaviour ends. The FollowState class is implied by the name, and what it releases or resets is not established by this data.", + "source": "generated" + }, + "FollowState::OnUpdate": { + "text": "Drives the follow behaviour while it is active, including the idling case its shipped debug string describes \u2014 `%4.1f: Bored. Repathing to a new nearby area` \u2014 where a waiting follower repaths nearby. Relevant when tuning how bot escorts loiter around their leader.", + "source": "generated" + }, + "FrameRateSpikeDump": { + "text": "Dumps diagnostic information when the engine registers a frame-rate spike, so a server hitch can be attributed to whatever was busy during the long frame. Read from the name only; the spike threshold, the destination of the dump, and its format are unverified.", + "source": "generated" + }, + "Friction": { + "text": "Applies ground friction, bleeding off horizontal speed while the player is on the ground. Read from the name and Source-movement lineage; also shipped as CCSPlayer_MovementServices::Friction, the hook point for slippery or extra-grippy movement mods.", + "source": "generated" + }, + "FullWalkMove": { + "text": "Runs the walking-movement update for one command, the main body of on-foot player movement. Read from the name and Source-movement lineage; also shipped as CCSPlayer_MovementServices::FullWalkMove, a common target for mods that replace ground movement wholesale.", + "source": "generated" + }, + "GameEventManager": { + "text": "Provides the game-event manager, the subsystem mods use to fire and listen for named game events. Named at medium confidence with no string anchor, so whether this is an accessor, a constructor, or a method on the manager itself is not established.", + "source": "generated" + }, + "GameSystem_Think_CheckSteamBan": { + "text": "Per-think game-system check that acts on Steam/GC ban and matchmaking-cooldown information for connected players, kicking them subject to sv_kick_players_with_cooldown \u2014 it carries the message \"Kicking user %s (sv_kick_players_with_cooldown=%d)\". Also shipped as HandleGCBanInfo; relevant to any server that wants to permit or suppress cooldown kicks.", + "source": "generated" + }, + "GameTypes::OnLevelLoadingSetDefaultGameModeAndType": { + "text": "Applies the default game mode and game type for the map being loaded, so a server that specifies neither still ends up with a defined mode. The GameTypes class is implied by the name, and which defaults it selects is unverified.", + "source": "generated" + }, + "GetAbsAngles": { + "text": "Returns an entity's absolute world-space orientation angles, as opposed to angles held relative to a parent. Read from the name at medium confidence with no prototype derived, so the owning type is unconfirmed, though CEntityInstance is among the classes this data's fields and parameters reference.", + "source": "generated" + }, + "GetAbsOrigin": { + "text": "Returns an entity's absolute world-space position, the value you want whenever a parented or attached entity's local origin would be misleading. Read from the name at medium confidence; the owning type is not derived, though CEntityInstance appears among the classes referenced by this data.", + "source": "generated" + }, + "GetAbsOriginFunction": { + "text": "Also yields an entity's absolute world-space origin; the \"Function\" suffix reads as a wrapper or function-pointer form of that accessor rather than a different query. Read from the name at medium confidence, and this data does not establish how it differs from GetAbsOrigin.", + "source": "generated" + }, + "GetAbsScale": { + "text": "Returns an entity's absolute world-space scale, folding in any parent scaling rather than reporting the entity's own value. Read from the name at medium confidence with no prototype derived; compare GetLocalScale for the unparented figure.", + "source": "generated" + }, + "GetAbsVelocity": { + "text": "Reads an entity's absolute, world-space velocity rather than any parent-relative value. Read from the name and the CBaseEntity::AbsVelocity alias; no prototype is derived, so the exact stored field and whether any recomputation happens are unverified.", + "source": "generated" + }, + "GetBitRange": { + "text": "Extracts a range of bits from a packed buffer or field, a bit-level read helper in the networking layer that matters when decoding or reproducing net message encodings. Read from the name only; the buffer type, bit ordering, and clamping behaviour are unverified.", + "source": "generated" + }, + "GetBoneIndexForHitboxForMesh": { + "text": "Maps a hitbox on a given mesh to the skeleton bone index that drives it, the lookup needed to turn a hitbox hit into a bone for attachment, positioning, or damage-zone logic. Read from the name only; the mesh and hitbox identifiers it accepts are unverified.", + "source": "generated" + }, + "GetCSWeaponDataFromKey": { + "text": "Retrieves the CS weapon data record for a given key, the CS-specific weapon definition lookup. Read from the name at medium-high confidence; despite the near-identical spelling it is recorded apart from FindWeaponVDataByName (also shipped as GetWeaponCSDataFromKey), so do not assume the two are interchangeable.", + "source": "generated" + }, + "GetClassNameAsCStr": { + "text": "Returns an entity's class name as a C string, the cheap way to identify what an entity is when filtering or branching on classname. Read from the name at medium confidence; the owning type is not derived, though CEntityInstance is referenced by this data's fields and parameters.", + "source": "generated" + }, + "GetClassNameOverride": { + "text": "Returns a class name that supersedes the entity's default one, letting a subclass or script-backed entity report a classname other than its native type. The name ships verbatim as a string; whether it is a virtual hook a mod can override or a plain query is not established.", + "source": "generated" + }, + "GetDamage": { + "text": "Returns the damage amount carried by a damage/take-damage info record, the base figure a damage handler reads before applying its own adjustments. Read from the name at medium confidence; the record type it reads is not derived, so treat the field mapping as unconfirmed.", + "source": "generated" + }, + "GetDamageCustom": { + "text": "Returns the \"custom\" damage classifier stored alongside a damage record, the value used to distinguish special damage or kill varieties beyond the plain type flags. Read from the name at medium confidence; the set of possible values and their meanings is not established here.", + "source": "generated" + }, + "GetDamageForce": { + "text": "Returns the force vector attached to a damage event, which is what drives ragdoll and physics push on the victim. Read from the name at medium confidence with no prototype derived, so the exact record it reads and the vector's units are unverified.", + "source": "generated" + }, + "GetDamagePosition": { + "text": "Returns the world position at which damage was applied, useful for hit effects, directional damage indicators, and hit-location logic. Read from the name at medium confidence; the damage record it reads from is not derived here.", + "source": "generated" + }, + "GetDamageType": { + "text": "Returns the damage-type bitfield for a damage event \u2014 the flags describing how the damage was dealt, which armour, immunity, and damage-filter rules test. Read from the name at medium confidence; the individual flag values are not established by this data.", + "source": "generated" + }, + "GetDesignerNameForScriptClass": { + "text": "Maps a script-facing class to the designer name used in maps and entity I/O, bridging a scripting class and the entity name a level designer would type. The name ships verbatim as a string; the scripting system involved and the identifier form are not derived.", + "source": "generated" + }, + "GetFreeClient": { + "text": "Finds an unused client slot on the server, the allocation step behind admitting a new connection or placing a bot. Read from the name at medium-high confidence; the slot bookkeeping it consults and its behaviour when the server is full are not established here.", + "source": "generated" + }, + "GetItemSchema": { + "text": "Returns the item schema, the economy and inventory definition set covering items, weapon finishes, and their attributes. Read from the name at medium confidence; whether it hands back a process-wide singleton or a per-context schema is not established.", + "source": "generated" + }, + "GetJointLimitAngles": { + "text": "Returns the angular limits of a physics or animation joint constraint \u2014 how far that joint is permitted to rotate about each axis. The name ships verbatim as a string; the joint identifier it takes and the axis convention of the result are unverified.", + "source": "generated" + }, + "GetLegacyGameEventListener": { + "text": "Supplies a player controller's legacy game-event listener, the object older-style game-event plumbing expects to work with. Read from the name, with the prototype verified; the same function also ships as CCSPlayerController::LegacyGameEventListener and LegacyGameEventListener.", + "source": "generated" + }, + "GetLocalScale": { + "text": "Returns an entity's own scale before any parent transform is applied, the counterpart to GetAbsScale for reading or reasoning about an unparented value. Read from the name at medium confidence with no prototype derived.", + "source": "generated" + }, + "GetNamedManifestResources": { + "text": "Retrieves the resources listed under a named manifest, the resource system's way of enumerating a bundle's contents by manifest name. Read from the name only; the manifest identifier it accepts and the form of the returned collection are unverified.", + "source": "generated" + }, + "GetNativeClassForScriptClass": { + "text": "Resolves a script-level class to the native C++ entity class backing it, the inverse of exposing an engine class to scripting. The name ships verbatim as a string; the binding layer it consults and whether it takes a name or a descriptor are not derived here.", + "source": "generated" + }, + "GetNativeOutputsForClass": { + "text": "Lists the entity outputs a native class declares, i.e. the outputs available for map and entity I/O wiring on that class. The name ships verbatim as a string; whether it is keyed by class name or by a class descriptor is not established.", + "source": "generated" + }, + "GetOriginalDamage": { + "text": "Returns the pre-modification damage recorded on a damage event, so a mod can compare it against the final figure after armour, falloff, and gameplay adjustments. Read from the name at medium confidence; the record layout it reads is not derived.", + "source": "generated" + }, + "GetParticleReplacement": { + "text": "Looks up a substitute particle effect for a requested one, the indirection that lets the game swap particle systems per context. Read from the name at medium confidence; the key it is given and where the replacement table comes from are not established here.", + "source": "generated" + }, + "GetPlayerLimits": { + "text": "Determines the server's player-count limits and can clamp the maximum, logging \"GetPlayerLimits: max players limited to %i\" when the cap it settles on is below what was asked for. Worth knowing when a mod tries to raise the player cap; the inputs behind the clamp are not derived.", + "source": "generated" + }, + "GetReportedPosition": { + "text": "Returns a \"reported\" position for an entity \u2014 a stored or communicated location kept separately from its live origin. Read from the name at medium confidence; what writes that value, and how it diverges from GetAbsOrigin, is not established by this data.", + "source": "generated" + }, + "GetSequenceActivityName": { + "text": "Resolves a model's animation sequence index to the activity name that sequence maps to, and reports 'Bad sequence in GetSequenceActivityName() for model '%s'!' when the index is not valid for the model. Useful when driving or inspecting animations by activity rather than raw sequence indices; read from the anchor and name, with details unverified.", + "source": "generated" + }, + "GetSpawnGroups": { + "text": "Retrieves the spawn groups the server currently has loaded, the world chunks that make up the running map and any streamed-in content. Also shipped as CSpawnGroupMgrGameSystem::GetSpawnGroups; read from the name at medium confidence, useful when enumerating loaded world data.", + "source": "generated" + }, + "GetTotalledDamage": { + "text": "Returns an accumulated damage total, reading as the running damage a player has dealt or absorbed over some scoring period. Taken from the name alone, so what the total covers and when it resets are unverified.", + "source": "generated" + }, + "GetWeaponAttackTime": { + "text": "Computes a weapon's attack timing from a user command, complaining 'sv: GetWeaponAttackTime - null cmd' when no command is supplied. Relevant to fire-rate and next-attack pacing work; read from the anchor and name, so the exact quantity produced is unverified.", + "source": "generated" + }, + "GetWeaponCSDataFromKey": { + "text": "Looks up a weapon's CS-specific data record from a key, and also ships as FindWeaponVDataByName, which reads as fetching weapon VData by name. Handy for resolving a weapon definition from a string identifier; read from the two names, so the key's exact form is unverified.", + "source": "generated" + }, + "GiveNamedItem": { + "text": "Grants an entity an item identified by name, spawning and handing over the corresponding weapon or gear, and guards against a missing target with 'nullptr Ent in GiveNamedItem'. A natural hook for giving players equipment by classname; read from the anchor and name, with details unverified.", + "source": "generated" + }, + "GiveNamedItem2": { + "text": "A second variant of giving an entity a named item, alongside GiveNamedItem. Read from the name; how it differs from GiveNamedItem is not established by this data.", + "source": "generated" + }, + "GlobalVarsPointer": { + "text": "Provides access to the engine's global variables block, the shared per-frame time, tick and frame-count state that server code reads constantly. Read from the name; the block's exact contents and how the pointer is acquired are unverified.", + "source": "generated" + }, + "HandleGCBanInfo": { + "text": "Acts on ban and cooldown information from the Steam Game Coordinator, kicking an affected player and logging 'Kicking user %s (sv_kick_players_with_cooldown=%d)'. Also shipped as GameSystem_Think_CheckSteamBan, and the derivation here is complete, so this reading is comparatively well supported.", + "source": "generated" + }, + "HandleSwapTeams": { + "text": "Swaps the two teams, moving each side's players to the other team as a half or round transition requires. Read from the name; what it does with scores, spawns and player state is unverified.", + "source": "generated" + }, + "HideState::GetName": { + "text": "Reports the name string for the bot hide behaviour, the label identifying that state. The HideState class is implied by the name, and the exact string it reports is not established here.", + "source": "generated" + }, + "HideState::OnEnter": { + "text": "Starts the bot's hiding behaviour, doing the entry work for taking cover. The HideState class is implied by the name, so the hiding-spot selection or crouch/aim setup it performs is unverified.", + "source": "generated" + }, + "HideState::OnExit": { + "text": "Ends the bot's hiding behaviour and cleans up as it leaves cover. The HideState class is implied by the name, and what it releases \u2014 a reserved hiding spot, for instance \u2014 is unverified.", + "source": "generated" + }, + "HideState::OnUpdate": { + "text": "Runs the hiding behaviour while it is active, including the timed hold its shipped string describes \u2014 `Heard enemy, holding position for %f2.1 seconds...` \u2014 where a bot that hears an enemy stays put. Useful when tuning how long bots camp after a noise cue.", + "source": "generated" + }, + "HostStateRequest": { + "text": "Starts a new host-state request, the engine-level mechanism behind map changes and level loads. Also shipped as CHostStateMgr::StartNewRequest and found in libengine2 rather than the game module, so reach for it when driving map changes from native code.", + "source": "generated" + }, + "Host_Say": { + "text": "Processes a chat message from a player or the server and delivers it to the intended audience, with the 'All Chat' anchor marking the everyone-hears case. A natural hook point for chat commands and chat filtering; read from the anchor and name, details unverified.", + "source": "generated" + }, + "HuntState::GetName": { + "text": "Reports the state's name string, with `Hunt` shipped as its anchor \u2014 the label for the behaviour in which a bot roams to seek out enemies. Useful for spotting that state in bot debug output.", + "source": "generated" + }, + "HuntState::OnEnter": { + "text": "Begins the hunting behaviour in which a bot goes looking for enemies, performing that state's entry work. The HuntState class is implied by the name, and the search area or initial target it picks is unverified.", + "source": "generated" + }, + "HuntState::OnUpdate": { + "text": "Drives the hunt behaviour while it is active, moving the bot along its search for enemies. The HuntState class is implied by the name, and the repathing and target-acquisition rules it applies are unverified.", + "source": "generated" + }, + "IGameSystem::InitAllSystems": { + "text": "Initialises the server's registered game systems in a single startup pass. Read from the name; a mod that registers its own game system depends on this pass, though the registration it consults is unverified.", + "source": "generated" + }, + "IGameSystem::InitAllSystems->pFirst": { + "text": "Locates `pFirst`, the head-of-list pointer that IGameSystem::InitAllSystems uses to reach the registered game systems, and is also shipped as IGameSystem_InitAllSystems_pFirst. Read from the name \u2014 useful when you want the game-system list itself rather than the init routine.", + "source": "generated" + }, + "IGameSystem::LoopActivateAllSystems": { + "text": "Runs the activation pass over the server's game systems, emitting the shipped marker `%s: IGameSystem::LoopActivateAllSystems {`. Useful for a mod whose game system must come alive with the engine's, and for reading that block in startup spew.", + "source": "generated" + }, + "IGameSystem::LoopDeactivateAllSystems": { + "text": "Runs the deactivation pass over the server's game systems, emitting the shipped marker `%s: IGameSystem::LoopDeactivateAllSystems {`. The shutdown-side counterpart to activation, and a natural place to watch mod game systems being wound down.", + "source": "generated" + }, + "IGameSystem::LoopDestroyAllSystems->s_GameSystems": { + "text": "Locates `s_GameSystems`, the static game-system container that IGameSystem::LoopDestroyAllSystems works through when tearing systems down; also shipped as IGameSystem_LoopDestroyAllSystems_s_GameSystems. Read from the name, and useful for enumerating registered game systems directly.", + "source": "generated" + }, + "IGameSystem::LoopInitAllSystems": { + "text": "Runs the initialisation pass across the server's game systems, giving each its init opportunity. Read from the name; mods that register a game system rely on this pass, though what it iterates is unverified.", + "source": "generated" + }, + "IGameSystem::LoopPostInitAllSystems": { + "text": "Runs the post-initialisation pass over the server's game systems, emitting the shipped marker `%s: IGameSystem::LoopPostInitAllSystems(start)`. Read from the name and that string: this is the phase where a mod's game system does work that assumes basic init is complete.", + "source": "generated" + }, + "IGameSystem::LoopPostInitAllSystems->pEventDispatcher": { + "text": "Locates `pEventDispatcher`, the dispatcher object used inside IGameSystem::LoopPostInitAllSystems to drive the post-init pass over game systems; also shipped as IGameSystem_LoopPostInitAllSystems_pEventDispatcher. Read from the name \u2014 handy when you need the dispatcher rather than the loop around it.", + "source": "generated" + }, + "IGameSystem::PostInitAllSystems": { + "text": "Performs the post-init pass over game systems and times each one: the shipped format `IGameSystem::PostInit( %-80s ) %8.3f msec` prints a system's name and its post-init cost in milliseconds. That spew is a cheap way to see whether a mod's game system slows server startup.", + "source": "generated" + }, + "IGameSystem_InitAllSystems_pFirst": { + "text": "Initialises the server's registered game systems during startup, walking the pFirst list head the key names. The entry is keyed IGameSystem_InitAllSystems_pFirst and read at that level with medium confidence, so verify before hooking game-system registration.", + "source": "generated" + }, + "IGameSystem_LoopDestroyAllSystems_s_GameSystems": { + "text": "Tears down the registered game systems at shutdown, iterating the s_GameSystems list the key names. Keyed IGameSystem_LoopDestroyAllSystems_s_GameSystems and read at that level with medium confidence, so confirm against your build before hooking shutdown cleanup.", + "source": "generated" + }, + "IGameSystem_LoopPostInitAllSystems_pEventDispatcher": { + "text": "Runs the post-initialisation pass over the registered game systems, touching the pEventDispatcher the key names. Keyed IGameSystem_LoopPostInitAllSystems_pEventDispatcher and read at that level with medium confidence; relevant if you attach your own event handling during game-system startup.", + "source": "generated" + }, + "IKV3TransferInterface_EHandle_Load": { + "text": "Loads an entity-handle value through the KeyValues3 transfer interface, deserializing an EHandle-typed field from KV3 data. Read from the name; the stored representation and the behaviour on a stale or missing handle are unverified.", + "source": "generated" + }, + "IKV3TransferInterface_ResourceLoad": { + "text": "Loads a resource-typed value through the KeyValues3 transfer interface, resolving a resource reference held in KV3 data. Read from the name; which resource kinds it accepts and how misses are reported are unverified.", + "source": "generated" + }, + "IMsgNetPacketFromCNetPacket": { + "text": "Wraps a raw CNetPacket as the IMsgNetPacket view that network message handling consumes, rejecting bad input with 'IMsgNetPacketFromCNetPacket: malformed packet, size %d bytes'. Relevant when intercepting or parsing incoming net messages; read from the anchor and name.", + "source": "generated" + }, + "INetChannel::SendNetMessage": { + "text": "Sends a network message out over a net channel \u2014 the send point for engine messages on a given connection. Shipped in libnetworksystem with a derived prototype, making it the hook of choice for intercepting or injecting messages to a specific client.", + "source": "generated" + }, + "IScriptVM::CreateVM": { + "text": "Creates a script virtual machine instance for the server's scripting layer, the handle through which script code is loaded and run. Shipped in libvscript; read from the name, so the backend it selects and the VM's lifetime rules are unverified.", + "source": "generated" + }, + "ISkeletonAnimationController::ISkeletonAnimationController": { + "text": "Constructs an instance of the skeleton animation controller interface, the handle through which a model's skeleton animation is driven. Read from the name; what state it sets up is not established by this data.", + "source": "generated" + }, + "IdleState::GetName": { + "text": "Reports the identifying name of an idle behaviour state, with the string `Idle` sitting alongside it as the label it hands back. Useful for logging or for matching on which behaviour state an actor currently occupies.", + "source": "generated" + }, + "IdleState::OnEnter": { + "text": "Performs the setup an idle behaviour state does when it becomes the active state, such as clearing whatever the previous activity left behind. The IdleState class is implied by the name rather than established by the data, and the slot is unbound, so the reading is unverified.", + "source": "generated" + }, + "IdleState::OnUpdate": { + "text": "Runs the per-tick work of an idle behaviour state, the place where a decision to keep idling or hand off is made. The IdleState class is implied by the name rather than established by the data, so both ownership and the effects are unverified.", + "source": "generated" + }, + "ImagePropertiesOffset": { + "text": "Locates the image-properties data inside a larger record, giving callers direct access to an image or texture's property block. Read from the name; what structure the offset applies to, and which properties it exposes, are not established.", + "source": "generated" + }, + "InitGameRules": { + "text": "Sets up the game rules for the session and reports 'InitGameRules: game rules entity (%s) not created' when the gamerules entity fails to come into existence. A useful place for a mod to observe or adjust gamerules creation; read from the anchor and name, timing unverified.", + "source": "generated" + }, + "InitGameTrace": { + "text": "Prepares a game trace query, the ray or hull cast used for hit and visibility tests, in code that also carries the 'invalid_hitbox' anchor. Relevant to hit registration and custom tracing work; read from the anchor and name, so exactly what it initialises is unverified.", + "source": "generated" + }, + "InitSteamLogin": { + "text": "Starts the server's Steam login, bringing up the Steam session the server needs to be listed and to validate connecting clients. Read from the name in libengine2; the sequence of steps and any inputs are unverified.", + "source": "generated" + }, + "InputAddAttribute": { + "text": "Handles the `AddAttribute` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputAddContext": { + "text": "Handles the `AddContext` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputChangeSubclass": { + "text": "Handles the `ChangeSubclass` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputClearContext": { + "text": "Handles the `ClearContext` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputClearParent": { + "text": "Handles the `ClearParent` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputDisableDamageForces": { + "text": "Handles the `DisableDamageForces` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputDisableShadow": { + "text": "Handles the `DisableShadow` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputDisableUpdateTarget": { + "text": "Handles the `_DisableUpdateTarget` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputDispatchResponse": { + "text": "Handles the `DispatchResponse` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputEnableDamageForces": { + "text": "Handles the `EnableDamageForces` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputEnableShadow": { + "text": "Handles the `EnableShadow` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputEnableUpdateTarget": { + "text": "Handles the `_EnableUpdateTarget` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputEndHint": { + "text": "Handles the `EndHint` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireEvent": { + "text": "Handles the `FireEvent` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireUser1": { + "text": "Handles the `FireUser1` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireUser2": { + "text": "Handles the `FireUser2` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireUser3": { + "text": "Handles the `FireUser3` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireUser4": { + "text": "Handles the `FireUser4` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFollowEntity": { + "text": "Handles the `FollowEntity` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFunctionAdapterS1Var": { + "text": "Handles the `IsTouching` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputGameEnd": { + "text": "Handles the `EndGame` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputKill": { + "text": "Handles the `Kill` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputKillConstrained": { + "text": "Handles the `KillConstrained` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputKillHierarchy": { + "text": "Handles the `KillHierarchy` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputPlatformDisable": { + "text": "Handles the `DisablePlatform` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputPlatformFollowYaw": { + "text": "Handles the `PlatformFollowYaw` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputRemoveAttribute": { + "text": "Handles the `RemoveAttribute` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputRemoveContext": { + "text": "Handles the `RemoveContext` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetBreakable": { + "text": "Handles the `SetBreakable` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetDamageFilter": { + "text": "Handles the `SetDamageFilter` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetNonsolid": { + "text": "Handles the `SetNonsolid` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetParentAttachment": { + "text": "Handles the `SetParentAttachment` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetParentAttachmentMaintainOffset": { + "text": "Handles the `SetParentAttachmentMaintainOffset` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetPositionImmediately": { + "text": "Handles the `SetPositionImmediately` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetSolid": { + "text": "Handles the `SetSolid` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetTargetPlayerToActivator": { + "text": "Handles the `SetTargetPlayerToActivator` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetTeam": { + "text": "Handles the `SetTeam` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetUnbreakable": { + "text": "Handles the `SetUnbreakable` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputShowHint": { + "text": "Handles the `ShowHint` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSplash": { + "text": "Handles the `Splash` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputTriggerForActivatedPlayer": { + "text": "Handles the `TriggerForActivatedPlayer` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputTriggerForAllPlayers": { + "text": "Handles the `TriggerForAllPlayers` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputUse": { + "text": "Handles the `Use` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InstancedAutoGeneratedSequenceScene": { + "text": "Builds an instanced, auto-generated choreo scene that plays a sequence on an actor, warning 'InstancedAutoGeneratedSequenceScene: Expecting non-NULL pActor for sound %s' when no actor is supplied. Useful for making an entity perform a scene without an authored scene file; read from the anchor and name.", + "source": "generated" + }, + "InstancedAutoGeneratedSoundScene": { + "text": "Builds an instanced, auto-generated scene that plays a sound on an actor, warning 'InstancedAutoGeneratedSoundScene: Expecting non-NULL pActor for sound %s' when the actor is missing. The sound-side companion to InstancedAutoGeneratedSequenceScene; read from the anchor and name, with details unverified.", + "source": "generated" + }, + "Internal_Coroutine_Continue": { + "text": "Resumes a suspended coroutine, continuing execution of the tier0 coroutine primitive from where it yielded. Read from the name; the scheduling rules and what happens once the coroutine finishes are unverified.", + "source": "generated" + }, + "InvestigateNoiseState::GetName": { + "text": "Reports the identifying name of the noise-investigation behaviour state, with the string `InvestigateNoise` alongside it as the label returned. Handy for logging or for testing which behaviour state an actor is currently in.", + "source": "generated" + }, + "InvestigateNoiseState::OnEnter": { + "text": "Performs the entry work for a behaviour state that sends an actor to check out a heard noise, such as latching the noise position as the destination. The InvestigateNoiseState class is implied by the name, not established by the data, so this reading is unverified.", + "source": "generated" + }, + "InvestigateNoiseState::OnExit": { + "text": "Performs the teardown when the noise-investigation behaviour state stops running, releasing whatever the search held. The InvestigateNoiseState class is implied by the name rather than by the data, so both the ownership and the cleanup performed are unverified.", + "source": "generated" + }, + "InvestigateNoiseState::OnUpdate": { + "text": "Drives the per-tick search of a heard noise's location; the string `Noise location is clear.` sits alongside it, showing the state recognises when the searched spot turns up nothing. Relevant when tracing or replacing how an actor investigates after hearing a sound.", + "source": "generated" + }, + "IsHearingClient": { + "text": "Tests whether one client can hear another, the voice-audibility check behind team-only and proximity voice rules. Read from the name, backed by a complete derivation, though the criteria it applies remain unverified.", + "source": "generated" + }, + "IsLastRoundBeforeHalfTime": { + "text": "Reports whether the round in progress is the final one before halftime, handy for side-switch announcements or end-of-half scripting. Read from the name and the CCSGameRules::IsLastRoundBeforeHalfTime alias; no prototype is derived, so the round-count rules behind the answer are unverified.", + "source": "generated" + }, + "KeyValues3::AddArrayElementToTail": { + "text": "Appends a fresh element onto the end of a KV3 array node, growing it by one. Read from the name; what the new element is initialised to is not established.", + "source": "generated" + }, + "KeyValues3::AllocArray_Float32_Internal": { + "text": "Allocates the backing storage for a float32-typed KV3 array node. The `_Internal` suffix marks it as an implementation helper rather than a public entry point, and the allocation policy is read from the name only.", + "source": "generated" + }, + "KeyValues3::AllocArray_Int32_Internal": { + "text": "Allocates the backing storage for an int32-typed KV3 array node. The `_Internal` suffix marks it as an implementation helper rather than a public entry point, and the allocation policy is read from the name only.", + "source": "generated" + }, + "KeyValues3::FindMember": { + "text": "Looks up a member of a KV3 object node by name, without adding one when it is absent \u2014 the read-only counterpart to KeyValues3::FindOrCreateMember. Read from the name; the key form and the absent-member result are not established.", + "source": "generated" + }, + "KeyValues3::FindOrCreateMember": { + "text": "Looks up a named member of a KV3 object node and creates it when it does not yet exist, which is the call to use when writing values into a tree you did not build. Read from the name; the type a freshly created member takes is not established.", + "source": "generated" + }, + "KeyValues3::GetArrayElement": { + "text": "Retrieves a single element of a KV3 array node by its position. Read from the name; how out-of-range positions are handled is not established.", + "source": "generated" + }, + "KeyValues3::GetArrayElementCount": { + "text": "Reports how many elements a KV3 array node currently holds, which is what bounds an iteration using KeyValues3::GetArrayElement. Read from the name; behaviour on a node that is not an array is not established.", + "source": "generated" + }, + "KeyValues3::GetFloat": { + "text": "Reads a KV3 node's value as a floating-point number. Read from the name; how it behaves when the node holds some other type is not established.", + "source": "generated" + }, + "KeyValues3::GetInt": { + "text": "Reads a KV3 node's value as an integer. Read from the name; how it behaves when the node holds some other type is not established.", + "source": "generated" + }, + "KeyValues3::GetMember": { + "text": "Retrieves a member of a KV3 object node by position rather than by name, the piece used with KeyValues3::GetMemberCount and KeyValues3::GetMemberName when walking a node's contents. Read from the name; how the member is selected is not established.", + "source": "generated" + }, + "KeyValues3::GetMemberCount": { + "text": "Reports how many members a KV3 object node holds, bounding an iteration built on KeyValues3::GetMember. Read from the name; behaviour on a node that is not an object is not established.", + "source": "generated" + }, + "KeyValues3::GetMemberName": { + "text": "Yields the key string of a member of a KV3 object node, so an iteration can print or match on member names. Read from the name; how the member is identified is not established.", + "source": "generated" + }, + "KeyValues3::GetString": { + "text": "Reads a KV3 node's value as a string. Read from the name; whether it converts other value types or the lifetime of the text it hands back is not established.", + "source": "generated" + }, + "KeyValues3::GetVector": { + "text": "Reads a KV3 node's value as a vector, the usual way to pull positions, angles or colour triples out of a KV3 document. Read from the name; the component count and any conversion rules are not established.", + "source": "generated" + }, + "KeyValues3::PrepareForType": { + "text": "Puts a KV3 node into the shape a given value type requires, reallocating or discarding whatever the node previously held. Read from the name; which types are accepted and what existing data survives are not established.", + "source": "generated" + }, + "KeyValues3::ReadArrayFloat32": { + "text": "Bulk-reads the contents of a KV3 float32 array in one call rather than element by element, which is the efficient path for vertex, weight or curve data. Read from the name; the destination and bounds handling are not established.", + "source": "generated" + }, + "KeyValues3::ReadArrayInt32": { + "text": "Bulk-reads the contents of a KV3 int32 array in one call rather than element by element, useful for index or id tables. Read from the name; the destination and bounds handling are not established.", + "source": "generated" + }, + "KeyValues3::RemoveArrayElements": { + "text": "Deletes a run of elements from a KV3 array node, shrinking it. Read from the name; how the run is specified and whether later elements shift down are not established.", + "source": "generated" + }, + "KeyValues3::RemoveMember_MemberName": { + "text": "Deletes a member from a KV3 object node, selecting it by member name as the suffix spells out. Read from the name; what happens when no member of that name is present is not established.", + "source": "generated" + }, + "KeyValues3::SetString": { + "text": "Stores a string value into a KV3 node, the write-side counterpart to KeyValues3::GetString. Read from the name; whether the text is copied into the node or referenced in place is not established.", + "source": "generated" + }, + "KeyValues::RecursiveLoadFromBuffer": { + "text": "Parses KeyValues text held in an in-memory buffer, descending into nested blocks to build the key tree \u2014 what you want when the config text is already in memory rather than on disk. Read from the name; the accepted syntax and error behaviour are not established here.", + "source": "generated" + }, + "KeyValues::SaveToFile": { + "text": "Writes a KeyValues tree back out to a file in its text form, for persisting config or state assembled or edited in memory. Read from the name; the formatting and overwrite behaviour are not established by this data.", + "source": "generated" + }, + "LaunchWorkshopMap": { + "text": "Starts a map published on the Steam Workshop, taking the server into a workshop-hosted level. Read from the name; how the map is identified and whether it is downloaded first are unverified.", + "source": "generated" + }, + "LegacyGameEventListener": { + "text": "Yields the legacy game-event listener belonging to a player controller, for code paths that still use the older game-event interface. Read from the name, with the prototype verified; the same function also ships as CCSPlayerController::LegacyGameEventListener and GetLegacyGameEventListener.", + "source": "generated" + }, + "LobbyMapVetoFinished": { + "text": "Handles the end of the lobby's map veto and pick phase, logging the outcome as 'LobbyMapVetoFinished: %s %s %s -(%s)'. Relevant to matchmaking-style map selection flows; read from the anchor and name, so the meaning of each logged field is unverified.", + "source": "generated" + }, + "LocalPlayerControllerPointer": { + "text": "Provides the local player controller pointer, giving access to the controller object for the local player on a listen server. Read from the name; what it resolves to on a dedicated server is not established.", + "source": "generated" + }, + "LoopModeGamePointer": { + "text": "Provides the game loop-mode object, the engine's active run mode while a game session is in progress rather than a menu or load state. Read from the name; the object's contents are unverified.", + "source": "generated" + }, + "MakeSymbolFunctionPointer": { + "text": "Resolves a symbol into a callable function pointer, in code that also reports 'Trying to find a flex controller (%s) that doesn't actually exist in the model.' Likely serves name-keyed lookup of model or animation entry points; read from the name plus that anchor, so the symbol namespace searched is unverified.", + "source": "generated" + }, + "Message::FindInitializationErrors": { + "text": "Checks a message for initialisation problems and reports `Message missing required fields:` when fields that must be set were left empty \u2014 the diagnostic you hit when a message is built incompletely. The anchor establishes the required-field check; any wider validation it performs is not established.", + "source": "generated" + }, + "MountWorldVPK": { + "text": "Mounts a world VPK archive so the files packed inside it become reachable through the filesystem for the loaded world. Read from the name in libworldrenderer; which search path it lands in, and how unmounting works, are unverified.", + "source": "generated" + }, + "MoveInit": { + "text": "Initialises the working state for a movement pass, setting up the movement code's copies of origin, velocity and movement parameters. Read from the name; also shipped as CCSPlayer_MovementServices::MoveInit, useful if you need to seed or override per-move state.", + "source": "generated" + }, + "MoveToState::GetName": { + "text": "Returns the state's identifying name string; beyond that the purpose is not established. The MoveToState class is implied by the name, not by the data.", + "source": "generated" + }, + "MoveToState::OnEnter": { + "text": "Performs the setup a bot needs when it begins moving to a chosen destination, such as latching the goal and starting a path. The class is implied by the name, and no string anchor or Valve text backs the reading, so the actual entry work is unverified.", + "source": "generated" + }, + "MoveToState::OnExit": { + "text": "Tears down the move-to-destination behaviour as the bot leaves it, releasing whatever the state held while running. The class is implied by the name, with no string anchor present, so the specific cleanup is unverified.", + "source": "generated" + }, + "MoveToState::OnUpdate": { + "text": "Advances the bot's move-to-destination behaviour each update and can abandon it: the message \"The enemy I was chasing was killed - giving up.\" lives here, so a chase target dying ends the move. Hook it to observe or change how bots pursue a position and when they give up.", + "source": "generated" + }, + "NavNearest::GetNavAreaOverlapping": { + "text": "Finds a navigation-mesh area that overlaps a given position, for when you need the area a point actually sits inside rather than one merely close by. The name appears verbatim as a string in libserver; tolerances and filtering are unverified.", + "source": "generated" + }, + "NavNearest::GetNearestNavArea": { + "text": "Finds the closest navigation-mesh area to a query position, a common way to snap an arbitrary world point onto the nav mesh for bot pathing. The name is present verbatim as a string; the search radius and any rejection rules are unverified.", + "source": "generated" + }, + "NavSpacePathfind_Npc::SpacePathfind_Core": { + "text": "Runs the core pathfinding search through NPC navigation space, producing the route an NPC follows between two points. The name is present verbatim as a string in libserver; the cost model and search bounds are unverified.", + "source": "generated" + }, + "NetworkStateChanged": { + "text": "Marks networked entity state as dirty so modified fields replicate out to clients, with the 'light_directional' anchor sitting alongside it. Important to mods that write schema fields directly and need the change to actually reach clients; the derivation is complete, but the dirty-marking granularity is unverified.", + "source": "generated" + }, + "OffsetToActiveWeapon": { + "text": "Gives the offset of the active-weapon field, letting callers reach a pawn's currently equipped weapon without a schema lookup. Read from the name; which class the offset applies to is not established by this data.", + "source": "generated" + }, + "OffsetToBasePawnHandle": { + "text": "Gives the offset of the handle that points from a controller to its pawn, and also ships as OffsetToPlayerPawnHandle, naming the same player pawn handle. Useful for hopping from a controller to the pawn it drives; read from the two names, so the owning class is unverified.", + "source": "generated" + }, + "OffsetToChildGameSceneNode": { + "text": "Gives the offset of a game scene node's child link, the field used to walk parent-child attachments in the scene graph. Read from the name; the exact structure it indexes into is unverified.", + "source": "generated" + }, + "OffsetToClipAmmo": { + "text": "Gives the offset of a weapon's clip ammo count, the rounds currently in the magazine. Read from the name; which weapon class it applies to, and which of the several ammo fields it targets, are unverified.", + "source": "generated" + }, + "OffsetToEntityClasses": { + "text": "Gives the offset of the entity-classes table, the registry of entity class entries the entity system works from. Read from the name; what container the offset applies to is not established.", + "source": "generated" + }, + "OffsetToFrametime": { + "text": "Gives the offset of the frametime field, the per-frame delta time that server code uses for time-scaled logic. Read from the name; the holding structure is unverified, though GlobalVarsPointer names a plausible home for it.", + "source": "generated" + }, + "OffsetToGameSceneNode": { + "text": "Resolves the offset of an entity's game scene node member, the scene-graph node an entity hangs its spatial state on, so a raw entity pointer can be turned into access to that node. Read from the name; no prototype is derived, so the owning type and how the offset is produced stay unverified.", + "source": "generated" + }, + "OffsetToHostageServices": { + "text": "Resolves the offset of the hostage services member, the sub-object that groups an entity's hostage-related state and behaviour. The reading comes from the name alone, so which entity carries the member and what the services expose are unverified.", + "source": "generated" + }, + "OffsetToIsBeingPlanted": { + "text": "Resolves the offset of an is-being-planted flag, the state marking that a C4 plant is currently in progress. Nothing beyond the name backs this, so the owning entity and the exact meaning of the flag are unverified.", + "source": "generated" + }, + "OffsetToIsGlowing": { + "text": "Resolves the offset of an entity's glowing flag, the state that switches its glow or outline effect on. Useful for toggling glow directly on a pawn or item; the reading is name-level, so the owning type is unverified.", + "source": "generated" + }, + "OffsetToIsScoped": { + "text": "Resolves the offset of the scoped flag, set while a player is looking through a weapon's scope. Handy for reading or forcing scope state from a pawn pointer; derived from the name, so the owning type and the flag's encoding are unverified.", + "source": "generated" + }, + "OffsetToItem3dPanelProperties": { + "text": "Resolves the offset of a 3D item panel's properties block, the settings that govern how an item is presented in that panel. Read from the name; no prototype is derived, so the panel type and the contents of the block are unverified.", + "source": "generated" + }, + "OffsetToItem3dPanelUnknownField": { + "text": "Resolves the offset of a field on a 3D item panel structure whose meaning was not identified \u2014 the name itself records that gap. Purpose beyond \"some member of that panel\" is not established.", + "source": "generated" + }, + "OffsetToLifeState": { + "text": "Resolves the offset of an entity's life state value, which distinguishes alive from dead or dying. Useful for checking death state straight from a pawn pointer; the reading is name-level, so the owning type and the value's encoding are unverified.", + "source": "generated" + }, + "OffsetToNextSiblingGameSceneNode": { + "text": "Resolves the offset of a scene node's next-sibling link, the field that lets sibling nodes in the scene hierarchy be walked one after another. Read from the name; no prototype is derived, so the node type and traversal conventions are unverified.", + "source": "generated" + }, + "OffsetToOwnerEntity": { + "text": "Resolves the offset of an entity's owner reference, the link from a projectile, weapon or effect back to the entity that owns it. Commonly wanted for damage attribution; the reading is name-level, so the owning type and the reference's form are unverified.", + "source": "generated" + }, + "OffsetToPanelId": { + "text": "Resolves the offset of a panel's identifier field. Which panel type carries it and what the identifier keys into are not established by this data.", + "source": "generated" + }, + "OffsetToPlayerColor": { + "text": "Resolves the offset of a player's assigned colour, the per-player tint used by teammate-facing UI. Read from the name; no prototype is derived, so the owning type and the colour's encoding are unverified.", + "source": "generated" + }, + "OffsetToPlayerPawnHandle": { + "text": "Resolves the offset of the handle linking a player object to the pawn it currently controls \u2014 the usual hop from controller to pawn. Shipped under both OffsetToPlayerPawnHandle and OffsetToBasePawnHandle for the same function; the reading is name-level, so the owning type is unverified.", + "source": "generated" + }, + "OffsetToPortraitWorld": { + "text": "Resolves the offset of a portrait-world reference, the field tying an object to the separate world used to render a portrait view. Read from the name; no prototype is derived, so the owning type and the referenced object are unverified.", + "source": "generated" + }, + "OffsetToRoundRestartTime": { + "text": "Resolves the offset of the round restart time, the game-rules value marking when the current round will restart. Useful for scheduling work around round transitions; the reading is name-level, so the owning type and the time base are unverified.", + "source": "generated" + }, + "OffsetToSceneObjectAttributes": { + "text": "Resolves the offset of a scene object's attribute block, the per-object parameters that shape how it is drawn. Read from the name; no prototype is derived, so the object type and the layout of those attributes are unverified.", + "source": "generated" + }, + "OffsetToSceneObjectClass": { + "text": "Resolves the offset of a scene object's class field, which identifies what kind of scene object it is. The reading comes from the name, so the owning type and whether the field holds a pointer or an enumerated value are unverified.", + "source": "generated" + }, + "OffsetToTeamNumber": { + "text": "Resolves the offset of an entity's team number, the value recording which team it belongs to. One of the most-reached-for members when reading or reassigning team membership on a pawn or controller; the reading is name-level, so the owning type is unverified.", + "source": "generated" + }, + "OffsetToWeaponServices": { + "text": "Resolves the offset of a pawn's weapon services member, the sub-object that carries weapon inventory and switching state. Read from the name; no prototype is derived, so the owning type and what the services hold are unverified.", + "source": "generated" + }, + "OnDeletePanelFunctionPointer": { + "text": "Resolves the offset of the callback pointer associated with panel deletion, the slot a panel owner uses for teardown work. Read from the name; no prototype is derived, so the panel type and the callback's contract are unverified.", + "source": "generated" + }, + "OnJumpLegacy": { + "text": "Performs the jump itself under the legacy jump model, applying jump velocity; its string anchor player_jump is the game-event name, so the jump event is likely raised here. Also shipped as CCSPlayer_MovementServices::OnJumpLegacy, and it pairs with CCSPlayerLegacyJump.", + "source": "generated" + }, + "OnJumpModern": { + "text": "Performs the jump itself under the modern jump model, applying the jump impulse to the player. Read from the name; also shipped as CCSPlayer_MovementServices::OnJumpModern, and it pairs with the CCSPlayerModernJump data this batch's fields reference.", + "source": "generated" + }, + "OnOwnerTakeDamage_React_TryForceDamageApply": { + "text": "Reacts to its owner taking damage by attempting to force the damage to be applied rather than letting it be dropped. The name is present verbatim as a string in the binary but nothing further is derived, so the owning system and the conditions under which the forcing succeeds are unverified.", + "source": "generated" + }, + "OpenDoorState::GetName": { + "text": "Reports the name of the door-opening behaviour state, with \"OpenDoor\" present as the reported string. Use it to identify which behaviour a bot is running when logging or debugging.", + "source": "generated" + }, + "OpenDoorState::OnEnter": { + "text": "Begins the bot's door-opening behaviour, doing whatever setup is needed before it works the door. The class is implied by the name, and no string anchor backs this entry, so the setup performed is unverified.", + "source": "generated" + }, + "OpenDoorState::OnExit": { + "text": "Ends the door-opening behaviour and releases what the state held while it ran. The class is implied by the name, with no string anchor present, so the cleanup is unverified.", + "source": "generated" + }, + "OpenDoorState::OnUpdate": { + "text": "Advances the door-opening behaviour each update, driving the bot to push or use the door; it carries the string \"Open door\". Hook it to change how bots deal with doors blocking a route, though the conditions that finish the state are unverified.", + "source": "generated" + }, + "PackEntity": { + "text": "Packs an entity's state into a compact serialised form. Read from the name in libengine2; whether this is network packing or another kind, and what it produces, are unverified.", + "source": "generated" + }, + "ParseSubclass": { + "text": "Parses a subclass specification, turning a named entity subclass in data into whatever the engine uses internally. Its name appears verbatim as a string anchor; the input format and the parsed result are unverified.", + "source": "generated" + }, + "PhysDisableEntityCollisions": { + "text": "Turns off physics collision between two particular entities, and rejects the request when the pair lives in two different scene worlds \u2014 its diagnostic string reports that mismatch with both entity names and IDs. The pairwise nature is evidenced by that string; the state it writes is unverified.", + "source": "generated" + }, + "PhysEnableEntityCollisions": { + "text": "Turns physics collision between two particular entities back on, and reports the same two-different-scene-worlds error when the pair is mismatched, naming both entities and their IDs. The pairwise form comes from that string; what state it restores, and any default, are unverified.", + "source": "generated" + }, + "PhysEntityCollisionsAreDisabled": { + "text": "Reports whether collision between two particular entities is currently disabled, and emits the same two-different-scene-worlds complaint when the pair is mismatched. The pairwise query reading rests on that string anchor; how the disabled state is stored is unverified.", + "source": "generated" + }, + "PhysicsSimulate": { + "text": "Runs a player controller's per-frame user-command simulation; its string anchor, \"'%s' took %.1fms to execute %d commands, backlog is %d commands\", shows it executes queued commands and reports time spent plus remaining backlog. The prototype is verified, and it also ships as CBasePlayerController::OnSimulateUserCommands and CCSPlayerController::PhysicsSimulate.", + "source": "generated" + }, + "PickupHostageState::GetName": { + "text": "Reports the name of the hostage-pickup behaviour state, with \"PickupHostage\" present as the reported string. Useful for identifying a bot's current behaviour in logs or debug overlays.", + "source": "generated" + }, + "PickupHostageState::OnEnter": { + "text": "Starts the bot's hostage-pickup behaviour, setting up the approach to the hostage it means to collect. The class is implied by the name, and no string anchor is present, so the setup is unverified.", + "source": "generated" + }, + "PickupHostageState::OnExit": { + "text": "Finishes the hostage-pickup behaviour and clears what the state held while active. The class is implied by the name, with no string anchor present, so the specific cleanup is unverified.", + "source": "generated" + }, + "PickupHostageState::OnUpdate": { + "text": "Advances the hostage-pickup behaviour each update, moving the bot toward the hostage and using it. The class is implied by the name, and no string anchor backs the reading, so success and abort conditions are unverified.", + "source": "generated" + }, + "PlantBombState::GetName": { + "text": "Reports the name of the bomb-planting behaviour state, with \"PlantBomb\" present as the reported string. Use it to identify a bot running bomb-plant behaviour when tracing objective play.", + "source": "generated" + }, + "PlantBombState::OnEnter": { + "text": "Begins the bot's bomb-planting behaviour and carries the string \"Plant bomb on floor\", indicating it settles on a spot to plant at. Hook it to observe or redirect where bots choose to plant; the placement checks themselves are unverified.", + "source": "generated" + }, + "PlantBombState::OnExit": { + "text": "Ends the bomb-planting behaviour, releasing whatever the state held while planting. The class is implied by the name, and no string anchor is present, so the cleanup is unverified.", + "source": "generated" + }, + "PlantBombState::OnUpdate": { + "text": "Advances the bomb-planting behaviour each update, holding the bot on the spot and carrying the plant through. The class is implied by the name, with no string anchor present, so the abort and completion conditions are unverified.", + "source": "generated" + }, + "PlantedC4sPointer": { + "text": "Reaches the server-side collection of planted C4 bombs, the natural handle for logic that reacts to live plants. Read from the name; no prototype is derived, so the container's owner and its shape are unverified.", + "source": "generated" + }, + "Plat_GetProcAddresses": { + "text": "Looks up function addresses in a loaded module, the tier0 platform-abstraction helper behind dynamic symbol resolution. Read from the name in libtier0; how lookups are specified and what happens on failure are unverified.", + "source": "generated" + }, + "PlayerMove": { + "text": "Drives a player's movement for a user command; its string anchor \"Can't move\" marks the case where movement is refused, such as a frozen or otherwise immobilised player. Also shipped as CCSPlayer_MovementServices::PlayerMove.", + "source": "generated" + }, + "PointerToGetInaccuracyFunction": { + "text": "Reaches a weapon's inaccuracy getter, the routine that yields the current spread value used for shot placement. Useful for accuracy tuning or telemetry; the reading is name-level, so the owning type and the units involved are unverified.", + "source": "generated" + }, + "PostPlayerMove": { + "text": "Performs the post-move phase of player movement processing \u2014 the name marks it as the \"post\" stage. What it reads or updates is not derived, so treat the stage boundary as a name-level reading.", + "source": "generated" + }, + "PostRopeAsyncJobs": { + "text": "Queues the asynchronous jobs that simulate ropes onto the physics job system. Read from the name in libvphysics2; the job payloads and how they are scheduled are unverified.", + "source": "generated" + }, + "ProcessMovement": { + "text": "Runs the server-side movement update for a player, carrying the profiling anchor PlayerMovementTraces. Also shipped as CCSPlayer_MovementServices::ProcessMove, which makes it the broadest hook available for replacing or instrumenting CS2 movement.", + "source": "generated" + }, + "ProcessSoundEvent": { + "text": "Processes one sound event, handling a single entry of sound-event data inside the sound system. Read from the name in libsoundsystem; the event's format and what processing produces are unverified.", + "source": "generated" + }, + "ProcessUsercmds": { + "text": "Consumes the user commands received for a player controller; its string anchor, \"%sRecv usercmd %d. Margin:%5.1fms net +%2d queue =%5.1f total\", shows it tracks each command's number alongside network margin, queue depth and total timing. The prototype is verified, and it also ships as CCSPlayerController::ProcessUserCmd, CCSPlayerController::ProcessUserCommands and CCSPlayerController::ProcessUsercmds.", + "source": "generated" + }, + "PulseAPIConvertArgumentsForCall": { + "text": "Converts the arguments of a Pulse API binding into the form the target call expects, and reports conversion problems per binding and per input parameter \u2014 its diagnostic quotes the binding name and the offending \"Inparam\". Valuable when debugging Pulse graph bindings; the conversion rules themselves are unverified.", + "source": "generated" + }, + "RandomFloatExp": { + "text": "Draws a random float with exponent-weighted rather than uniform distribution, for randomisation that should bias toward one end of a range. Read from the name; no prototype is derived, so the exact weighting and the random stream it uses are unverified.", + "source": "generated" + }, + "RandomInt": { + "text": "Returns a pseudo-random integer, presumably within a caller-supplied range. Read from the name; the generator it draws from and whether the bounds are inclusive are not established here.", + "source": "generated" + }, + "ReconnectGameInterface": { + "text": "Re-establishes the game module's interface links to the engine's app-system layer; the log APPSYSTEM: In ReconnectGameInterface(), tried to use different connection modes! shows it rejecting an attempt to switch connection modes partway. Useful context when engine interfaces are re-acquired, such as during a hot reload; which interfaces get rebound is not established.", + "source": "generated" + }, + "RecvServerBrowserPacket": { + "text": "Handles an inbound server-browser packet on the Steam networking sockets layer, the query traffic behind server-list entries and their advertised details. The reading comes from the name and its home in libsteamnetworkingsockets; what it parses and how it answers are not established.", + "source": "generated" + }, + "Reflection::AddEnumValue": { + "text": "Registers one named constant on an enum being described to the reflection system, so tools and serialization can resolve that value by name. Read from the name, and matched in libserver; the data does not establish how the value is encoded or which registration structure receives it.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name string for the `AnimParamType_t` animation-parameter type enum, the per-type form of the internal name helper. Read from the name and its template argument; the exact string produced and how reflection tables consume it are not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::AnimGraph::ParamType` attribute, which by its name declares the animgraph parameter type of a reflected member. Read from the name and template argument; the emitted string and the attribute's effect on animgraph tooling are not established here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::AnimGraph::ReplayInputProvider` attribute, which by its name marks a member as providing inputs for animgraph replay. Read from the name and template argument; what the attribute drives at runtime is not derived from this data.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::AnimGraph::UseReflectionEditor` attribute, which by its name routes a member's animgraph editing through the generic reflection editor. Read from the name and template argument; the emitted string and the editor behaviour behind it are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::Color` attribute, which by its name attaches a colour to a reflected member for display purposes. Read from the name and template argument; the string produced and how consumers interpret the colour are not established here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::Deprecated` attribute, which by its name flags a reflected member as obsolete. Useful when auditing which reflected fields Valve has retired; the emitted string and any enforcement behaviour are read from the name only, not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::Description` attribute, which by its name carries human-readable descriptive text for a reflected member. Read from the name and template argument; the string produced and where the description surfaces are not established by this data.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::FriendlyName` attribute, which by its name gives a reflected member a display label distinct from its code identifier. Read from the name and template argument; the emitted string and its consumers are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::Group` attribute, which by its name assigns a reflected member to a named grouping for organisation in tools. Read from the name and template argument; the string produced and how grouping is applied are not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::Icon` attribute, which by its name associates an icon with a reflected member. Read from the name and template argument; the emitted string and how the icon reference is resolved are not established here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::IsEnabled` attribute, which by its name controls whether a reflected member is active or editable. Read from the name and template argument; the string produced and the condition the attribute expresses are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::MotionMatching::UsesCustomCurrentValue` attribute, which by its name marks a motion-matching element as sourcing its current value through custom logic. Read from the name and template argument; the runtime effect on motion matching is not derived from this data.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::MotionMatching::UsesCustomSampleInterpolation` attribute, which by its name marks a motion-matching element as interpolating samples with custom logic. Read from the name and template argument; the emitted string and the interpolation behaviour behind it are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::ObjectColor` attribute, which by its name attaches a display colour to a reflected object rather than a single member. Read from the name and template argument; the string produced and its consumers are not established here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::ObjectGroup` attribute, which by its name places a reflected object into a named category. Read from the name and template argument; the emitted string and how the grouping is presented are not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::ObjectIcon` attribute, which by its name associates an icon with a reflected object. Read from the name and template argument; the string produced and how the icon reference resolves are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::ObjectName` attribute, which by its name gives a reflected object a display name. Read from the name and template argument; the emitted string and where the name is shown are not established by this data.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::ObjectUserData` attribute, which by its name carries arbitrary caller-defined data alongside a reflected object. Read from the name and template argument; the payload's shape and who reads it are not derived here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::AnimGraph::EditExpression` attribute, which by its name presents a member as an editable animgraph expression field. Read from the name and template argument; the emitted string and the editor widget behind it are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::AnimGraph::EditParameterValue` attribute, which by its name exposes an animgraph parameter's value for editing in the UI. Read from the name and template argument; the string produced and the widget behaviour are not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::AutoExpand` attribute, which by its name makes a reflected member's UI node open by default instead of collapsed. Read from the name and template argument; the emitted string and the exact UI treatment are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::AutoRefresh` attribute, which by its name causes a reflected member's editor display to refresh automatically. Read from the name and template argument; the refresh trigger and cadence are not established by this data.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::Edit` attribute, which by its name marks a reflected member as editable in tools. Read from the name and template argument; the string produced and the default widget chosen for it are not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::EditCheckBox` attribute, which by its name presents a reflected member as a checkbox in the editor. Read from the name and template argument; the emitted string and its handling by the UI layer are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::EditComboBox` attribute, which by its name presents a reflected member as a drop-down selection in the editor. Read from the name and template argument; where the list of choices comes from is not derived here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::EditLabel` attribute, which by its name gives a reflected member's editor row a label. Read from the name and template argument; the emitted string and how the label text is supplied are not established.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::EditSlider` attribute, which by its name presents a numeric reflected member as a slider in the editor. Read from the name and template argument; the range and step handling are not derived from this data.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::Embed` attribute, which by its name inlines a nested reflected object's fields into the parent's editor view. Read from the name and template argument; the emitted string and the nesting behaviour are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::Font` attribute, which by its name selects the font used when displaying a reflected member. Read from the name and template argument; the string produced and how the font is resolved are not established here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::HideAddRemoveButtons` attribute, which by its name suppresses the add and remove controls on a reflected collection's editor. Read from the name and template argument; the emitted string and the affected widgets are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::ReadOnly` attribute, which by its name shows a reflected member without allowing edits. Read from the name and template argument; whether the restriction is enforced beyond the display layer is not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the `Attribute::UI::SortPriority` attribute, which by its name orders a reflected member relative to its siblings in the editor. Read from the name and template argument; the sort direction and tie-breaking are not established by this data.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name string for the `BlendKeyType` animation blend-key enum, the per-type form of the internal name helper. Read from the name and template argument; the exact string produced and how reflection tables consume it are not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for the CAnimGraphSettingsGroup type, the identifier by which an animgraph settings group is exposed to reflection-driven tooling and data. Both the behaviour and what that type holds are read from the template name, so the exact text returned and its use sites are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CAnimTagBase, the base type behind animation tags, so reflected data and tools can refer to that type by name. Read from the template instantiation; the exact string produced, and what a modder can do with it, are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CAnimVariant, the animation system's mixed-type value container, giving reflection a name for parameter values whose type varies. Read from the template instantiation in libanimationsystem; the returned text and where it is consumed are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CAudioAnimTag, the animation tag type that ties audio to a point in a sequence. The reading comes from the template name alone, so the exact string and its consumers are unverified; its presence mainly tells you that type is reflected.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CBlendPoseOperation, the pose operation that blends poses together. Read from the template instantiation; the exact text returned is unverified, and the blending semantics attributed to that type are a name-level reading.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CCPPScriptComponentInstance, the animation component instance that carries native script-backed behaviour on a graph. Read from the template name; the returned string and what that component actually drives at runtime are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CChoreoPoseOperation, the pose operation associated with choreographed scene animation. Read from the template instantiation in libanimationsystem; the exact string and the operation's real inputs are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CCurrentRotationVelocityMetricEvaluator, a motion-matching metric evaluator whose name points at scoring candidates on present rotational velocity. Read from the template name; the returned text and the evaluator's actual scoring rule are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CDifferenceBlendPoseOperation, the pose operation that applies a difference between poses rather than a straight blend. Read from the template instantiation; the exact string and the operation's precise math are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CDistanceRemainingMetricEvaluator, a metric evaluator whose name points at scoring on distance still to travel toward a goal. Read from the template name; the returned string and the measured quantity are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CFetchCyclePoseOperation, the pose operation that fetches a pose at a cycle position within an animation. Read from the template instantiation; the exact string and how the cycle is supplied are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CFutureVelocityMetricEvaluator, a metric evaluator whose name points at scoring on predicted future velocity. Read from the template name in libanimationsystem; the returned text and the prediction horizon it uses are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CGlobalSymbol, the engine's interned string-symbol type, so reflected data can describe fields holding symbols. Read from the template instantiation; the exact string returned is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CLeafUpdateNode, an animgraph update node at the leaf of the node tree. Read from the template name; the returned string and the node's actual role in graph evaluation are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CMotionNode, an animgraph node whose name points at driving motion output. Read from the template instantiation; the exact string and what the node produces are unverified, so treat the motion reading as name-level.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CPairedSequenceComponentInstance, the component instance behind paired animations that run on two participants together. Read from the template name; the returned text and the pairing mechanics are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CPairedSequenceUpdateNode, the animgraph update node that plays a paired sequence. Read from the template instantiation in libanimationsystem; the exact string and the node's timing behaviour are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CPathMetricEvaluator, a metric evaluator whose name points at scoring motion candidates against a path. Read from the template name; the returned string and the path representation it reads are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CPoseOperation, the general pose-operation type that the more specific pose operations share a name root with. Read from the template instantiation; the exact string and that type's interface are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CRagdollComponentInstance, the animation component instance concerned with ragdoll behaviour on an animating entity. Read from the template name; the returned text and the component's actual physics handoff are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CSequenceUpdateNode, the animgraph update node that plays an animation sequence. Read from the template instantiation; the exact string and the node's playback controls are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CSequenceUpdateNodeBase, the shared base behind sequence-playing update nodes. Read from the template name; the returned string and what behaviour the base actually supplies are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CSingleFramePoseOperation, the pose operation that takes a single frame's pose rather than an animating range. Read from the template instantiation; the exact string and how the frame is chosen are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CStateMachineUpdateNode, the animgraph update node that runs a state machine over child states. Read from the template name in libanimationsystem; the returned text and the transition handling are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CStepsRemainingMetricEvaluator, a metric evaluator whose name points at scoring on footsteps left before a goal. Read from the template instantiation; the returned string and the counting rule are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CStopAtGoalUpdateNode, the animgraph update node concerned with bringing locomotion to a stop at a goal position. Read from the template name; the exact string and the stopping logic are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CUnaryUpdateNode, an animgraph update node that wraps a single child node. Read from the template instantiation; the returned string and what the wrapper does to its child's pose are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CUtlString, the engine's owning string container, so reflected data can describe string-valued fields. Read from the template instantiation; the exact text returned is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName>": { + "text": "Yields the reflection name for a CUtlVector of CGlobalSymbol, giving reflection a name for fields holding a list of interned symbols. Read from the template instantiation; the exact string returned is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName >>": { + "text": "Yields the reflection name for a CUtlVector of reference-counted CAnimComponentInstance pointers, naming the field shape used where a graph instance holds its component instances. Read from the template instantiation; the exact string and the ownership semantics are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName >>": { + "text": "Yields the reflection name for a CUtlVector of reference-counted CAnimMotorInstance pointers, naming the field shape used where motor instances are held as a list. Read from the template instantiation; the exact string and what a motor instance drives are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName > >": { + "text": "Yields the reflection name for a CUtlVector of reference-counted CAnimParameterInstance pointers, the field shape behind an animgraph's live parameter list. Read from the template instantiation; the exact string and how parameters are indexed are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName>": { + "text": "Yields the reflection name for a CUtlVector of CWeightPreview, naming a field that holds a list of weight-preview entries for reflection and tooling. Read from the template instantiation; the exact string and what CWeightPreview stores are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name for CWayPointHelperUpdateNode, an animgraph update node whose name points at assisting waypoint-following movement. Read from the template instantiation in libanimationsystem; the returned text and the node's actual steering role are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name text for the CWeightPreview type, letting the reflection layer identify that type by string when reflected animation data is described or serialized. Read from the templated name; the exact text produced and how it is obtained are not derived here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name text for the DampingSpeedFunction type, a damping-speed selector used by animation code, so reflected data and tooling can refer to it by string. Inferred from the templated name; the precise text and lookup mechanism are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Provides the reflection name text for the FacingMode type, which reflection-driven serialization and editor tooling use to refer to that facing setting by string. The reading comes from the templated name; the exact text it yields is not established by this data.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Provides the reflection name for the HSequence type, the animation sequence handle, so reflected members holding sequences can be described or serialized by type name. Read from the templated name; the exact text and where it is stored are not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IAnimComponentManagerInstance interface type for the reflection layer, so reflected animation data can refer to the component-manager instance type by string. Read from the templated name; the exact text produced is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IAnimNodeInstance interface type for reflection, letting runtime animation-graph node instances be identified by string in reflected or serialized data. Inferred from the templated name; no prototype is derived, so the exact text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IAnimParameter interface type for the reflection layer, so animation-graph parameter objects can be referred to by string in reflected data and editor tooling. Read from the templated name; the exact text is not established here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IAnimTag interface type for reflection, letting animation tags be identified by string when reflected data is described or serialized. Read from the templated name; the exact text produced is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IAudioAnimTag interface type for the reflection layer, so audio-related animation tags can be referenced by string in reflected data. Taken from the templated name; the exact text and its source are not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IBodyGroupAnimTag interface type for reflection, so body-group animation tags can be identified by string in reflected or serialized animation data. Read from the templated name; the exact text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IClothSettingsAnimTag interface type for reflection, so cloth-settings animation tags can be referenced by string when reflected data is inspected or written. Read from the templated name; the exact text is not established.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IEnumAnimParameter interface type for the reflection layer, covering enum-valued animation-graph parameters so they can be referred to by string. Read from the templated name; the exact text produced is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IMovementComponentInstance interface type for reflection, so the animation movement component can be identified by string in reflected data. Read from the templated name; the exact text is not derived here.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IPairedSequenceComponentInstance interface type for reflection, so the paired-sequence animation component can be referenced by string in reflected data and tooling. Read from the templated name; the exact text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Names the IRagdollAnimTag interface type for reflection, so ragdoll animation tags can be identified by string in reflected or serialized data. Read from the templated name; the exact text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Provides the reflection name for the LinearRootMotionBlendMode_t type, a linear root-motion blend mode setting, so it can be described by string in reflected animation data. Inferred from the templated name; the exact text is not established.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Provides the reflection name for the Reflection::CAttribute type, the attribute objects that annotate reflected members, so attributes themselves can be described by name. Read from the templated name; the exact text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Provides the reflection name for the Reflection::Object type, the reflected-object type of the reflection system itself, so it can be referenced by string like any other reflected type. Read from the templated name; the exact text is not derived.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Provides the reflection name for the ResetCycleOption type, an animation cycle-reset setting, so reflected data and tooling can refer to it by string. Inferred from the templated name; the exact text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Provides the reflection name for the SelectorTagBehavior_t type, a selector tag behavior setting used by animation code, so it can be described by string in reflected data. Inferred from the templated name; the exact text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Provides the reflection name for the primitive bool type, so reflected boolean members can be described by type name during serialization or inspection. Read from the templated name; the exact text produced is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Provides the reflection name for the primitive int type, so reflected integer members can be identified by type name in serialized or inspected data. Read from the templated name; the exact text produced is unverified.", + "source": "generated" + }, + "Reflection::SetEnumValue": { + "text": "Writes an enum-typed value into a reflected member through the reflection system, the route to change an enum setting by reflection rather than by direct field access. Read from the name; how the target member is addressed and how the value is supplied are not derived here.", + "source": "generated" + }, + "Reflection::SetRepeatedEnumValue": { + "text": "Writes an enum value into a repeated, multi-valued reflected member, covering enum arrays or lists rather than a single enum slot. Inferred from the name, where Repeated indicates a collection member; the addressing and element selection are not derived.", + "source": "generated" + }, + "RegisterConVar": { + "text": "Registers a console variable with the engine's convar system, emitting RegisterConVar: Unknown error registering convar \"%s\"! when registration fails. Worth knowing if you create convars from a plugin and need to recognise where that failure message originates; the validation it performs is not established.", + "source": "generated" + }, + "RemoveEntity": { + "text": "Removes an entity from the world, marking it for deletion. Also shipped as UTIL::Remove, the standard server-side entity kill used throughout gameplay code, which makes it a medium-confidence but natural hook for intercepting entity removal.", + "source": "generated" + }, + "ReservePlayerController": { + "text": "Reserves a player-controller slot for an incoming connection, logging ReservePlayerController reserving slot for new player [%llu] with the joining player's identifier. Useful when tracing exactly when a slot is claimed during connect; the reservation's lifetime and how it is released are not established.", + "source": "generated" + }, + "ResetBreakpadAppId": { + "text": "Resets the application id that the Breakpad crash reporter stamps onto generated crash dumps. Read from the name and its home in libengine2; the value it resets to, and whether it affects dump routing, are not established.", + "source": "generated" + }, + "RollPercentage": { + "text": "Performs a percentage-chance roll and reports whether it passed, the usual shape for probability-gated behaviour. Read from the name; the input scale (0-100 versus 0-1) and the random source behind it are not established.", + "source": "generated" + }, + "RunCommand": { + "text": "Processes a user command's movement input for a player, read from the name. It resolves to the same code as CCSPlayer_MovementServices::ProcessUserCmd, a medium-confidence match, so confirm the address against your own build before hooking it.", + "source": "generated" + }, + "RunScriptFunctionPointer": { + "text": "Invokes a script function through an already-resolved function pointer instead of a by-name lookup. The nearby string center_on_damage_point suggests use from script hooks that carry that parameter; argument marshalling and error behaviour are not established.", + "source": "generated" + }, + "SV_InstallHLTVStringTableMirrors": { + "text": "Installs mirrored copies of the networked string tables for the HLTV broadcast path, so relay/spectator streams carry their own table state. Read from the name and its home in libengine2; which tables are mirrored and when the mirrors are torn down are not established.", + "source": "generated" + }, + "SaveGame_SetLastSaveFile": { + "text": "Records the path of the most recent save file, logging SaveGame_SetLastSaveFile (changing from '%s' to '%s') as the stored value is replaced. Chiefly relevant to singleplayer-style save flow; who reads the stored path afterwards is not established.", + "source": "generated" + }, + "ScaleDamage": { + "text": "Applies a scaling factor to a damage amount before it lands, the hook point for damage modifiers. Read from the name; which modifiers it folds in, and whether it mutates a damage-info structure or hands back a value, are not established.", + "source": "generated" + }, + "ScriptFirstMoveChild": { + "text": "Script-exposed accessor for the first child entity in an entity's movement-parent hierarchy, the entry point for walking attached entities from VScript. Read from the name; what it yields when an entity has no children is not established.", + "source": "generated" + }, + "ScriptGetAbsOrigin": { + "text": "Script-exposed accessor returning an entity's absolute world-space origin rather than a parent-relative offset. Read from the name; whether the value reflects movement already applied within the current tick is not established.", + "source": "generated" + }, + "ScriptInputKill": { + "text": "Script binding that fires the Kill input on an entity, removing it from the world. Read from the name; whether removal is immediate or deferred, and what happens to parented children, are not established.", + "source": "generated" + }, + "ScriptNextMovePeer": { + "text": "Script-exposed accessor for the next sibling in an entity's movement-parent hierarchy, pairing with ScriptFirstMoveChild when iterating everything attached to a parent. Read from the name; the terminator it returns at the end of a sibling chain is not established.", + "source": "generated" + }, + "ScriptPrintMessageChatAll": { + "text": "Script binding that prints a message into the chat of all connected players, the script-side server-wide chat broadcast. Handy for announcements from VScript; formatting rules, colour-code handling, and localisation behaviour are not established.", + "source": "generated" + }, + "ScriptSetConVarDouble": { + "text": "Script binding that sets a console variable to a floating-point value. Use it when script code needs a fractional convar value; whether it honours protection flags such as cheat or replicated is not established.", + "source": "generated" + }, + "ScriptSetConVarNumber": { + "text": "Script binding that sets a console variable to a plain numeric value. Use it from VScript to drive gameplay convars at runtime; whether unknown or flag-protected convars are rejected is not established.", + "source": "generated" + }, + "ScriptSetConVarString": { + "text": "Script binding that sets a console variable to a string value. Use it from VScript for text-valued convars; how it treats an unknown convar name or a protected one is not established.", + "source": "generated" + }, + "ScriptSetModel": { + "text": "Script binding that assigns a model to an entity, swapping its visual and collision representation. Read from the name; whether it takes a model path or a precached index, and whether precaching is required first, are not established.", + "source": "generated" + }, + "ScriptSetOrigin": { + "text": "Script binding that places an entity at an absolute world position. Read from the name; whether it performs a full teleport with collision and parent-relative fixups, or a raw position write, is not established.", + "source": "generated" + }, + "ScriptSetSize": { + "text": "Sets an entity's collision bounds, the mins/maxs box that decides what it collides against. Read from the name and the CBaseModelEntity::SetCollisionBounds alias; no prototype is derived, so whether the visible model is affected or only the collision hull is unverified.", + "source": "generated" + }, + "ScriptVmKeyValueFromVariant": { + "text": "Converts a script VM variant into a KeyValue, logging ScriptVmKeyValueFromVariant failed to unpack parameter variant type %d when the variant's type cannot be unpacked. Relevant when script-to-engine parameters silently drop values; which variant types are supported is not established.", + "source": "generated" + }, + "Script_AddDamageType": { + "text": "Adds a damage-type flag to a script-exposed damage-info object while leaving existing flags in place. Read from the name and its pairing with Script_HasDamageType and Script_SetDamageType; the flag encoding and whether duplicates are ignored are not established.", + "source": "generated" + }, + "Script_GetAmmoType": { + "text": "Returns the ammo type recorded on a script-exposed damage or weapon object. Read from the name; whether the value is an index into an ammo-definition table or some other identifier is not established.", + "source": "generated" + }, + "Script_GetAttacker": { + "text": "Returns the entity credited as the attacker on a script-exposed damage-info object, the party that takes the kill or damage credit. Read from the name alongside Script_GetInflictor; what it yields for world or unattributed damage is not established.", + "source": "generated" + }, + "Script_GetInflictor": { + "text": "Returns the inflictor on a script-exposed damage-info object, the entity that physically delivered the damage, which can differ from the attacker. Read from the name alongside Script_GetAttacker; the exact split between the two in this build is not established.", + "source": "generated" + }, + "Script_HasDamageType": { + "text": "Tests whether a script-exposed damage-info object carries a given damage-type flag, the usual filter for script that should react only to certain damage classes. Read from the name; the flag values and whether several bits can be tested at once are not established.", + "source": "generated" + }, + "Script_SetAmmoType": { + "text": "Sets the ammo type on a script-exposed damage or weapon object, overwriting whatever was there. Read from the name and its pairing with Script_GetAmmoType; the identifier space it expects is not established.", + "source": "generated" + }, + "Script_SetAngularVelocity": { + "text": "Sets an entity's angular velocity from script, driving spin rather than translation. Read from the name; the units and axis convention, and its effect on non-physics entities, are not established.", + "source": "generated" + }, + "Script_SetAttacker": { + "text": "Sets the attacker on a script-exposed damage-info object, letting script reassign damage or kill credit before the damage resolves. Read from the name alongside Script_GetAttacker; whether a reassignment carries through to scoring is not established.", + "source": "generated" + }, + "Script_SetDamageType": { + "text": "Replaces the damage-type flags on a script-exposed damage-info object wholesale, in contrast to the additive Script_AddDamageType. Read from the name; the flag encoding and any validation of unknown bits are not established.", + "source": "generated" + }, + "Script_SetVelocity": { + "text": "Sets an entity's linear velocity from script as an outright overwrite rather than an added impulse. Read from the name; the units, and whether it wakes physics or clamps against movement limits, are not established.", + "source": "generated" + }, + "SendSnapshot_Job": { + "text": "A worker-job entry point that builds and sends a network snapshot destined for clients. Read from the name and its home in libengine2; what work unit it receives and its threading contract are not established.", + "source": "generated" + }, + "SendToServerConsole": { + "text": "Submits a command string to the server console for execution, the programmatic equivalent of typing at the console. Useful for driving commands that expose no direct API; the command source it executes under, and any permission filtering, are not established.", + "source": "generated" + }, + "ServiceDescriptor::DebugString": { + "text": "Formats a service descriptor into human-readable debug text, emitting a block that opens with \"service $0 {\". Handy when dumping registered services while diagnosing startup or wiring problems; which descriptor details appear is unverified.", + "source": "generated" + }, + "SetAbsOrigin": { + "text": "Places an entity at an absolute world-space position, the standard way to teleport something outright instead of nudging it. Read from the name and the CBaseEntity::SetAbsOrigin alias; no prototype is derived, so side effects such as collision or child-transform updates are unverified.", + "source": "generated" + }, + "SetAbsScale": { + "text": "Sets an entity's absolute, world-space scale factor, as opposed to a scale expressed relative to a parent. Read from the name; no prototype is derived, so the units and whether the change reaches parented children or collision bounds are unverified.", + "source": "generated" + }, + "SetAbsVelocity": { + "text": "Overwrites an entity's world-space velocity, useful for launch pads, knockback and boost effects where adjusting movement input is not enough. Read from the name and the CBaseEntity::SetAbsVelocity alias; no prototype is derived, so the exact update semantics are unverified.", + "source": "generated" + }, + "SetAnimClipByName": { + "text": "Selects an animation clip on an animating entity by its string name instead of an index, the convenient form for script or map-authored playback. The name is present verbatim as a string in libserver, which supports that reading; which entity types accept it is not established here.", + "source": "generated" + }, + "SetDamage": { + "text": "Sets the damage amount carried by a damage record before it is applied to a victim, the primary knob for scaling how much a hit hurts. Read from the name; no prototype is derived, so whether it writes a pending damage info structure or an entity's own damage property is unverified.", + "source": "generated" + }, + "SetDamageCustom": { + "text": "Sets the custom damage classifier on a damage record, the supplementary tag that accompanies the standard damage-type bits so game rules can distinguish specific causes of a kill. Read from the name; the accepted tag values and their meanings are not established by this data.", + "source": "generated" + }, + "SetDamageForce": { + "text": "Sets the force vector a damage event imparts, which is what drives ragdoll and physics knockback direction and strength. Read from the name; no prototype is derived, so the vector's coordinate frame and scaling relative to the damage amount are unverified.", + "source": "generated" + }, + "SetDamagePosition": { + "text": "Sets the world position at which a damage event is treated as having landed, the point used for impact effects, force application and directional hit feedback. Read from the name; this data does not establish the coordinate frame or which damage record receives the value.", + "source": "generated" + }, + "SetGroundEntity": { + "text": "Assigns the entity that a given entity is standing on, the state that governs whether it counts as grounded for movement and jumping. Read from the name and the CBaseEntity::SetGroundEntity alias; no prototype is derived, so clearing behaviour and accompanying flag changes are unverified.", + "source": "generated" + }, + "SetJointLimitAngles": { + "text": "Sets the angular limits of a physics joint or constraint, bounding how far the joined bodies may rotate before being clamped. The name appears verbatim as a string in libserver; the axis convention, units and whether limits are symmetric are not established here.", + "source": "generated" + }, + "SetJointLimitEnabled": { + "text": "Turns a physics joint's limit on or off, letting a constraint either swing freely or be clamped to its configured range such as the one SetJointLimitAngles writes. The name appears verbatim as a string; which limit kind it toggles is not established here.", + "source": "generated" + }, + "SetLabelTextFunctionPointer": { + "text": "Installs a callback that supplies a label's text, so the displayed string is produced on demand rather than stored as a fixed value. Read from the name; no prototype is derived, so the callback's contract and which label object it applies to are unverified.", + "source": "generated" + }, + "SetLocalScale": { + "text": "Sets an entity's scale in its own local space, relative to its parent rather than to the world. Read from the name; no prototype is derived, so whether it affects collision and hitboxes as well as rendering is unverified.", + "source": "generated" + }, + "SetMaterialGroup": { + "text": "Selects which material group a model renders with, the mechanism behind alternate skins and material variants baked into a model. Read from the name; whether the group is addressed by name or by index, and whether the choice is networked, are not established here.", + "source": "generated" + }, + "SetOrAddAttributeValueByName": { + "text": "Sets a named attribute's value on an entity's attribute list, creating the attribute when it is not already present. Read from the name and the CAttributeList::SetOrAddAttributeValueByName alias; no prototype is derived, so the value semantics and how the change propagates to the owning entity are unverified.", + "source": "generated" + }, + "SetOriginalDamage": { + "text": "Records the pre-mitigation damage value on a damage record, preserving the amount before armor, falloff or other reductions altered it so later logic can reference the original figure. Read from the name; which reductions are considered part of the original are not established here.", + "source": "generated" + }, + "SetParticleAlwaysSimulate": { + "text": "Flags a particle system to keep simulating even when it would ordinarily be skipped, for instance while off-screen or otherwise culled. Read from the name; no prototype is derived, so the exact culling behavior it overrides and its performance cost are unverified.", + "source": "generated" + }, + "SetParticleControlEnt": { + "text": "Binds a particle system's numbered control point to an entity, so the effect follows that entity's position and orientation as it moves. Read from the name; the control-point indexing, attachment options and fallback when the entity dies are not established here.", + "source": "generated" + }, + "SetPolymorphicPointer": { + "text": "Stores a pointer whose concrete type varies, together with the type information needed to interpret it later, the tagged-pointer setter generic containers and serialization rely on. Read from the name, which also appears verbatim as a string; the tag encoding is not established here.", + "source": "generated" + }, + "SetReportedPosition": { + "text": "Sets the position an entity reports outward, which may differ from its true simulated origin, useful where a displayed or networked location is deliberately decoupled from physics. Read from the name; this data does not establish which systems consume the reported value.", + "source": "generated" + }, + "SetSceneObjectAttributeFloat4": { + "text": "Sets a named four-component float attribute on a renderable scene object, the render-side channel for per-instance shader and material parameters such as tint or UV data. Read from the name; no prototype is derived, so the attribute naming scheme and valid ranges are unverified.", + "source": "generated" + }, + "SetSchemaHammerUniqueId": { + "text": "Writes the Hammer unique id, the map editor's per-entity identifier, into the entity's schema data so runtime code can correlate a spawned entity with its authored counterpart in the map source. Read from the name; the id's format and lifetime are not established here.", + "source": "generated" + }, + "ShakeRopes": { + "text": "Disturbs nearby rope and cable entities so they visibly sway, the effect an explosion or heavy impact would produce on hanging geometry. Read from the name; no prototype is derived, so the radius, strength and how affected ropes are chosen are unverified.", + "source": "generated" + }, + "SharedRandomFloat": { + "text": "Produces a random float from a seeded stream that server and client can each reproduce identically, so predicted results agree on both sides. Read from the name, which also appears verbatim as a string; the seeding inputs and range convention are not established here.", + "source": "generated" + }, + "SimulateUserCommands": { + "text": "Processes the user commands queued for a player, the per-tick input packets that drive that player's movement and actions. Read from the name, present verbatim as a string; no prototype is derived, so batching, tick budgeting and clamping behavior are unverified.", + "source": "generated" + }, + "SnapViewAngles": { + "text": "Forces a player pawn's view angles to a given orientation instantly, rather than letting the view turn there gradually. Also shipped as CBasePlayerPawn_SnapViewAngles, the same function; read from the name, so the angle source and whether client-side interpolation is suppressed remain unverified.", + "source": "generated" + }, + "SoundEmitterSystem::EmitSoundByHandle": { + "text": "Plays a sound entry through the sound emitter system using an already-resolved handle instead of a name lookup, in shared code from soundemittersystem.cpp. It also ships as CSoundEmitterSystem::EmitSound \u2014 the same function under both names \u2014 so hooking either intercepts server-side sound playback.", + "source": "generated" + }, + "SoundOpGameSystem::DoStartSoundEvent": { + "text": "Starts a soundevent in the sound-operator game system, logging \"DoStartSoundEvent(%s)\" with tick and curtime alongside the event name. That log line makes it the place to trace when a soundevent actually fires, useful for diagnosing missing or duplicated sounds.", + "source": "generated" + }, + "SoundOpGameSystem::SetSoundEventParamString": { + "text": "Sets a string parameter on a running soundevent, warning \"CSoundOpGameSystem::SetSoundEventParam: Failed soundevent param message to: %s\" when the parameter message cannot be delivered. Use it to change a live soundevent's text-valued inputs after it has started.", + "source": "generated" + }, + "SoundOpGameSystem::StartSoundEventString": { + "text": "Starts a soundevent identified by its name string, resolving the event from text rather than a precomputed handle. Read from the name \u2014 no string anchor or Valve text is present \u2014 so name resolution and failure behaviour are unverified.", + "source": "generated" + }, + "SoundOpGameSystem::StopSoundEvent": { + "text": "Stops a playing soundevent, the counterpart to starting one through this system. Read from the name, with no string anchor present, so whether it cuts immediately or lets the event release is unverified.", + "source": "generated" + }, + "SoundOpGameSystem::StopSoundEventFilter": { + "text": "Stops a soundevent for a filtered set of recipients rather than for everyone, so only selected clients have it silenced. Read from the name, with no string anchor present, so how the recipient filter is expressed is unverified.", + "source": "generated" + }, + "SpacePathfind_StringPull_FindLastVisiblePortal": { + "text": "Finds the last portal still visible from the current point while string-pulling a navigation path, letting a chain of portals be shortened toward a straight line. Read from the name and its diagnostic string, which warns that the start lies within a future block; the portal representation is not established here.", + "source": "generated" + }, + "SpawnGroupSpawnEntities": { + "text": "Spawns the entities belonging to a spawn group, the unit in which a map's or sub-level's entities are loaded, and reports how many were spawned and how long it took in milliseconds. That report is its own log string; how the group is identified is not established here.", + "source": "generated" + }, + "SpawnGroupUnloadingThink": { + "text": "Drives the periodic unload of a spawn group, logging \"SV: SpawnGroupUnloadingThink: UNLOAD START %s\" as the unload begins. The listed alias CTestPulseIO::InputVariantVector does not match that string, and this entry is name-only, so verify it against your build before use.", + "source": "generated" + }, + "SpeakDispatchResponse": { + "text": "Makes a speaker entity say a chosen response line, cancelling speech already in progress on that speaker so the new line can play. Its own log string states this, naming the speaker and the queued line; how the response is selected is not established here.", + "source": "generated" + }, + "SplitContext": { + "text": "Splits a delimited context string into its component parts, the key/value criteria text that AI and response systems carry around as a single string. Read from the name; the delimiter, the output container and whether keys and values are separated too are not established here.", + "source": "generated" + }, + "StateChanged": { + "text": "Signals that a tracked piece of state has changed, the notification hook a system exposes so cached or derived data can be brought up to date. The name indicates a change notification but not which state it concerns; the owning subsystem is not established here.", + "source": "generated" + }, + "StateTransition": { + "text": "Moves a player between named states in a state machine, changing which state is current. Its ShowStateTransitions diagnostic string logs the player entering a named state, which supports that reading; the set of states and the conditions permitting a transition are not established here.", + "source": "generated" + }, + "StitchPath": { + "text": "Joins path segments into one continuous route, splicing a newly computed portion onto an existing path, and validates the seam. Its string reports an incorrect ending when the join does not close properly; the path representation and the exact validity test are not established here.", + "source": "generated" + }, + "StudioModel::GetAttachment": { + "text": "Retrieves the current world position and orientation of an attachment point on a model, so you can place effects, weapons or props exactly where the model defines. Read from the name; no string anchor is present, so the exact transform produced is unverified.", + "source": "generated" + }, + "StudioModel::LookupAttachment": { + "text": "Resolves an attachment's name to the identifier the model uses for it, the lookup you do once and cache before querying that attachment. Read from the name; no string anchor is present, so behaviour for an unknown attachment name is unverified.", + "source": "generated" + }, + "TSListTests::CListOps::IsEmpty": { + "text": "Reports whether the list under test currently holds any elements, the usual guard before a pop in test code. The class grouping is implied by the name, and the slot is unbound, so how emptiness is sampled under concurrent writers is unverified.", + "source": "generated" + }, + "TSListTests::CListOps::Pop": { + "text": "Removes an element from the thread-safe list under test and hands it back to the caller. The class grouping is implied by the name, and the slot is unbound, so pop order and what happens on an empty list are unverified.", + "source": "generated" + }, + "TSListTests::CListOps::Push": { + "text": "Inserts an element into the thread-safe list being exercised by this test harness. The TSListTests::CListOps grouping is implied by the name, and the entry sits in an unbound vtable slot, so contention behaviour and where the element lands are unverified.", + "source": "generated" + }, + "TSListTests::CListOps::Validate": { + "text": "Checks the list's internal structure for consistency, the integrity pass a test harness runs after a batch of pushes and pops. The class grouping is implied by the name, and the slot is unbound, so what is checked and how failures surface are unverified.", + "source": "generated" + }, + "TSListTests::CQueueOps::IsEmpty": { + "text": "Reports whether the queue under test currently holds any elements. The class grouping is implied by the name, and the slot is unbound, so how emptiness is sampled while other threads are mutating the queue is unverified.", + "source": "generated" + }, + "TSListTests::CQueueOps::Pop": { + "text": "Dequeues an element from the thread-safe queue under test and returns it to the caller. The class grouping is implied by the name, and the slot is unbound, so ordering guarantees and empty-queue behaviour are unverified.", + "source": "generated" + }, + "TSListTests::CQueueOps::Push": { + "text": "Enqueues an element into the thread-safe queue being exercised by this test harness. The TSListTests::CQueueOps grouping is implied by the name, and the entry sits in an unbound vtable slot, so contention behaviour is unverified.", + "source": "generated" + }, + "TSListTests::CQueueOps::Validate": { + "text": "Checks the queue's internal structure for consistency, the integrity pass a test harness runs after a batch of enqueues and dequeues. The class grouping is implied by the name, and the slot is unbound, so the specific invariants tested are unverified.", + "source": "generated" + }, + "TeleportToPathNode": { + "text": "Teleports an entity straight to a node on its path, repositioning it at that waypoint instead of moving it there over time. Read from the name, present verbatim as a string; whether angles, velocity or path progress are also updated is not established here.", + "source": "generated" + }, + "TerminateRound": { + "text": "Ends the round in progress and applies its outcome, the usual way a mod forces a round to finish early. Read from the name and the CCSGameRules::TerminateRound alias; no prototype is derived, so the available outcome reasons and any delay handling are unverified.", + "source": "generated" + }, + "TestBoxHullForClipDir": { + "text": "Tests a box hull against geometry along a clipping direction to determine whether the hull is blocked that way, part of collision or movement clipping work. Its string reports an empty back polygon from the clip; the geometry source and result form are not established here.", + "source": "generated" + }, + "TestRaysToBoundaryZone": { + "text": "Casts rays toward a boundary zone and measures how many get through, reporting a raw pass figure, a grid pass figure and their ratio, a visibility or reachability probe against a play-area boundary. Those figures come from its own log string; the sampling pattern is not established here.", + "source": "generated" + }, + "Test_RandomPlayerPosition": { + "text": "A developer test entry point that picks or applies a random position for the player, and reports failure when there is no local player entity to act on. Read from the name and that message; what exactly it randomizes and its argument form are not established here.", + "source": "generated" + }, + "Think_LightStyleEvent": { + "text": "A think handler for an entity driving lightstyle events, running on the entity's periodic think to advance its light-style animation or trigger the next style change. Read from the name; no prototype is derived, so the think cadence and the owning entity type are unverified.", + "source": "generated" + }, + "TraceFunc": { + "text": "Runs a trace query against the world, in the form of a reusable tracing helper or callback hook. Read from the name; the data does not establish what geometry, mask, or filter it applies, so treat the exact trace semantics as unverified.", + "source": "generated" + }, + "TraceShape": { + "text": "Sweeps a collision shape through the world and reports what it hits, under the profiling label Physics/TraceShape (Server). Also shipped as CEngineTrace::TraceShape, the general-purpose collision query behind custom hitscan, placement checks, and line-of-sight tests.", + "source": "generated" + }, + "TriggerPush_Touch": { + "text": "Handles an entity touching a push trigger, applying the volume's push to whatever entered it. Read from the name alongside CTriggerPush and CBaseEntity among this batch's referenced classes; hook it to alter or suppress push volumes such as map jump pads and wind brushes.", + "source": "generated" + }, + "TryCreateBreakPieces": { + "text": "Attempts to spawn break-apart gib pieces for a breakable object, with the anchor OnOwnerTakeDamage_React_TryCreateBreakPieces tying the attempt to an owner taking damage. Useful when customizing debris from destructible props, though the conditions under which pieces are actually produced are not established here.", + "source": "generated" + }, + "TrySetupSolverData": { + "text": "Attempts to prepare the working data a solver operates on, bailing out when the setup cannot be completed, as the Try prefix and the matching TrySetupSolverData anchor indicate. Which solver it serves (physics, cloth, ragdoll) is not established by this data.", + "source": "generated" + }, + "UTIL::CreateEntityByName": { + "text": "Creates a server-side entity from its classname string, the standard entry point mods use to spawn something at runtime. It is also shipped as CBaseEntity::CreateEntityByName, CGameEntitySystem::CreateEntityByName and CreateEntityByName, which are the same function; the reading comes from the name, so keyvalue and spawn handling around it is unverified.", + "source": "generated" + }, + "UTIL::Remove": { + "text": "Deletes a server-side entity, the counterpart mods use to tear down something they created. It is also shipped as RemoveEntity, the same function under another name; read from the name, so whether deletion is immediate or deferred is unverified.", + "source": "generated" + }, + "UTIL_ClientPrintAll": { + "text": "Broadcasts a text message to connected players, the server-side helper for announcements that are not aimed at a single recipient. Read from the name; the print destination (chat, console, center, hint) and text formatting are not established here.", + "source": "generated" + }, + "UTIL_DispatchEffect": { + "text": "Fires a named visual or audio effect described by a CEffectData payload, the general server-side entry for impact, blood, and explosion-style effects. Which effect plays is chosen by the data supplied rather than by the function itself.", + "source": "generated" + }, + "UTIL_DispatchEffectFilter": { + "text": "Fires an effect described by CEffectData to a chosen recipient filter instead of broadcasting it. Use it when an effect should be visible to a subset of players, for example team-scoped or spectator-scoped feedback in a mod.", + "source": "generated" + }, + "UTIL_DispatchParticleEffectFilter_Attachment": { + "text": "Plays a particle system anchored to an entity attachment point, delivered to a chosen recipient filter, so the effect follows the model as it moves. The same code also ships under the name DispatchParticleEffect; use it for muzzle, hand, or prop-mounted effects.", + "source": "generated" + }, + "UTIL_DispatchParticleEffectFilter_Position": { + "text": "Plays a particle system at a world position for a chosen recipient filter, rather than attaching it to an entity. Use it for one-shot effects fixed in the map, such as markers, beacons, or ground impacts.", + "source": "generated" + }, + "UTIL_GetEconItemSchema": { + "text": "Provides access to the loaded economy item schema, the lookup that resolves weapon, skin, sticker, and cosmetic item definitions. Use it from server code when a mod needs item definition data rather than raw item indices.", + "source": "generated" + }, + "UTIL_GetGameSystemFactory": { + "text": "Looks up a game-system factory by name, the handle through which an engine game system is obtained. Read from the name; which registry it consults and how a missing system is reported are not established here.", + "source": "generated" + }, + "UTIL_RadioMessage": { + "text": "Sends a radio message, the canned callout players trigger, so it reaches its listeners. CCSPlayerController appears among this batch's referenced classes on the speaker side; use it to emit callouts programmatically, though the exact addressing rules are not established here.", + "source": "generated" + }, + "UTIL_SayText2Filter": { + "text": "Delivers a chat message to a chosen recipient filter in the SayText2 form, which carries a sender slot and parameter substitutions for templated lines. Use it for colored, localized, or per-player chat output from a mod.", + "source": "generated" + }, + "UTIL_SayTextFilter": { + "text": "Delivers a plain chat line to a chosen recipient filter. Use it for simple per-player or team-scoped chat output, without the sender and parameter structure that the UTIL_SayText2Filter name implies.", + "source": "generated" + }, + "UTIL_SetModel": { + "text": "Assigns a model to a model-bearing entity, the usual follow-up to creating one so it has geometry to draw and collide with. Read from the name and the CBaseModelEntity::SetModel alias; no prototype is derived, so precache requirements and bounds side effects are unverified.", + "source": "generated" + }, + "UnmountWorldVPK": { + "text": "Unmounts a world VPK archive, releasing packed map content that had been mounted. Read from the name; no prototype is derived, so which archive handle it takes and what it invalidates are unverified.", + "source": "generated" + }, + "UpdateQueryCache": { + "text": "Refreshes a cached set of query results so later lookups see current state, matching the UpdateQueryCache anchor. What is being cached, whether entities, visibility, or spatial partition results, is not established here.", + "source": "generated" + }, + "UseEntityState::GetName": { + "text": "Returns the identifying name of a use-entity state, with the string UseEntity present verbatim in libserver alongside it, tying it to the player's use-interaction state machine. Beyond supplying that label for debug or state reporting, no further purpose is established.", + "source": "generated" + }, + "UseEntityState::OnUpdate": { + "text": "Runs the per-update step for the player's use-entity state, advancing whatever the state tracks while the player is holding a use interaction. The UseEntityState class is implied by the name, and the slot is unbound, so update cadence and exit conditions are unverified.", + "source": "generated" + }, + "VScriptInitialization": { + "text": "Brings up the VScript scripting layer, the startup entry for script VM support in the server. Read from the name; relevant if a mod hooks or extends server-side scripting, though what it registers or binds is not established here.", + "source": "generated" + }, + "ValidateStringFormatSpecifiers": { + "text": "Checks a format string's specifiers for validity, guarding against malformed printf-style formats before they are consumed. Read from the name; useful context when tier0 logging or string helpers reject a format that looks correct.", + "source": "generated" + }, + "VfxInit": { + "text": "Initializes the vfx layer of the material system, the compiled shader and material effect machinery. Read from the name; what it allocates or registers is not established by this data.", + "source": "generated" + }, + "WaterMove": { + "text": "Runs the swimming branch of player movement, handling buoyancy and travel while submerged. Read from the name and Source-movement lineage; also shipped as CCSPlayer_MovementServices::WaterMove, the hook for changing water physics or swim speed.", + "source": "generated" + }, + "WriteDeltaEntities": { + "text": "Writes delta-compressed entity state into an outgoing network snapshot, the encoding of what changed for a client since its last acknowledged tick. Read from the name; useful when reasoning about networking cost, though the buffer and framing are unverified.", + "source": "generated" + }, + "WriteEnterPVS": { + "text": "Writes the network payload for an entity entering a client's PVS, the fuller state form sent when something becomes potentially visible to that client. Read from the name; relevant to mods that manipulate visibility or transmit rules.", + "source": "generated" + }, + "__RegisterGameEventListeners": { + "text": "Registers the server's game-event listeners so game events are delivered to their handlers. Read from the name; relevant to mods adding their own event hooks, though which events are covered is not established here.", + "source": "generated" + }, + "addEdge": { + "text": "Adds an edge to the working triangulation used while building Recast's detail navmesh; its anchor is the rcBuildPolyMeshDetail message about shrinking triangle count to a maximum. The same code also ships as rcBuildPolyMeshDetail, so this matters when investigating navmesh generation rather than gameplay.", + "source": "generated" + }, + "antlr3RecognitionExceptionNew": { + "text": "Creates a recognition-exception record for the ANTLR3 parser runtime, the error object produced when input fails to match a grammar rule. Read from the name; it is parser infrastructure, surfacing only when a grammar-driven parser in the server rejects input.", + "source": "generated" + }, + "buildNavigation": { + "text": "Drives navigation-mesh construction for a map, and its anchor shows it aborts with a failure message when the intermediate chunky triangle mesh cannot be built. Relevant when a custom map ends up with no usable bot navigation.", + "source": "generated" + }, + "google::protobuf::DynamicMessageFactory::GetPrototype": { + "text": "Supplies the shared default instance for a message type, the immutable template that runtime-built dynamic messages are copied from. The protobuf class is implied by the name; only a vtable slot is derived, so ownership and lifetime of the returned prototype are unverified.", + "source": "generated" + }, + "google::protobuf::DynamicMessageFactory::~DynamicMessageFactory": { + "text": "Tears down a dynamic message factory, releasing the prototypes and per-type data it constructed; prototypes it handed out die with it. The class is implied by the name, and only a vtable slot is derived, so exactly what is freed is unverified.", + "source": "generated" + }, + "google::protobuf::FatalException::what": { + "text": "Yields the human-readable text of a protobuf fatal error, which is what you log or surface when the library throws. The class is implied by the name; only a vtable slot is derived, so the message's storage and lifetime are unverified.", + "source": "generated" + }, + "google::protobuf::FatalException::~FatalException": { + "text": "Destroys a protobuf fatal-exception object and releases the error text and any state it carries. The class is implied by the name, and only a vtable slot is derived, so what it frees is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintBool": { + "text": "Formats a boolean field value for protobuf text-format output; override it to change how true and false are rendered in message dumps. The class is implied by the name, and only a vtable slot is derived, so the exact emitted text is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintBytes": { + "text": "Formats a bytes field value for text-format output, normally quoting and escaping non-printable octets so binary payloads survive as text. The class is implied by the name, and only a vtable slot is derived, so the escaping scheme is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintDouble": { + "text": "Renders a double-precision field value into text-format output; override it when you need different precision or notation in dumps. The class is implied by the name, and only a vtable slot is derived, so the default numeric formatting is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintEnum": { + "text": "Renders an enum field value in text-format output, deciding between the symbolic name and the raw numeric value. The class is implied by the name, and only a vtable slot is derived, so its handling of values outside the enum is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintFieldName": { + "text": "Emits the key portion of a field in text-format output; override it to relabel or requalify field names in dumps. The class is implied by the name, and only a vtable slot is derived, so the naming rules it applies are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintFloat": { + "text": "Renders a single-precision float field value into text-format output. The class is implied by the name, and only a vtable slot is derived, so the precision and rounding behaviour are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintInt32": { + "text": "Renders a signed 32-bit integer field value into text-format output; a hook point if you want hex or grouped digits instead of plain decimal. The class is implied by the name, and only a vtable slot is derived, so the default formatting is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintInt64": { + "text": "Renders a signed 64-bit integer field value into text-format output. The class is implied by the name, and only a vtable slot is derived, so the default formatting is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintMessageEnd": { + "text": "Writes the closing delimiter for a nested message during text-format printing, matching the brace or bracket style and line layout used at the start. The class is implied by the name, and only a vtable slot is derived, so the emitted text is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintMessageStart": { + "text": "Writes the opening delimiter and header for a nested submessage during text-format printing, where single-line versus multi-line layout is chosen. The class is implied by the name, and only a vtable slot is derived, so the emitted text is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintString": { + "text": "Renders a string field value for text-format output, normally quoting it and escaping characters that would break the format. The class is implied by the name, and only a vtable slot is derived, so the escaping rules are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintUInt32": { + "text": "Renders an unsigned 32-bit integer field value into text-format output. The class is implied by the name, and only a vtable slot is derived, so the default formatting is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintUInt64": { + "text": "Renders an unsigned 64-bit integer field value into text-format output. The class is implied by the name, and only a vtable slot is derived, so the default formatting is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::~FieldValuePrinter": { + "text": "Destroys a text-format value printer, releasing any state a custom printer holds; relevant if you install your own printer and hand ownership to the text-format machinery. The class is implied by the name, and only a vtable slot is derived, so what it frees is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::Parser::ParserImpl::ParserErrorCollector::AddError": { + "text": "Records a hard parse failure encountered while reading text-format protobuf input, collecting the diagnostic so a caller can report why the text would not parse. The class is implied by the name, and only a vtable slot is derived, so the message format and where it lands are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::Parser::ParserImpl::ParserErrorCollector::AddWarning": { + "text": "Records a non-fatal complaint about text-format protobuf input, such as suspicious but tolerated syntax, alongside the collected errors. The class is implied by the name, and only a vtable slot is derived, so the message format and destination are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::Parser::ParserImpl::ParserErrorCollector::~ParserErrorCollector": { + "text": "Destroys the text-format parser's diagnostic collector and releases the accumulated error and warning records. The class is implied by the name, and only a vtable slot is derived, so what it frees is unverified.", + "source": "generated" + }, + "google::protobuf::internal::ExtensionSet::flat_begin": { + "text": "Gives access to the start of the flat, small-size-optimised array an extension set uses to hold its extension entries, which is the entry point for walking extensions attached to a message. Read from the name and located by signature in libanimationsystem, so the iteration contract is unverified.", + "source": "generated" + }, + "google::protobuf::internal::ExtensionSet::flat_end": { + "text": "Gives the past-the-end position of the flat array an extension set uses for its extension entries, bounding a walk over those extensions. Read from the name and located by signature in libanimationsystem, so the iteration contract is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::BackUp": { + "text": "Rewinds a fixed-array input stream by a count of bytes so data already produced becomes available for reading again, the usual way a decoder returns bytes it did not consume. The class is implied by the name, and only a vtable slot is derived, so the accepted range is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::ByteCount": { + "text": "Reports how many bytes of the backing array have been consumed, useful for tracking position or measuring how much of a buffer a decode touched. The class is implied by the name, and only a vtable slot is derived, so the exact accounting is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::Next": { + "text": "Hands out a contiguous chunk of the backing array for reading, giving a zero-copy read over a buffer you already hold in memory. The class is implied by the name, and only a vtable slot is derived, so chunk sizing and end-of-data behaviour are unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::Skip": { + "text": "Advances the read position over a number of bytes without producing them, letting a decoder jump past fields it does not care about. The class is implied by the name, and only a vtable slot is derived, so clamping at the end of the array is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::~ArrayInputStream": { + "text": "Destroys a fixed-array input stream; the array itself belongs to the caller, so cleanup concerns only the stream's own bookkeeping. The class is implied by the name, and only a vtable slot is derived, so what it frees is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayOutputStream::BackUp": { + "text": "Gives unwritten bytes at the tail of the handed-out output buffer back to the stream, so the recorded written length counts only what you actually filled. The class is implied by the name, and only a vtable slot is derived, so the accepted range is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayOutputStream::ByteCount": { + "text": "Reports how many bytes have been written into the fixed output array, which is how you learn a serialised message's length. The class is implied by the name, and only a vtable slot is derived, so the exact accounting is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayOutputStream::Next": { + "text": "Hands out a writable chunk of the fixed output array, giving a zero-copy write path for serialising a message straight into a caller-owned buffer. The class is implied by the name, and only a vtable slot is derived, so chunk sizing and buffer-exhaustion behaviour are unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayOutputStream::~ArrayOutputStream": { + "text": "Destroys a fixed-array output stream; the target array is caller-owned, so cleanup concerns the stream's own bookkeeping. The class is implied by the name, and only a vtable slot is derived, so what it frees is unverified.", + "source": "generated" + }, + "google::protobuf::io::StringOutputStream::BackUp": { + "text": "Trims unused bytes off the tail of a string-backed output stream, so the string ends up sized to the data actually written. The class is implied by the name, and only a vtable slot is derived, so the accepted range is unverified.", + "source": "generated" + }, + "google::protobuf::io::StringOutputStream::ByteCount": { + "text": "Reports how many bytes have been written into the target string, giving the serialised length when a message is written into a string buffer. The class is implied by the name, and only a vtable slot is derived, so the exact accounting is unverified.", + "source": "generated" + }, + "google::protobuf::io::StringOutputStream::Next": { + "text": "Hands back the next writable chunk of a zero-copy output stream whose destination is a string, extending that buffer as serialization proceeds. StringOutputStream is implied by the name, not by the data, so the growth policy and chunk sizing are a name-level reading and unverified.", + "source": "generated" + }, + "google::protobuf::io::StringOutputStream::~StringOutputStream": { + "text": "Destroys a string-backed output stream, releasing whatever bookkeeping it held once writing into the string is finished. StringOutputStream is implied by the name rather than the data; as a destructor it is mainly of interest as a teardown hook point.", + "source": "generated" + }, + "google::protobuf::io::ZeroCopyOutputStream::AllowsAliasing": { + "text": "Reports whether this output stream accepts aliased data, meaning bytes referenced in place instead of copied into the stream. ZeroCopyOutputStream is implied by the name, not the data; useful when a writer must decide if it may hand over borrowed buffers, though the contract is a name-level reading.", + "source": "generated" + }, + "google::protobuf::io::ZeroCopyOutputStream::WriteAliasedRaw": { + "text": "Writes a raw block of bytes into the output stream by reference, avoiding a copy when the stream permits aliasing. ZeroCopyOutputStream is implied by the name, not the data, so the lifetime requirements on the caller's buffer are a name-level reading and unverified.", + "source": "generated" + }, + "int_err_get": { + "text": "Fetches the error-state record used by a bundled C error-reporting library, with the anchor naming err.c as the source file it was compiled from. Read from the name and anchor; this is library plumbing rather than gameplay-facing code.", + "source": "generated" + }, + "int_thread_get": { + "text": "Obtains the per-thread bookkeeping entry for that same err.c error-reporting code, per its int_thread_get anchor. Read from the name and anchor; it is infrastructure for thread-local error state, not something a gameplay mod would call.", + "source": "generated" + }, + "mergeAndFilterRegions": { + "text": "Merges undersized regions and filters out unusable ones while Recast partitions walkable area during navmesh generation. Its anchor is an out-of-memory report for the regions array, so this is a place where navmesh builds fail on large or dense maps.", + "source": "generated" + }, + "rcBuildCompactHeightfield": { + "text": "Converts a solid heightfield into Recast's compact heightfield, the neighbour-linked span representation used for walkable-area analysis. Its anchor is an out-of-memory report for the chf.areas allocation, marking it as a memory pressure point in navmesh generation.", + "source": "generated" + }, + "rcBuildContours": { + "text": "Traces contours around walkable regions in the compact heightfield, producing the region outlines used for polygon-mesh construction. Its anchor is an out-of-memory report for a hole buffer, so contour tracing is where navmesh builds can fail on complex geometry.", + "source": "generated" + }, + "rcBuildDistanceField": { + "text": "Computes a distance field over walkable spans, giving each span its distance to the nearest border so regions can be partitioned by watershed. Its anchor is an out-of-memory report for the destination buffer; relevant when diagnosing navmesh generation.", + "source": "generated" + }, + "rcBuildLayerRegions": { + "text": "Partitions walkable area into layered regions, the layer-based alternative for building navmesh regions on multi-level geometry. Its anchor is an out-of-memory report for a source buffer; which partitioning mode a given map build uses is not established here.", + "source": "generated" + }, + "rcBuildPolyMesh": { + "text": "Converts traced contours into the convex polygon mesh that forms the navmesh proper, including neighbour links between polygons, since its anchor reports an adjacency failure. Relevant when a map's generated navmesh comes out broken or empty.", + "source": "generated" + }, + "rcBuildPolyMeshDetail": { + "text": "Builds the height-sampled detail mesh over the polygon mesh so navmesh surfaces follow the terrain underneath instead of sitting flat. Its anchor is an out-of-memory report for a triangle buffer, and the same code also ships as addEdge.", + "source": "generated" + }, + "rcBuildRegions": { + "text": "Builds the walkable regions that navmesh generation is organised into, and warns through its own string 'rcBuildRegions: %d overlapping regions.' when the partition produces overlaps. The region-building role is read from the name and that anchor; the inputs, the partitioning method, and how a modder would trigger it are unverified.", + "source": "generated" + }, + "rcBuildRegionsMonotone": { + "text": "Builds navmesh regions using a monotone partitioning variant, and emits 'rcBuildRegionsMonotone: Out of memory 'src' (%d).' when its working buffer cannot be allocated \u2014 a useful marker when navmesh generation fails on large maps. The monotone reading comes from the name; its inputs and how its output differs are unverified.", + "source": "generated" + }, + "rcRasterizeTriangles": { + "text": "Rasterizes triangle geometry into the volumetric grid that navmesh generation works from, logging 'rcRasterizeTriangles: Out of memory.' when that allocation fails. The rasterization role is read from the name and anchor; the geometry format it accepts and the grid it writes into are unverified.", + "source": "generated" + }, + "snappy::ByteArraySource::Available": { + "text": "Reports how many bytes are still readable from a byte-array data source in the bundled snappy compression code. The snappy::ByteArraySource class is implied by the name, and the slot is unbound, so the exact remaining-byte accounting is unverified.", + "source": "generated" + }, + "snappy::ByteArraySource::Peek": { + "text": "Exposes the next bytes of a snappy byte-array source without consuming them, letting a reader inspect data before deciding to advance. The class is implied by the name, and the slot is unbound, so how much data one peek makes visible is unverified.", + "source": "generated" + }, + "snappy::ByteArraySource::Skip": { + "text": "Advances a snappy byte-array source past a run of bytes, discarding them rather than returning them. The class is implied by the name, and the slot is unbound, so behaviour when skipping past the end of the buffer is unverified.", + "source": "generated" + }, + "snappy::ByteArraySource::~ByteArraySource": { + "text": "Destroys a snappy byte-array source, releasing whatever the wrapper holds. The destructor role is implied by the name, and the slot is unbound, so whether it owns and frees the underlying buffer is unverified.", + "source": "generated" + }, + "snd_cast": { + "text": "Sound-subsystem function whose purpose is not established \u2014 the snd_cast name places it with audio, but 'cast' could mean a spatial trace, a type conversion, or a broadcast. Nothing else in the data narrows it, so confirm behaviour empirically before relying on it.", + "source": "generated" + } + } +} \ No newline at end of file diff --git a/mappings/semantics-dota2.json b/mappings/semantics-dota2.json new file mode 100644 index 0000000..9602332 --- /dev/null +++ b/mappings/semantics-dota2.json @@ -0,0 +1,12748 @@ +{ + "meta": { + "game": "dota2", + "source_build": "game", + "described": 3183, + "named": 5146, + "by_source": { + "derived": 1517, + "generated": 1666 + }, + "valve_described_elsewhere": 1963, + "note": "Keyed on NAME, which is stable across builds. Descriptions are SIGNATURE-FREE: arity, types and verdicts join from abi-.json at render time. Valve's own text always wins and is NOT duplicated here \u2014 see bindings-.json." + }, + "descriptions": { + "AddAegisPickup": { + "text": "Credits a player with picking up an Aegis, incrementing the per-player Aegis tally kept for match statistics. Read from the name; which record it writes and at what point in the pickup are not established here.", + "source": "generated" + }, + "AddClaimedFarm": { + "text": "Attributes an amount of farm to a player, accumulating the claimed-farm statistic used for farm-share and efficiency reporting. Read from the name; whether it counts gold, experience or creep kills, and when it is credited, is unverified.", + "source": "generated" + }, + "AddDamage": { + "text": "Accumulates a damage amount into a running total, the building block for damage-dealt and damage-taken bookkeeping. Read from the name; whose total it updates and what qualifies as damage are not established by this data.", + "source": "generated" + }, + "AddGoldSpentOnSupport": { + "text": "Adds to a player's tally of gold spent on support items such as wards and consumables, the figure surfaced in end-of-match support statistics. Name-level reading; which purchases qualify and where the tally lives are unverified.", + "source": "generated" + }, + "AddRunePickup": { + "text": "Records that a player collected a rune, incrementing the per-player rune-pickup count used for statistics. Read from the name; whether rune type is distinguished, and where the count is stored, is not established.", + "source": "generated" + }, + "AngerNearbyUnits": { + "text": "Provokes units within a radius of a point or entity so they acquire and attack a target, the aggro pull associated with creeps and neutral camps. Read from the name; the radius, filtering and target choice are unverified.", + "source": "generated" + }, + "AppendDataChannels": { + "text": "Adds animation data channels to a channel collection, the per-attribute streams (bone transforms, floats, flags) that animation data is written into. Read from the name and its animation-system home; the container it appends to and the channel kinds are unverified.", + "source": "generated" + }, + "AreUnitsSharedWithPlayerID": { + "text": "Tests whether a player's units are currently shared with the given player ID, the unit-sharing state behind allied control of another player's units. Read from the name; the direction of the query and how sharing is stored are unverified.", + "source": "generated" + }, + "AssignSharedChangeCallbackIndex": { + "text": "Assigns the index that identifies a shared change callback, the handle networking uses so one notification covers entries watching the same field change. Read from the name and its networking home; the allocation scheme and what the index keys into are unverified.", + "source": "generated" + }, + "AttackNoEarlierThan": { + "text": "Concerns the earliest time a unit is permitted to attack, the gate enforcing attack cooldown and swing timing. Read from the name; whether it sets or queries that time, and in what time units, is not established.", + "source": "generated" + }, + "AttackReady": { + "text": "Reports whether a unit's attack is currently able to fire, with cooldown elapsed and nothing blocking the swing. Read from the name; the specific conditions folded into readiness are not established by this data.", + "source": "generated" + }, + "BoundingRadius2D": { + "text": "Gives an entity's bounding radius projected onto the horizontal plane, the flat radius used for ground-plane range, overlap and selection checks. Read from the name; whether it is cached or derived from collision bounds is unverified.", + "source": "generated" + }, + "CAI_ChangeHintGroup::InputActivate": { + "text": "Handles the `Activate` entity-IO input on `CAI_ChangeHintGroup`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAggregateSceneObject::OnBeginRenderingFrame": { + "text": "Performs per-frame work on an aggregate scene object as a rendering frame begins, the point where batched scene geometry can refresh itself before drawing. Read from the name and its presence in libscenesystem; the exact per-frame work is unverified.", + "source": "generated" + }, + "CAmbientGeneric::InputFadeIn": { + "text": "Handles the `FadeIn` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputFadeOut": { + "text": "Handles the `FadeOut` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputPitch": { + "text": "Handles the `Pitch` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputPlaySound": { + "text": "Handles the `PlaySound` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputStopSound": { + "text": "Handles the `StopSound` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputToggleSound": { + "text": "Handles the `ToggleSound` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAmbientGeneric::InputVolume": { + "text": "Handles the `Volume` entity-IO input on `CAmbientGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CAnimGraphGameSystem::AnimTickUpdate": { + "text": "Advances animation-graph state on each animation tick, driving animgraph evaluation for the entities the game system tracks. Read from the name and its presence in libserver; the tick source and the scope of what it updates are unverified.", + "source": "generated" + }, + "CAnimationSystem::FrameUpdate": { + "text": "Steps the animation system forward for a frame, advancing animation state for that frame. The owning CAnimationSystem class is implied by the name rather than derived from the data, and the update's scope is unverified.", + "source": "generated" + }, + "CAnimationSystemUtils::CreateAnimationHelper": { + "text": "Creates an animation helper object, the utility handle a modder obtains before driving animation on a model. The CAnimationSystemUtils class is implied by the name; a prototype is derived, but what the helper wraps is unverified.", + "source": "generated" + }, + "CAnimationSystemUtils::DestroyAnimationHelper": { + "text": "Releases an animation helper obtained from this utility, freeing what it holds. The CAnimationSystemUtils class is implied by the name; pair it with CAnimationSystemUtils::CreateAnimationHelper so helpers are not leaked.", + "source": "generated" + }, + "CAnimationSystemUtils::~CAnimationSystemUtils": { + "text": "Destroys a CAnimationSystemUtils instance and tears down whatever the utility owns. The class is implied by the name; beyond ordinary destruction, no further purpose is established.", + "source": "generated" + }, + "CAppSystemDict::ConnectInterfaces": { + "text": "Supplies interfaces to the app-system dictionary so registered systems can resolve one another. Read from the name and its presence in libtier0; the exact wiring, and when it occurs, are unverified.", + "source": "generated" + }, + "CAppSystemDict::LoadSystemAndDependencies": { + "text": "Loads an app system together with the systems it depends on, bringing a module and its prerequisites into the dictionary in one operation. Read from the name and its presence in libengine2; which module identifiers it accepts, and how failures surface, are unverified.", + "source": "generated" + }, + "CAssetModifier::Compare": { + "text": "Compares one asset modifier against another, giving the equality or ordering test used to deduplicate or sort modifiers. Read from the name; a prototype is derived, but the comparison key is unverified.", + "source": "generated" + }, + "CAssetModifier::Init": { + "text": "Purpose is not established; the name indicates only that it initialises a CAssetModifier.", + "source": "generated" + }, + "CAssetModifier::Precache": { + "text": "Precaches the resources an asset modifier refers to, so they are resident rather than loaded on demand at use time. Read from the name and its presence in libserver; which assets are touched is unverified.", + "source": "generated" + }, + "CAsyncFileSystem::RunCallbackAndMarkComplete": { + "text": "Invokes the completion callback for an asynchronous file request and marks that request finished. Read from the name and its presence in libfilesystem_stdio; the callback contract and any threading rules are unverified.", + "source": "generated" + }, + "CAttributeContainer::NetworkVar_m_Item::NetworkStateChanged": { + "text": "Flags the container's m_Item field as dirty so the changed CEconItemView state replicates to clients; server-side writes to that field need it or clients keep showing stale item data. Read from the name and the m_Item schema field; a prototype is derived, though the dirty-bit mechanics are unverified.", + "source": "generated" + }, + "CBaseAnimatingController::DispatchAnimEvents": { + "text": "Fires the animation events reached by the controller's current sequence playback, the path by which anim-tagged events reach gameplay code. Read from the name together with m_flLastEventCycle and m_nResetEventsParity; the event payloads and firing conditions are unverified.", + "source": "generated" + }, + "CBaseClientUIEntity::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CBaseClientUIEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseClientUIEntity::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CBaseClientUIEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseCombatCharacter::InputSetRelationship": { + "text": "Handles the `SetRelationship` entity-IO input on `CBaseCombatCharacter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseEntity::PerformInvalidatePhysicsRecursive": { + "text": "Invalidates cached physics state on the entity and, per the name, recursively on its children, so stale absolute transforms and collision bounds are recomputed rather than reused - useful when a modder moves or reparents an entity. Read from the name alongside m_vecAbsVelocity and m_pCollision; no prototype is derived, so the exact scope and conditions are unverified.", + "source": "generated" + }, + "CBaseFileSystem::Close": { + "text": "Closes an open file handle and releases it. The CBaseFileSystem class is implied by the name; a prototype is derived, but the handle's lifetime rules are unverified.", + "source": "generated" + }, + "CBaseFileSystem::FileExists": { + "text": "Reports whether a file is present, the cheap existence check to use before opening a path. The CBaseFileSystem class is implied by the name; a prototype is derived, though search-path behaviour is unverified.", + "source": "generated" + }, + "CBaseFileSystem::FindFirst": { + "text": "Begins a directory search for files matching a pattern and yields the first match. Read from the name and its presence in libfilesystem_stdio; use it with CBaseFileSystem::FindNext to walk a wildcard listing.", + "source": "generated" + }, + "CBaseFileSystem::FindNext": { + "text": "Yields the next match in a directory search already begun, letting a mod walk a wildcard listing entry by entry. Read from the name and its presence in libfilesystem_stdio; use it with CBaseFileSystem::FindFirst, though the termination semantics are unverified.", + "source": "generated" + }, + "CBaseFileSystem::GetFileTime": { + "text": "Retrieves a file's timestamp, useful for cache invalidation or reload-on-change logic over mod assets. The CBaseFileSystem class is implied by the name; a prototype is derived, but the time base and units are unverified.", + "source": "generated" + }, + "CBaseFileSystem::IsOk": { + "text": "Reports whether an open file handle is still in a good state, the error check for a handle that may have hit end-of-file or an I/O failure. The CBaseFileSystem class is implied by the name; a prototype is derived, though what counts as not-ok is unverified.", + "source": "generated" + }, + "CBaseFileSystem::Open": { + "text": "Opens a file through the filesystem and yields a handle for subsequent access. The CBaseFileSystem class is implied by the name; no prototype is derived, so how paths and access modes are specified is unverified.", + "source": "generated" + }, + "CBaseFileSystem::Read": { + "text": "Reads bytes from an open file into memory. The CBaseFileSystem class is implied by the name; a prototype is derived, but buffering and partial-read behaviour are unverified.", + "source": "generated" + }, + "CBaseFileSystem::ReadEx": { + "text": "Reads from an open file with extended options beyond the plain read path, such as caller-controlled buffer handling. The CBaseFileSystem class is implied by the name; a prototype is derived, though what the extension actually provides is unverified.", + "source": "generated" + }, + "CBaseFileSystem::Seek": { + "text": "Moves the read/write position of an open file to a new offset, enabling random access instead of streaming from the start. The CBaseFileSystem class is implied by the name; a prototype is derived, but the accepted origin modes are unverified.", + "source": "generated" + }, + "CBaseFileSystem::Size": { + "text": "Reports the length of a file. The CBaseFileSystem class is implied by the name; no prototype is derived, so the unit and how the file is identified are unverified.", + "source": "generated" + }, + "CBaseFileSystem::Tell": { + "text": "Reports the current read/write position of an open file, the counterpart to CBaseFileSystem::Seek. The CBaseFileSystem class is implied by the name; a prototype is derived, though the offset's base is unverified.", + "source": "generated" + }, + "CBaseFileSystem::Write": { + "text": "Writes bytes to an open file. The CBaseFileSystem class is implied by the name; a prototype is derived, but flushing and partial-write behaviour are unverified.", + "source": "generated" + }, + "CBaseFilter::InputTestActivator": { + "text": "Handles the `TestActivator` entity-IO input on `CBaseFilter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseGameUIInputHandler::GetName": { + "text": "Purpose is not established beyond returning an identifying name for the handler. The CBaseGameUIInputHandler class is implied by the name, not derived from the data.", + "source": "generated" + }, + "CBaseGameUIInputHandler::HandleInputEvent": { + "text": "Handles a single game-UI input event, the point where a UI input handler consumes keyboard, mouse or controller input. The CBaseGameUIInputHandler class is implied by the name; whether a handler can swallow an event is unverified.", + "source": "generated" + }, + "CBasePlayerPawn::InputSetFogController": { + "text": "Handles the `SetFogController` entity-IO input on `CBasePlayerPawn`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePlayerPawn::InputSetHUDVisibility": { + "text": "Handles the `SetHUDVisibility` entity-IO input on `CBasePlayerPawn`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePlayerPawn::PhysicsSimulate": { + "text": "Runs a physics simulation step for a player pawn, advancing its movement and collision state. The CBasePlayerPawn class is implied by the name; relevant alongside m_pMovementServices, though the step's exact work is unverified.", + "source": "generated" + }, + "CBasePlayerWeapon::InputSetClipPrimary": { + "text": "Handles the `SetClipPrimary` entity-IO input on `CBasePlayerWeapon`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBasePlayerWeapon::InputSetClipSecondary": { + "text": "Handles the `SetClipSecondary` entity-IO input on `CBasePlayerWeapon`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseQueuedRenderable::Age": { + "text": "Deals with the age of a queued renderable, the staleness measure for how long a queued item has lived. The CBaseQueuedRenderable class is implied by the name; whether it reports age or advances it is unverified.", + "source": "generated" + }, + "CBaseQueuedRenderable::ShouldDestroy": { + "text": "Decides whether a queued renderable has outlived its usefulness and can be torn down. The CBaseQueuedRenderable class is implied by the name; the criteria, which may involve CBaseQueuedRenderable::Age, are unverified.", + "source": "generated" + }, + "CBaseTrigger::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputEndTouch": { + "text": "Handles the `EndTouch` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputStartTouch": { + "text": "Handles the `StartTouch` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBaseTrigger::InputTouchTest": { + "text": "Handles the `TouchTest` entity-IO input on `CBaseTrigger`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBeam::InputNoise": { + "text": "Handles the `Noise` entity-IO input on `CBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBeam::InputWidth": { + "text": "Handles the `Width` entity-IO input on `CBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBenchmarkService::Connect": { + "text": "Wires the benchmark service up to the interfaces it depends on as the service framework brings it online. Read from the name; the class is implied by the name, and no prototype is derived, so the inputs and any failure path are unverified.", + "source": "generated" + }, + "CBenchmarkService::Disconnect": { + "text": "Releases the interfaces the benchmark service acquired, unwinding it during service teardown. Read from the name; the class is implied by the name, and what it drops is unverified.", + "source": "generated" + }, + "CBenchmarkService::GetBuildType": { + "text": "Reports the build flavour the benchmark service identifies itself as, useful when a caller needs to distinguish builds while enumerating loaded services. Read from the name; the class is implied by the name, and the build-type values are unverified.", + "source": "generated" + }, + "CBenchmarkService::GetDependencies": { + "text": "Reports the other services the benchmark service requires before it can operate, which a service framework can consult when staging startup. Read from the name; the class is implied by the name, and the form of the dependency list is unverified.", + "source": "generated" + }, + "CBenchmarkService::GetName": { + "text": "Returns the benchmark service's registered name; beyond that identity accessor role, no purpose is established here. The class is implied by the name.", + "source": "generated" + }, + "CBenchmarkService::GetRenderingMultiplier": { + "text": "Reports the rendering multiplier the benchmark applies \u2014 a scale factor on render workload for a benchmark run. Read from the name; the class is implied by the name, so what the multiplier scales and where it is configured remain unverified.", + "source": "generated" + }, + "CBenchmarkService::GetServiceDependencies": { + "text": "Reports the services this one needs present, the service-level counterpart to its general dependency query. Read from the name; the class is implied by the name, and the returned container's form is unverified.", + "source": "generated" + }, + "CBenchmarkService::GetServiceIndex": { + "text": "Reports the index the service framework assigned to this benchmark service, the handle used to find it among registered services. Read from the name; the class is implied by the name, and the indexing scheme is unverified.", + "source": "generated" + }, + "CBenchmarkService::GetTier": { + "text": "Reports which initialisation tier the benchmark service belongs to, a grouping a framework can use when staging service startup. Read from the name; the class is implied by the name, and the tier values are unverified.", + "source": "generated" + }, + "CBenchmarkService::Init": { + "text": "Initialises the benchmark service; beyond that, no specific purpose is established from this data. The class is implied by the name.", + "source": "generated" + }, + "CBenchmarkService::IsActive": { + "text": "Reports whether the benchmark service is currently active \u2014 the query a modder would use before assuming benchmark behaviour is running. Read from the name; the class is implied by the name, and what the active state gates is unverified.", + "source": "generated" + }, + "CBenchmarkService::IsSingleton": { + "text": "Reports whether one shared instance of the benchmark service is expected rather than an instance per loop or session. Read from the name; the class is implied by the name, and how the answer is consumed is unverified.", + "source": "generated" + }, + "CBenchmarkService::OnLoopActivate": { + "text": "Handles the engine loop the benchmark service is attached to becoming active, the natural place for per-loop benchmark state to be established. Read from the name; the class is implied by the name, and what it touches is unverified.", + "source": "generated" + }, + "CBenchmarkService::OnLoopDeactivate": { + "text": "Handles the attached engine loop going inactive, where per-loop benchmark state would be torn down. Read from the name; the class is implied by the name, and the actual cleanup is unverified.", + "source": "generated" + }, + "CBenchmarkService::PreShutdown": { + "text": "Performs benchmark-service work that belongs before shutdown proper, such as quiescing in-flight state while other services still exist. Read from the name; the class is implied by the name, and the actual pre-shutdown work is unverified.", + "source": "generated" + }, + "CBenchmarkService::QueryInterface": { + "text": "Resolves a requested interface exposed by the benchmark service, the accessor a caller uses to obtain a specific interface from it. Read from the name; the class is implied by the name, and which interface identifiers are accepted is unverified.", + "source": "generated" + }, + "CBenchmarkService::Reconnect": { + "text": "Re-resolves an interface the benchmark service holds, for when that interface is swapped or reloaded underneath it. Read from the name; the class is implied by the name, and which interfaces participate is unverified.", + "source": "generated" + }, + "CBenchmarkService::RegisterEventMap": { + "text": "Registers the benchmark service's event handlers so it receives the events it subscribes to. Read from the name; the class is implied by the name, and the map's contents are unverified.", + "source": "generated" + }, + "CBenchmarkService::SetActive": { + "text": "Turns the benchmark service's active state on or off, the writer paired with its active-state query. Read from the name; the class is implied by the name, and the side effects of toggling are unverified.", + "source": "generated" + }, + "CBenchmarkService::SetName": { + "text": "Assigns the benchmark service's registered name. Read from the name; the class is implied by the name, and whether the string is copied or merely aliased is unverified.", + "source": "generated" + }, + "CBenchmarkService::SetServiceIndex": { + "text": "Stores the index the service framework assigns to this benchmark service, the write side of its index accessor. Read from the name; the class is implied by the name, and the indexing scheme is unverified.", + "source": "generated" + }, + "CBenchmarkService::ShouldActivate": { + "text": "Answers whether the benchmark service should be activated in the current context, letting a host skip it when benchmarking is not wanted. Read from the name; the class is implied by the name, so the conditions it tests are unverified.", + "source": "generated" + }, + "CBenchmarkService::Shutdown": { + "text": "Shuts the benchmark service down, releasing what it set up at initialisation. Read from the name; the class is implied by the name, and the specific teardown is unverified.", + "source": "generated" + }, + "CBenchmarkService::~CBenchmarkService": { + "text": "Destroys a benchmark service instance and frees what it owns. This is the class destructor; the class is implied by the name, and exactly what it releases is unverified.", + "source": "generated" + }, + "CBodyComponentBaseAnimating::ResetSequence": { + "text": "Restarts the animation sequence on an entity's animating body component, putting playback back to the sequence start. Read from the name and the component's m_animationController field; no prototype is derived, so the reset semantics \u2014 cycle, layers, animation events \u2014 are unverified.", + "source": "generated" + }, + "CBodyComponentBaseAnimating::SetPlaybackRate": { + "text": "Sets the playback rate of the animation on an entity's animating body component, the speed multiplier for its current sequence, so a mod can slow down or speed up an entity's animation. Read from the name and the component's m_animationController field; the scaling and any clamping are unverified.", + "source": "generated" + }, + "CBoneSetup::AllocateResult": { + "text": "Obtains the result buffer that a bone-setup pass writes its computed bone data into. Read from the name; the class is implied by the name, and the buffer's layout, pooling and lifetime are unverified.", + "source": "generated" + }, + "CBoneSetup::FreeResult": { + "text": "Releases a bone-setup result buffer, ending that result's lifetime and returning its storage. Read from the name; the class is implied by the name, and the ownership rules are unverified.", + "source": "generated" + }, + "CBoneSetup::GetCModel": { + "text": "Exposes the model the bone setup is operating on \u2014 the source of its skeleton and animation data. Read from the name; the class is implied by the name, and which model representation is handed out is unverified.", + "source": "generated" + }, + "CBoneSetup::GetPoseParameter": { + "text": "Reads one pose-parameter value driving the bone setup, the scalar that blends animation poses during evaluation. Read from the name; the class is implied by the name, and whether the value is normalised or in model units is unverified.", + "source": "generated" + }, + "CBoneSetup::GetPoseParameterArray": { + "text": "Exposes the bone setup's pose-parameter values together rather than one at a time, for code that reads or copies them in bulk. Read from the name; the class is implied by the name, and the array's length and ordering are unverified.", + "source": "generated" + }, + "CBoneSetup::GetRealtime": { + "text": "Supplies the real-time clock value the bone setup uses when evaluating time-dependent animation. Read from the name; the class is implied by the name, and the clock's origin and units are unverified.", + "source": "generated" + }, + "CBreakable::InputAddHealth": { + "text": "Handles the `AddHealth` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputBreak": { + "text": "Handles the `Break` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputRemoveHealth": { + "text": "Handles the `RemoveHealth` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputSetEnableBreaking": { + "text": "Handles the `SetEnableBreaking` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputSetEnableCollisions": { + "text": "Handles the `SetEnableCollisions` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputSetHealth": { + "text": "Handles the `SetHealth` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakable::InputSetMass": { + "text": "Handles the `SetMass` entity-IO input on `CBreakable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputAddHealth": { + "text": "Handles the `AddHealth` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputBreak": { + "text": "Handles the `Break` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputDisablePuntSound": { + "text": "Handles the `DisablePuntSound` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputEnablePuntSound": { + "text": "Handles the `EnablePuntSound` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputForceDrop": { + "text": "Handles the `ForceDrop` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputRemoveHealth": { + "text": "Handles the `RemoveHealth` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputSetEnableBreaking": { + "text": "Handles the `SetEnableBreaking` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputSetEnableCollisions": { + "text": "Handles the `SetEnableCollisions` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputSetHealth": { + "text": "Handles the `SetHealth` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBreakableProp::InputSetNavIgnore": { + "text": "Handles the `SetNavIgnore` entity-IO input on `CBreakableProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CBugService::OnFrameBoundary": { + "text": "Handles the frame boundary for the bug-reporting service, the per-frame point where bug-report capture or state sampling would be driven. Read from the name; the class is implied by the name, and what it samples or submits is unverified.", + "source": "generated" + }, + "CCallResult, SteamUGCQueryCompleted_t>::GetCallbackSizeBytes": { + "text": "Reports how many bytes a SteamUGCQueryCompleted_t result payload occupies, so the Steam callback machinery knows how much data to hand across when a workshop query finishes. Read from the name; useful when hooking or forwarding UGC query completions.", + "source": "generated" + }, + "CCallResult, SteamUGCQueryCompleted_t>::Run": { + "text": "Its anchored string, 'UGC DownloadItemResult_t callback for unexpected ID %llu!', shows this handles delivery of a finished Steam UGC result and complains when one arrives for an item ID it does not recognise. Together with the name, that indicates completion handling for a queued CJobCallResult; exact conditions are unverified.", + "source": "generated" + }, + "CCallResult::GetCallbackSizeBytes": { + "text": "Reports the byte size of the HTTPRequestCompleted_t payload the Steam callback layer moves when a script-issued HTTP request finishes. Read from the name; relevant when marshalling or re-dispatching HTTP results to script.", + "source": "generated" + }, + "CCallResult::Run": { + "text": "Handles completion of a CScriptHTTPRequest, delivering the HTTPRequestCompleted_t result to the script request that issued it. A string reachable here, 'PrecacheResource must be passed a valid precache context!', fits precaching rather than HTTP, so treat that anchor as shared or inlined code and the name as the better guide.", + "source": "generated" + }, + "CChangeLevel::InputChangeLevel": { + "text": "Handles the `ChangeLevel` entity-IO input on `CChangeLevel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CClientFrame::IsMemPoolAllocated": { + "text": "Reports whether this client frame came from a memory pool rather than the general heap, a guard before deciding how to release it. Membership in CClientFrame is implied by the name; the vtable slot is unbound, so the owning class is not established by the data.", + "source": "generated" + }, + "CClientFrame::~CClientFrame": { + "text": "Destructor for a per-client frame record, releasing whatever buffers the frame holds when the server retires it. Ownership by CClientFrame is implied by the name; the slot is unbound, so that association is unverified.", + "source": "generated" + }, + "CClientFrameManager::~CClientFrameManager": { + "text": "Destructor for the manager that owns a client's frame history, tearing down the frames it still holds at shutdown or disconnect. Ownership by CClientFrameManager is implied by the name; the slot is unbound, so what it frees is unverified.", + "source": "generated" + }, + "CCodeResourceManifestManager::GetNamedManifestResources": { + "text": "Fetches the resources belonging to a named code-resource manifest group, letting callers enumerate what that manifest declares. The owning class is implied by the name; the slot is unbound, so the lookup key and result form are unverified.", + "source": "generated" + }, + "CCodeResourceManifestManager::IsResourceManifestGroupKnown": { + "text": "Answers whether a given resource-manifest group is registered with the manager \u2014 an existence check before asking for its contents. Ownership by CCodeResourceManifestManager is implied by the name; the slot is unbound, so the key format is unverified.", + "source": "generated" + }, + "CColorCorrection::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CColorCorrection`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CColorCorrection::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CColorCorrection`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CColorCorrection::InputSetFadeInDuration": { + "text": "Handles the `SetFadeInDuration` entity-IO input on `CColorCorrection`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CColorCorrection::InputSetFadeOutDuration": { + "text": "Handles the `SetFadeOutDuration` entity-IO input on `CColorCorrection`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCommentaryAuto::InputMultiplayerSpawned": { + "text": "Handles the `MultiplayerSpawned` entity-IO input on `CCommentaryAuto`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCompileTargetExprStackMachineBuilder::AddBoolLiteral": { + "text": "Appends a boolean constant to the expression program the builder is assembling, so evaluation yields that literal value. The builder class is implied by the name; the slot is unbound, so the literal's encoding is unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddElementAccess": { + "text": "Adds an element or index access step to the expression program under construction, as in indexing an array or keyed container. Ownership by CCompileTargetExprStackMachineBuilder is implied by the name; the slot is unbound, so what it indexes and how are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddFloatLiteral": { + "text": "Appends a floating-point constant to the expression program being compiled. The builder class is implied by the name; the slot is unbound, so the literal's storage and any constant folding are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddFunctionCall": { + "text": "Adds a function-call node to the expression program, so the compiled expression can reference a named routine at evaluation time. The builder class is implied by the name; the slot is unbound, so callee resolution and argument handling are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddIntLiteral": { + "text": "Appends an integer constant to the expression program being compiled. The builder class is implied by the name; the slot is unbound, so the literal's width and encoding are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddVariableExistenceLookup": { + "text": "Adds a test for whether a named variable is present in the evaluation context, rather than a read of its value \u2014 the compiled form of an 'is defined' check. The builder class is implied by the name; the slot is unbound, so naming and scope rules are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::AddVariableLookup": { + "text": "Adds a read of a named variable to the expression program, so evaluation resolves that name against its context. Ownership by CCompileTargetExprStackMachineBuilder is implied by the name; the slot is unbound, so the resolution scheme is unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::ReportParseError": { + "text": "Records a parse failure hit while building an expression, giving callers a diagnostic instead of a silently broken program. The builder class is implied by the name; the slot is unbound, so message format and resulting error state are unverified.", + "source": "generated" + }, + "CCompileTargetExprStackMachineBuilder::~CCompileTargetExprStackMachineBuilder": { + "text": "Destructor for the expression stack-machine builder, releasing the program it assembled and its scratch storage. Ownership by CCompileTargetExprStackMachineBuilder is implied by the name; the slot is unbound, so what it owns and frees is unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::CanEncode": { + "text": "Tests whether a given rotation track can be represented in this compressed quaternion format \u2014 the gate before selecting it for an animation channel. Ownership by CCompressedAnimQuaternion is implied by the name; the slot is unbound, so the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::CreateContainer": { + "text": "Allocates the backing container that holds compressed quaternion animation data for a track. The codec class is implied by the name; the slot is unbound, so the container's layout and sizing inputs are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::DecodeFrame": { + "text": "Decompresses one frame of rotation data from a compressed quaternion track, producing the usable quaternion for that time sample. The codec class is implied by the name; the slot is unbound, so frame indexing and output destination are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::DecodeSize": { + "text": "Reports how much room decoded output requires for this compressed quaternion data, so callers can size a destination buffer. The codec class is implied by the name; the slot is unbound, so whether it counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::DeswizzleAndBlendContainer": { + "text": "Unpacks swizzled compressed quaternion data and blends it against another pose in a single pass, the shape of work done when sampling between animation frames. The codec class is implied by the name; the slot is unbound, so blend weighting and data layout are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::DeswizzleContainer": { + "text": "Unpacks a swizzled compressed quaternion container into straight per-track rotation data, without any blending step. The codec class is implied by the name; the slot is unbound, so source layout and destination form are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::GetFieldType": { + "text": "Reports which animation field this codec handles \u2014 rotation, per the quaternion in its name \u2014 letting the animation system match codecs to channels. Ownership by CCompressedAnimQuaternion is implied by the name; the slot is unbound, so the enumeration values are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::GetFlags": { + "text": "Reports the codec's behaviour or capability flags, which the animation system consults when deciding how a compressed track may be used. The codec class is implied by the name; the slot is unbound, so individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::GetName": { + "text": "Supplies the codec's identifying name; beyond that, purpose is not established. Ownership by CCompressedAnimQuaternion is implied by the name.", + "source": "generated" + }, + "CCompressedAnimQuaternion::GetSizeof": { + "text": "Reports the in-memory size of the compressed quaternion codec object, the kind of value used when allocating or copying codec instances generically. The codec class is implied by the name; the slot is unbound, so exactly what is measured is unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::Instantiate": { + "text": "Brings up a working instance of the compressed quaternion codec, readying it for encode or decode use. The codec class is implied by the name; the slot is unbound, so the initialisation inputs are unverified.", + "source": "generated" + }, + "CCompressedAnimQuaternion::~CCompressedAnimQuaternion": { + "text": "Destructor for the compressed quaternion codec, freeing its container and any decode scratch storage. Ownership by CCompressedAnimQuaternion is implied by the name; the slot is unbound, so what it owns is unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::CanEncode": { + "text": "Reports whether a given vector3 animation channel can be represented in this compressed form, so a caller can fall back to another codec when it cannot. Class CCompressedAnimVector3 is implied by the name; no prototype is derived, so the inputs and the rejection criteria are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::CreateContainer": { + "text": "Allocates the storage container that holds this codec's compressed vector3 animation data. Class CCompressedAnimVector3 is implied by the name; the container's memory layout and ownership rules are not established by this data.", + "source": "generated" + }, + "CCompressedAnimVector3::DecodeFrame": { + "text": "Decompresses one frame's worth of vector3 values out of this codec's compressed data into usable output. Class CCompressedAnimVector3 is implied by the name, and the frame indexing scheme and output destination are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::DecodeSize": { + "text": "Reports the size of the decoded vector3 data this codec produces, which a caller uses to size a destination buffer. Class CCompressedAnimVector3 is implied by the name; no prototype is derived, so whether the figure counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks the codec's interleaved (swizzled) compressed vector3 container back into per-element order while blending the result against another pose or frame by weight. Class CCompressedAnimVector3 is implied by the name; no prototype is derived, so the weighting and the operand roles are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::DeswizzleContainer": { + "text": "Unpacks the codec's interleaved (swizzled) compressed vector3 container into straight per-element output, without the blending step its sibling name advertises. Class CCompressedAnimVector3 is implied by the name; no prototype is derived, so the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::GetFieldType": { + "text": "Reports which animation field type this codec handles, a vector3 channel per the class name. Class CCompressedAnimVector3 is implied by the name; useful when matching a codec against an animation channel's data type.", + "source": "generated" + }, + "CCompressedAnimVector3::GetFlags": { + "text": "Returns the codec's capability and behaviour flag bits, which a caller inspects to learn what this compression supports. Class CCompressedAnimVector3 is implied by the name, and the meaning of individual flag values is not established here.", + "source": "generated" + }, + "CCompressedAnimVector3::GetName": { + "text": "Returns this codec's identifying name string; beyond that, a purpose is not established. Class CCompressedAnimVector3 is implied by the name.", + "source": "generated" + }, + "CCompressedAnimVector3::GetSizeof": { + "text": "Reports the in-memory size of this codec's compressed vector3 element or container, for allocation and stride arithmetic. Class CCompressedAnimVector3 is implied by the name; no prototype is derived, so exactly which object is being measured is unverified.", + "source": "generated" + }, + "CCompressedAnimVector3::Instantiate": { + "text": "Constructs a live instance of this vector3 compression codec for animation decoding to work through. Class CCompressedAnimVector3 is implied by the name, and where the resulting instance is stored is not established by this data.", + "source": "generated" + }, + "CCompressedAnimVector3::~CCompressedAnimVector3": { + "text": "Destroys a codec instance and releases the compressed vector3 storage it owns. Class CCompressedAnimVector3 is implied by the name; a modder hooking this gets object teardown rather than animation logic.", + "source": "generated" + }, + "CCompressedDeltaVector3::CanEncode": { + "text": "Reports whether a given vector3 animation channel can be represented as this delta (difference) encoding, letting a caller choose another codec when it cannot. Class CCompressedDeltaVector3 is implied by the name; no prototype is derived, so the inputs and acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedDeltaVector3::CreateContainer": { + "text": "Allocates the storage container that holds this codec's delta-encoded vector3 animation data. Class CCompressedDeltaVector3 is implied by the name; the container's memory layout and ownership rules are not established by this data.", + "source": "generated" + }, + "CCompressedDeltaVector3::DecodeFrame": { + "text": "Reconstructs one frame of vector3 values from delta-encoded storage, turning recorded differences back into usable values. Class CCompressedDeltaVector3 is implied by the name, and the frame indexing scheme and output destination are unverified.", + "source": "generated" + }, + "CCompressedDeltaVector3::DecodeSize": { + "text": "Reports the size of the decoded vector3 output this delta codec produces, which a caller uses to size a destination buffer. Class CCompressedDeltaVector3 is implied by the name; no prototype is derived, so whether the figure counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedDeltaVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks the interleaved (swizzled) delta-encoded vector3 container into per-element order while blending the result against another pose or frame by weight. Class CCompressedDeltaVector3 is implied by the name; no prototype is derived, so the weighting and the operand roles are unverified.", + "source": "generated" + }, + "CCompressedDeltaVector3::DeswizzleContainer": { + "text": "Unpacks the interleaved (swizzled) delta-encoded vector3 container into straight per-element output, without the blending step its sibling name advertises. Class CCompressedDeltaVector3 is implied by the name; no prototype is derived, so the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedDeltaVector3::GetFieldType": { + "text": "Reports which animation field type this codec handles, a vector3 channel per the class name. Class CCompressedDeltaVector3 is implied by the name; useful when matching a codec against an animation channel's data type.", + "source": "generated" + }, + "CCompressedDeltaVector3::GetFlags": { + "text": "Returns the codec's capability and behaviour flag bits, which a caller inspects to learn what this delta compression supports. Class CCompressedDeltaVector3 is implied by the name, and the meaning of individual flag values is not established here.", + "source": "generated" + }, + "CCompressedDeltaVector3::GetName": { + "text": "Returns this codec's identifying name string; beyond that, a purpose is not established. Class CCompressedDeltaVector3 is implied by the name.", + "source": "generated" + }, + "CCompressedDeltaVector3::GetSizeof": { + "text": "Reports the in-memory size of this codec's delta-encoded vector3 element or container, for allocation and stride arithmetic. Class CCompressedDeltaVector3 is implied by the name; no prototype is derived, so exactly which object is being measured is unverified.", + "source": "generated" + }, + "CCompressedDeltaVector3::Instantiate": { + "text": "Constructs a live instance of this delta vector3 compression codec for animation decoding to work through. Class CCompressedDeltaVector3 is implied by the name, and where the resulting instance is stored is not established by this data.", + "source": "generated" + }, + "CCompressedDeltaVector3::~CCompressedDeltaVector3": { + "text": "Destroys a codec instance and releases the delta-encoded vector3 storage it owns. Class CCompressedDeltaVector3 is implied by the name; a modder hooking this gets object teardown rather than animation logic.", + "source": "generated" + }, + "CCompressedFullBool::CanEncode": { + "text": "Tests whether this codec is able to encode the data it is handed, so selection code can reject a boolean-valued channel it cannot represent. The CCompressedFullBool class is implied by the name; the inputs examined and the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedFullBool::CreateContainer": { + "text": "Creates the storage container that holds this codec's compressed boolean data. The CCompressedFullBool class is implied by the name; the container's layout and who owns the allocation are not established here.", + "source": "generated" + }, + "CCompressedFullBool::DecodeFrame": { + "text": "Decodes a single frame of boolean values out of compressed storage into caller-supplied output, for readers that want one sample rather than a whole container. The CCompressedFullBool class is implied by the name; the buffers involved and the frame indexing are unverified.", + "source": "generated" + }, + "CCompressedFullBool::DecodeSize": { + "text": "Reports how much space decoding this compressed boolean data requires, letting callers size an output buffer up front. The CCompressedFullBool class is implied by the name; whether the figure counts bytes or elements is not established.", + "source": "generated" + }, + "CCompressedFullBool::DeswizzleAndBlendContainer": { + "text": "Unpacks a compressed boolean container out of its interleaved storage order while blending the result against another set of values, the combined form of plain container deswizzling. The CCompressedFullBool class is implied by the name; the blend weighting and the roles of each operand are unverified.", + "source": "generated" + }, + "CCompressedFullBool::DeswizzleContainer": { + "text": "Unpacks a compressed boolean container from its interleaved storage order into straight per-element output. The CCompressedFullBool class is implied by the name; the exact packing order it reverses is not established by this data.", + "source": "generated" + }, + "CCompressedFullBool::GetFieldType": { + "text": "Reports the field-type identifier this codec handles, marking it as the full-precision boolean encoding to code that picks a codec by data type. The CCompressedFullBool class is implied by the name; the identifier's enumeration and values are not established.", + "source": "generated" + }, + "CCompressedFullBool::GetFlags": { + "text": "Reports the flags this codec advertises about its own encoding behaviour, which callers consult when deciding how the compressed boolean data may be used. The CCompressedFullBool class is implied by the name; the individual flag bits and their meanings are not established.", + "source": "generated" + }, + "CCompressedFullBool::GetName": { + "text": "Supplies this codec's name for identification, logging, or tooling that lists available compression types. The CCompressedFullBool class is implied by the name; beyond producing a name, no further purpose is established.", + "source": "generated" + }, + "CCompressedFullBool::GetSizeof": { + "text": "Reports the size associated with this codec, the figure a caller needs to stride through or allocate its compressed boolean storage. The CCompressedFullBool class is implied by the name; which object or element the size measures is not established.", + "source": "generated" + }, + "CCompressedFullBool::Instantiate": { + "text": "Brings a full-precision boolean codec instance into existence, the hook to use when you need a working encoder or decoder of this type. The CCompressedFullBool class is implied by the name; where the instance is placed and how long it lives are unverified.", + "source": "generated" + }, + "CCompressedFullBool::~CCompressedFullBool": { + "text": "Tears down a full-precision boolean codec instance, releasing whatever container storage it was holding. The CCompressedFullBool class is implied by the name; which resources are actually freed is not established here.", + "source": "generated" + }, + "CCompressedFullChar::CanEncode": { + "text": "Tests whether this codec can encode the data it is handed, so selection code can reject a char-valued channel it cannot represent. The CCompressedFullChar class is implied by the name; the inputs examined and the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedFullChar::CreateContainer": { + "text": "Creates the storage container that holds this codec's compressed char data. The CCompressedFullChar class is implied by the name; the container's layout and who owns the allocation are not established here.", + "source": "generated" + }, + "CCompressedFullChar::DecodeFrame": { + "text": "Decodes a single frame of char values out of compressed storage into caller-supplied output, for readers that want one sample rather than a whole container. The CCompressedFullChar class is implied by the name; the buffers involved and the frame indexing are unverified.", + "source": "generated" + }, + "CCompressedFullChar::DecodeSize": { + "text": "Reports how much space decoding this compressed char data requires, letting callers size an output buffer before they decode. The CCompressedFullChar class is implied by the name; whether the figure counts bytes or elements is not established.", + "source": "generated" + }, + "CCompressedFullChar::DeswizzleAndBlendContainer": { + "text": "Unpacks a compressed char container out of its interleaved storage order while blending the result against another set of values, the combined form of plain container deswizzling. The CCompressedFullChar class is implied by the name; the blend weighting and the roles of each operand are unverified.", + "source": "generated" + }, + "CCompressedFullChar::DeswizzleContainer": { + "text": "Unpacks a compressed char container from its interleaved storage order into straight per-element output. The CCompressedFullChar class is implied by the name; the exact packing order it reverses is not established by this data.", + "source": "generated" + }, + "CCompressedFullChar::GetFieldType": { + "text": "Reports the field-type identifier this codec handles, marking it as the full-precision char encoding to code that picks a codec by data type. The CCompressedFullChar class is implied by the name; the identifier's enumeration and values are not established.", + "source": "generated" + }, + "CCompressedFullChar::GetFlags": { + "text": "Reports the flags this codec advertises about its own encoding behaviour, which callers consult when deciding how the compressed char data may be used. The CCompressedFullChar class is implied by the name; the individual flag bits and their meanings are not established.", + "source": "generated" + }, + "CCompressedFullChar::GetName": { + "text": "Supplies this codec's name for identification, logging, or tooling that lists available compression types. The CCompressedFullChar class is implied by the name; beyond producing a name, no further purpose is established.", + "source": "generated" + }, + "CCompressedFullChar::GetSizeof": { + "text": "Reports the size associated with this codec, the figure a caller needs to stride through or allocate its compressed char storage. The CCompressedFullChar class is implied by the name; which object or element the size measures is not established.", + "source": "generated" + }, + "CCompressedFullChar::Instantiate": { + "text": "Brings a full-precision char codec instance into existence, the hook to use when you need a working encoder or decoder of this type. The CCompressedFullChar class is implied by the name; where the instance is placed and how long it lives are unverified.", + "source": "generated" + }, + "CCompressedFullChar::~CCompressedFullChar": { + "text": "Tears down a full-precision char codec instance, releasing whatever container storage it was holding. The CCompressedFullChar class is implied by the name; which resources are actually freed is not established here.", + "source": "generated" + }, + "CCompressedFullColor32::CanEncode": { + "text": "Reports whether given source data can be represented in this full-precision Color32 encoding, so generic compression code can pick a format that accepts the values at hand. Read from the name; the owning class is implied by the name rather than derived from the data, so the exact test and its inputs are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::CreateContainer": { + "text": "Allocates the container object that holds full-precision Color32 data in its encoded, packed form. Read from the name; the owning class is implied by the name, so the container's layout and ownership rules are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::DecodeFrame": { + "text": "Decodes a single frame's worth of full-precision Color32 values out of an encoded container into caller-supplied output. Read from the name; the owning class is implied by the name, so the frame indexing and output form are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::DecodeSize": { + "text": "Reports how large the decoded full-precision Color32 output will be, which a caller uses to size a destination buffer before decoding. Read from the name; the owning class is implied by the name, and whether the measure is bytes or element count is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's swizzled full-precision Color32 layout into straight per-element order while blending the result against a second set of values, as when interpolating between two samples. Read from the name; the owning class is implied by the name, so the blend weighting and operand roles are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::DeswizzleContainer": { + "text": "Unpacks the container's swizzled, interleaved full-precision Color32 storage back into straight per-element order for consumers. Read from the name; the owning class is implied by the name, so the exact memory layout it converts between is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::GetFieldType": { + "text": "Reports which data field type this codec handles, letting generic compression code match a compressor to the kind of value being stored. Read from the name; the owning class is implied by the name, and the type enumeration used is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::GetFlags": { + "text": "Reports the codec's capability and behaviour flags, which generic compression code queries to learn how this format may be used. Read from the name; the owning class is implied by the name, and the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::GetName": { + "text": "Supplies the codec's identifying name, presumably for lookup or diagnostics; a more specific purpose is not established. The owning class is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedFullColor32::GetSizeof": { + "text": "Reports the size of the codec's stored element or instance, letting generic code stride through packed data without knowing the format. Read from the name; the owning class is implied by the name, and which object is measured is unverified.", + "source": "generated" + }, + "CCompressedFullColor32::Instantiate": { + "text": "Constructs a working instance of the full-precision Color32 codec, the hook generic compression code uses to obtain one for a field. Read from the name; the owning class is implied by the name, so allocation and lifetime behaviour are unverified.", + "source": "generated" + }, + "CCompressedFullColor32::~CCompressedFullColor32": { + "text": "Destroys a full-precision Color32 codec instance, releasing container or buffer state it holds. Read from the name as a destructor; the owning class is implied by the name, so the resources actually freed are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::CanEncode": { + "text": "Reports whether given source data can be represented in this full-precision float encoding, so generic compression code can pick a format that accepts the values at hand. Read from the name; the owning class is implied by the name rather than derived from the data, so the exact test and its inputs are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::CreateContainer": { + "text": "Allocates the container object that holds full-precision float data in its encoded, packed form. Read from the name; the owning class is implied by the name, so the container's layout and ownership rules are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::DecodeFrame": { + "text": "Decodes a single frame's worth of full-precision float values out of an encoded container into caller-supplied output. Read from the name; the owning class is implied by the name, so the frame indexing and output form are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::DecodeSize": { + "text": "Reports how large the decoded full-precision float output will be, which a caller uses to size a destination buffer before decoding. Read from the name; the owning class is implied by the name, and whether the measure is bytes or element count is unverified.", + "source": "generated" + }, + "CCompressedFullFloat::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's swizzled full-precision float layout into straight per-element order while blending the result against a second set of values, as when interpolating between two samples. Read from the name; the owning class is implied by the name, so the blend weighting and operand roles are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::DeswizzleContainer": { + "text": "Unpacks the container's swizzled, interleaved full-precision float storage back into straight per-element order for consumers. Read from the name; the owning class is implied by the name, so the exact memory layout it converts between is unverified.", + "source": "generated" + }, + "CCompressedFullFloat::GetFieldType": { + "text": "Reports which data field type this codec handles, letting generic compression code match a compressor to the kind of value being stored. Read from the name; the owning class is implied by the name, and the type enumeration used is unverified.", + "source": "generated" + }, + "CCompressedFullFloat::GetFlags": { + "text": "Reports the codec's capability and behaviour flags, which generic compression code queries to learn how this format may be used. Read from the name; the owning class is implied by the name, and the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::GetName": { + "text": "Supplies the codec's identifying name, presumably for lookup or diagnostics; a more specific purpose is not established. The owning class is implied by the name, not by the data.", + "source": "generated" + }, + "CCompressedFullFloat::GetSizeof": { + "text": "Reports the size of the codec's stored element or instance, letting generic code stride through packed data without knowing the format. Read from the name; the owning class is implied by the name, and which object is measured is unverified.", + "source": "generated" + }, + "CCompressedFullFloat::Instantiate": { + "text": "Constructs a working instance of the full-precision float codec, the hook generic compression code uses to obtain one for a field. Read from the name; the owning class is implied by the name, so allocation and lifetime behaviour are unverified.", + "source": "generated" + }, + "CCompressedFullFloat::~CCompressedFullFloat": { + "text": "Destroys a full-precision float codec instance, releasing container or buffer state it holds. Read from the name as a destructor; the owning class is implied by the name, so the resources actually freed are unverified.", + "source": "generated" + }, + "CCompressedFullInt::CanEncode": { + "text": "Reports whether this full-precision integer codec is able to encode a given piece of source data, so encoding code can pick a scheme that will accept the values. Read from the name; the class binding is implied by the name, and what it inspects to decide is unverified.", + "source": "generated" + }, + "CCompressedFullInt::CreateContainer": { + "text": "Builds the storage container that holds this codec's full-precision integer payload for a compressed track. Read from the name; the class binding is implied by the name, so the container's layout and who owns the allocation are unverified.", + "source": "generated" + }, + "CCompressedFullInt::DecodeFrame": { + "text": "Decodes a single frame's worth of values out of a compressed integer container into caller-supplied output. Read from the name; the class binding is implied by the name, and no prototype is derived, so frame addressing and output form are unverified.", + "source": "generated" + }, + "CCompressedFullInt::DecodeSize": { + "text": "Reports how large a decode of this codec's data will be, the figure a caller needs before allocating an output buffer. Read from the name; the class binding is implied by the name, so whether the count is in bytes, elements, or frames is unverified.", + "source": "generated" + }, + "CCompressedFullInt::DeswizzleAndBlendContainer": { + "text": "Unpacks the codec's interleaved (swizzled) container into per-element order and blends the result against a second set of values in one pass, the shape you want when mixing two sets of animated data. Read from the name; the class binding is implied by the name, so the blend weighting is unverified.", + "source": "generated" + }, + "CCompressedFullInt::DeswizzleContainer": { + "text": "Unpacks the codec's interleaved (swizzled) container back into straight per-element order, with no blending step. Read from the name; the class binding is implied by the name, so the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedFullInt::GetFieldType": { + "text": "Reports which field type this codec encodes, letting generic compression code identify what a container's payload actually holds. Read from the name, with a derived prototype; the class binding is implied by the name, and the type enumeration itself is unverified.", + "source": "generated" + }, + "CCompressedFullInt::GetFlags": { + "text": "Returns the codec's flag bits, which generic compression code can test to learn how the encoder behaves before using it. Read from the name, with a derived prototype; the class binding is implied by the name, and the meaning of individual bits is unverified.", + "source": "generated" + }, + "CCompressedFullInt::GetName": { + "text": "Returns the codec's identifying name, the label generic compression code would use to select or report an encoder; nothing beyond that is established. The class binding is implied by the name.", + "source": "generated" + }, + "CCompressedFullInt::GetSizeof": { + "text": "Reports the byte size associated with this codec \u2014 the per-element or per-record stride a caller needs to walk or allocate its compressed data. Read from the name; the class binding is implied by the name, so exactly which size it measures is unverified.", + "source": "generated" + }, + "CCompressedFullInt::Instantiate": { + "text": "Brings up a working instance of this full-precision integer codec for compression code to use. Read from the name, with a derived prototype; the class binding is implied by the name, so what it constructs or registers is unverified.", + "source": "generated" + }, + "CCompressedFullInt::~CCompressedFullInt": { + "text": "Destructor for the full-precision integer codec: tears the instance down and releases the storage it holds. The prototype is derived; the class binding is implied by the name.", + "source": "generated" + }, + "CCompressedFullShort::CanEncode": { + "text": "Reports whether this short-width integer codec can encode a given piece of source data, so encoding code can reject values that will not fit the narrower storage. Read from the name; the class binding is implied by the name, and the range test it applies is unverified.", + "source": "generated" + }, + "CCompressedFullShort::CreateContainer": { + "text": "Builds the storage container that holds this codec's short-width payload for a compressed track. Read from the name; the class binding is implied by the name, so the container's layout and allocation ownership are unverified.", + "source": "generated" + }, + "CCompressedFullShort::DecodeFrame": { + "text": "Decodes a single frame's worth of values out of a compressed short-width container into caller-supplied output. Read from the name; the class binding is implied by the name, and no prototype is derived, so frame addressing and output form are unverified.", + "source": "generated" + }, + "CCompressedFullShort::DecodeSize": { + "text": "Reports how large a decode of this codec's short-width data will be, so a caller can size an output buffer. Read from the name; the class binding is implied by the name, so whether the count is in bytes, elements, or frames is unverified.", + "source": "generated" + }, + "CCompressedFullShort::DeswizzleAndBlendContainer": { + "text": "Unpacks the codec's interleaved (swizzled) short-width container into per-element order while blending the result against a second set of values in one pass. Read from the name; the class binding is implied by the name, so the blend weighting and the roles of the two operands are unverified.", + "source": "generated" + }, + "CCompressedFullShort::DeswizzleContainer": { + "text": "Unpacks the codec's interleaved (swizzled) short-width container back into straight per-element order, without blending. Read from the name; the class binding is implied by the name, so the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedFullShort::GetFieldType": { + "text": "Reports which field type this short-width codec encodes, letting generic compression code identify a container's payload. Read from the name, with a derived prototype; the class binding is implied by the name, and the type enumeration itself is unverified.", + "source": "generated" + }, + "CCompressedFullShort::GetFlags": { + "text": "Returns the codec's flag bits, which generic compression code can test to learn how this encoder behaves. Read from the name, with a derived prototype; the class binding is implied by the name, and the meaning of individual bits is unverified.", + "source": "generated" + }, + "CCompressedFullShort::GetName": { + "text": "Returns the codec's identifying name, the label generic compression code would use to select or report an encoder; nothing beyond that is established. The class binding is implied by the name.", + "source": "generated" + }, + "CCompressedFullShort::GetSizeof": { + "text": "Reports the byte size associated with this short-width codec \u2014 the per-element or per-record stride needed to walk or allocate its compressed data. Read from the name; the class binding is implied by the name, so exactly which size it measures is unverified.", + "source": "generated" + }, + "CCompressedFullShort::Instantiate": { + "text": "Brings up a working instance of this short-width codec for compression code to use. Read from the name, with a derived prototype; the class binding is implied by the name, so what it constructs or registers is unverified.", + "source": "generated" + }, + "CCompressedFullShort::~CCompressedFullShort": { + "text": "Destructor for the short-width codec: tears the instance down and releases the storage it holds. The prototype is derived; the class binding is implied by the name.", + "source": "generated" + }, + "CCompressedFullVector2D::CanEncode": { + "text": "Tests whether this codec is able to encode a given source of 2D-vector data, i.e. whether the full-precision 2D compression path is applicable to it. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::CreateContainer": { + "text": "Builds the container object that holds this codec's compressed full-precision 2D-vector data, giving callers the storage they then fill or read. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::DecodeFrame": { + "text": "Decodes a single frame of compressed 2D-vector values out of the codec's stored data into usable output \u2014 the per-frame sampling entry point for anyone reading this compressed track. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::DecodeSize": { + "text": "Reports the size of the decoded 2D-vector data for this codec, which is what a caller needs to size an output buffer. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed 2D-vector data into a linear layout while blending it with another set of values, producing a weighted mix in one operation. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::DeswizzleContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed 2D-vector data back into a plain linear layout, the plain variant without blending. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::GetFieldType": { + "text": "Reports the field type this codec handles, identifying the kind of data \u2014 a full-precision 2D vector \u2014 that it compresses, so callers can match a codec to a field. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::GetFlags": { + "text": "Reports the codec's flag bits, the capability or behaviour word a caller queries to learn how this compression handles its data. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::GetName": { + "text": "Yields the codec's identifying name string; beyond naming, no further purpose is established. The CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::GetSizeof": { + "text": "Reports the byte size of this codec's data element or instance, which callers use to stride through and allocate compressed 2D-vector storage. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::Instantiate": { + "text": "Brings a usable instance of this codec into existence, the factory-style entry point for obtaining the full-precision 2D-vector compressor. Read from the name; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector2D::~CCompressedFullVector2D": { + "text": "Destroys a CCompressedFullVector2D instance and releases whatever storage the codec object owns. This is the destructor; the CCompressedFullVector2D class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::CanEncode": { + "text": "Tests whether this codec is able to encode a given source of 3D-vector data, i.e. whether the full-precision 3D compression path is applicable to it. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::CreateContainer": { + "text": "Builds the container object that holds this codec's compressed full-precision 3D-vector data, giving callers the storage they then fill or read. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::DecodeFrame": { + "text": "Decodes a single frame of compressed 3D-vector values out of the codec's stored data into usable output \u2014 the per-frame sampling entry point for reading this compressed track. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::DecodeSize": { + "text": "Reports the size of the decoded 3D-vector data for this codec, which is what a caller needs to size an output buffer. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed 3D-vector data into a linear layout while blending it with another set of values, producing a weighted mix in one operation. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::DeswizzleContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed 3D-vector data back into a plain linear layout, the plain variant without blending. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::GetFieldType": { + "text": "Reports the field type this codec handles, identifying the kind of data \u2014 a full-precision 3D vector \u2014 that it compresses, so callers can match a codec to a field. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::GetFlags": { + "text": "Reports the codec's flag bits, the capability or behaviour word a caller queries to learn how this compression handles its data. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::GetName": { + "text": "Yields the codec's identifying name string; beyond naming, no further purpose is established. The CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::GetSizeof": { + "text": "Reports the byte size of this codec's data element or instance, which callers use to stride through and allocate compressed 3D-vector storage. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::Instantiate": { + "text": "Brings a usable instance of this codec into existence, the factory-style entry point for obtaining the full-precision 3D-vector compressor. Read from the name; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector3::~CCompressedFullVector3": { + "text": "Destroys a CCompressedFullVector3 instance and releases whatever storage the codec object owns. This is the destructor; the CCompressedFullVector3 class is implied by the name rather than established by the data.", + "source": "generated" + }, + "CCompressedFullVector4D::CanEncode": { + "text": "Reports whether candidate source values can be represented by this full-precision four-component vector encoding, letting compression code accept this codec or fall back to another. The class is implied by the name rather than bound in the data, and the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::CreateContainer": { + "text": "Allocates the storage container that holds this codec's compressed four-component vector data, so encoded frames have somewhere to live. Read from the name, with the class implied by the name; the container's internal layout is not established here.", + "source": "generated" + }, + "CCompressedFullVector4D::DecodeFrame": { + "text": "Decompresses one stored frame back into full-precision Vector4D values for a consumer that wants uncompressed samples. Read from the name, and the class is implied by the name, so frame addressing and output placement are unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::DecodeSize": { + "text": "Reports how much decoded output this codec produces, which is what a caller needs to size a destination buffer before decoding. The class is implied by the name; whether the figure covers one element or a whole frame is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved (swizzled) vector storage into linear output while blending between stored frames, yielding interpolated Vector4D samples. Read from the name, with the class implied by the name; the blend weighting and interpolation rule are unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::DeswizzleContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed storage into linear per-element Vector4D output, with no blending step. Read from the name, and the class is implied by the name, so the packed storage layout is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::GetFieldType": { + "text": "Reports the field-type identifier this codec handles, letting generic compression code match a codec to the kind of data it is asked to store. The class is implied by the name, and the identifier's enumeration is not established here.", + "source": "generated" + }, + "CCompressedFullVector4D::GetFlags": { + "text": "Provides the codec's descriptive flag bits, which generic code inspects when choosing or driving a compressor. The class is implied by the name, and the meaning of individual bits is not established by this data.", + "source": "generated" + }, + "CCompressedFullVector4D::GetName": { + "text": "Provides this compressor's identifying name, useful when enumerating or logging available codecs. Beyond that the purpose is not established, and the class is implied by the name.", + "source": "generated" + }, + "CCompressedFullVector4D::GetSizeof": { + "text": "Reports an in-memory size for this codec, the figure a caller needs for allocation or stride arithmetic. The class is implied by the name, and whether the size describes the codec object or one encoded element is unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::Instantiate": { + "text": "Creates a working instance of this compressor for the compression system to use. Read from the name, with the class implied by the name, so where the instance is placed and how it is initialised are unverified.", + "source": "generated" + }, + "CCompressedFullVector4D::~CCompressedFullVector4D": { + "text": "Tears down the compressor instance and releases whatever storage it owns. Ordinary destructor behaviour implied by the name; nothing beyond teardown is established here.", + "source": "generated" + }, + "CCompressedStaticBool::CanEncode": { + "text": "Reports whether candidate source values qualify for the static boolean encoding, meaning boolean data uniform enough to store once instead of per frame. The class is implied by the name, and the exact acceptance test is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::CreateContainer": { + "text": "Allocates the storage container holding this codec's boolean data, which for a static encoding is a stored constant rather than a per-frame stream. Read from the name, with the class implied by the name; the container's internal form is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::DecodeFrame": { + "text": "Produces the boolean value for a requested frame, which under a static encoding is the single stored constant. Read from the name, and the class is implied by the name, so frame addressing and output placement are unverified.", + "source": "generated" + }, + "CCompressedStaticBool::DecodeSize": { + "text": "Reports the decoded output size for the static boolean codec, so a caller can size a destination buffer before decoding. The class is implied by the name, and the unit the size is expressed in is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::DeswizzleAndBlendContainer": { + "text": "Expands the container's packed boolean storage into linear output on the blending path, so a constant boolean field can be sampled through the same interface as time-varying ones. The class is implied by the name, and how blend weights are treated is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::DeswizzleContainer": { + "text": "Expands the container's packed boolean storage into linear per-element output, with no blending step. Read from the name, with the class implied by the name, so the packed layout is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::GetFieldType": { + "text": "Reports the field-type identifier this codec handles, letting generic compression code match a boolean field to this encoding. The class is implied by the name, and the identifier's enumeration is not established here.", + "source": "generated" + }, + "CCompressedStaticBool::GetFlags": { + "text": "Provides the codec's descriptive flag bits, which generic code inspects when selecting or driving a compressor. The class is implied by the name, and the meaning of individual bits is not established by this data.", + "source": "generated" + }, + "CCompressedStaticBool::GetName": { + "text": "Provides this compressor's identifying name, useful when enumerating or logging available codecs. Beyond that the purpose is not established, and the class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticBool::GetSizeof": { + "text": "Reports an in-memory size for this codec, the figure a caller needs for allocation or stride arithmetic. The class is implied by the name, and whether it describes the codec object or one encoded element is unverified.", + "source": "generated" + }, + "CCompressedStaticBool::Instantiate": { + "text": "Creates a working instance of this compressor for the compression system to use. Read from the name, with the class implied by the name, so where the instance is placed and how it is initialised are unverified.", + "source": "generated" + }, + "CCompressedStaticBool::~CCompressedStaticBool": { + "text": "Tears down the compressor instance and releases whatever storage it owns. Ordinary destructor behaviour implied by the name; nothing beyond teardown is established here.", + "source": "generated" + }, + "CCompressedStaticChar::CanEncode": { + "text": "Tests whether a candidate block of char-valued data can be represented in this static compressed form, so a compressor can decide whether to select this codec. The class is implied by the name rather than bound in the data, so the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::CreateContainer": { + "text": "Allocates the container object that holds this codec's compressed static char payload. The class is implied by the name, not established by the data, so the container's layout and who owns the memory are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::DecodeFrame": { + "text": "Decodes a single frame's worth of char values out of the compressed static representation into caller-supplied output. Read from the name; the class is implied by the name rather than bound in the data, so the output form and how frames are indexed are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::DecodeSize": { + "text": "Reports the size of the decoded char output for this compressed data, so a caller can size an output buffer. The class is implied by the name, and the units it reports are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved char samples back into linear per-element order and blends the result with existing values, as when layering compressed static data over a base. The class is implied by the name, so the blend factor and destination format are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::DeswizzleContainer": { + "text": "Unpacks the container's interleaved char samples into linear per-element output without blending, the plain counterpart to CCompressedStaticChar::DeswizzleAndBlendContainer. The class is implied by the name, so the swizzle pattern and destination layout are unverified.", + "source": "generated" + }, + "CCompressedStaticChar::GetFieldType": { + "text": "Reports which data field type this codec handles, identifying it as the char variant to generic compression code that selects codecs by type. The class is implied by the name, and the enumeration used is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::GetFlags": { + "text": "Reports the codec's capability or behaviour flags to generic compression code. The class is implied by the name, and the meaning of individual flag bits is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::GetName": { + "text": "Yields the codec's identifying name; beyond that, purpose is not established. The class is implied by the name, not bound in the data.", + "source": "generated" + }, + "CCompressedStaticChar::GetSizeof": { + "text": "Reports the storage size associated with this codec, for callers allocating buffers or stepping through packed data. The class is implied by the name, and whether it measures one element or the codec's own structure is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::Instantiate": { + "text": "Brings a usable instance of this static char codec into existence for generic compression code to work with. The class is implied by the name, and whether it allocates fresh storage or initialises in place is unverified.", + "source": "generated" + }, + "CCompressedStaticChar::~CCompressedStaticChar": { + "text": "Destroys a codec instance, releasing whatever container or scratch memory it holds. The class is implied by the name, and exactly what gets freed is unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::CanEncode": { + "text": "Tests whether a candidate block of packed 32-bit colour values can be represented in this static compressed form, so a compressor can decide whether to select this codec. The class is implied by the name rather than bound in the data, so the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::CreateContainer": { + "text": "Allocates the container object that holds this codec's compressed static colour payload. The class is implied by the name, not established by the data, so the container's layout and memory ownership are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::DecodeFrame": { + "text": "Decodes a single frame's worth of Color32 values out of the compressed static representation into caller-supplied output. Read from the name; the class is implied by the name rather than bound in the data, so the output form and frame indexing are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::DecodeSize": { + "text": "Reports the size of the decoded colour output for this compressed data, so a caller can size an output buffer. The class is implied by the name, and the units it reports are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved colour samples back into linear per-element order and blends the result with existing values, as when layering compressed static colour over a base. The class is implied by the name, so the blend factor and destination format are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::DeswizzleContainer": { + "text": "Unpacks the container's interleaved colour samples into linear per-element output without blending, the plain counterpart to CCompressedStaticColor32::DeswizzleAndBlendContainer. The class is implied by the name, so the swizzle pattern and channel order of the output are unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::GetFieldType": { + "text": "Reports which data field type this codec handles, identifying it as the Color32 variant to generic compression code that selects codecs by type. The class is implied by the name, and the enumeration used is unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::GetFlags": { + "text": "Reports the codec's capability or behaviour flags to generic compression code. The class is implied by the name, and the meaning of individual flag bits is unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::GetName": { + "text": "Yields the codec's identifying name; beyond that, purpose is not established. The class is implied by the name, not bound in the data.", + "source": "generated" + }, + "CCompressedStaticColor32::GetSizeof": { + "text": "Reports the storage size associated with this codec, for callers allocating buffers or stepping through packed colour data. The class is implied by the name, and whether it measures one element or the codec's own structure is unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::Instantiate": { + "text": "Brings a usable instance of this static Color32 codec into existence for generic compression code to work with. The class is implied by the name, and whether it allocates fresh storage or initialises in place is unverified.", + "source": "generated" + }, + "CCompressedStaticColor32::~CCompressedStaticColor32": { + "text": "Destroys a codec instance, releasing whatever container or scratch memory it holds. The class is implied by the name, and exactly what gets freed is unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::CanEncode": { + "text": "Tests whether a given float animation channel qualifies for this static (constant-value) compression format, so a compressor can accept or reject the channel. The class is implied by the name; the reading comes from the name alone, so the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::CreateContainer": { + "text": "Allocates the storage container that holds this codec's compressed static float data. The class is implied by the name; read from the name alone, so what the container holds and how it is sized are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::DecodeFrame": { + "text": "Decodes a single animation frame's worth of data for a float channel stored in this static format, producing the value a sampler consumes. The class is implied by the name; read from the name, so frame indexing and the output destination are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::DecodeSize": { + "text": "Reports the size of this codec's float data once decoded, which is what you need when sizing an output buffer before decoding. The class is implied by the name; read from the name alone, so whether the figure counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::DeswizzleAndBlendContainer": { + "text": "Unpacks (deswizzles) a compressed static float container into a linear layout and blends the result with existing values, the pattern used for weighted animation layering. The class is implied by the name; read from the name alone, so the blend weighting and container layout are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::DeswizzleContainer": { + "text": "Unpacks a compressed static float container from its interleaved storage order into a linear, directly readable layout, without any blending step. The class is implied by the name; read from the name, so the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::GetFieldType": { + "text": "Reports which animation field type this codec handles, letting the runtime match a codec to a channel it can decode. The class is implied by the name; the specific field-type constant reported is not established by this data.", + "source": "generated" + }, + "CCompressedStaticFloat::GetFlags": { + "text": "Reports the capability or behavior flags describing this codec, which a caller can query to decide how its data must be treated. The class is implied by the name; the individual flag meanings are not established by this data.", + "source": "generated" + }, + "CCompressedStaticFloat::GetName": { + "text": "Supplies an identifying name for the codec; beyond that identification, the purpose is not established. The class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticFloat::GetSizeof": { + "text": "Reports the in-memory size associated with this codec's data, the figure a caller uses when allocating storage or striding through it. The class is implied by the name; read from the name alone, so exactly what is measured is unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::Instantiate": { + "text": "Constructs an instance of this codec so it can be registered and used to decode static float channels. The class is implied by the name; read from the name alone, so what is created and where it is stored are unverified.", + "source": "generated" + }, + "CCompressedStaticFloat::~CCompressedStaticFloat": { + "text": "Destroys a CCompressedStaticFloat instance, releasing whatever storage the codec owns. The class is implied by the name; read from the name, so the cleanup actually performed is unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::CanEncode": { + "text": "Tests whether a given three-component vector animation channel qualifies for this static, full-precision compression format, so a compressor can accept or reject it. The class is implied by the name; the reading comes from the name alone, so the acceptance criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::CreateContainer": { + "text": "Allocates the storage container holding this codec's compressed static vector data. The class is implied by the name; read from the name alone, so the container's contents and sizing rules are unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::DecodeFrame": { + "text": "Decodes one animation frame of a three-component vector channel stored in this static format, yielding the vector a sampler consumes. The class is implied by the name; read from the name, so frame indexing and the output destination are unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::DecodeSize": { + "text": "Reports the size of this codec's vector data once decoded, useful for sizing an output buffer ahead of decoding. The class is implied by the name; read from the name alone, so whether the figure counts bytes or elements is unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks (deswizzles) a compressed static vector container into a linear layout and blends the result with existing values, as weighted animation layering requires. The class is implied by the name; read from the name alone, so the blend weighting and container layout are unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::DeswizzleContainer": { + "text": "Unpacks a compressed static vector container from its interleaved storage order into a linear, directly readable layout, with no blending step. The class is implied by the name; read from the name, so the source and destination layouts are unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::GetFieldType": { + "text": "Reports which animation field type this codec handles, letting the runtime match a codec to a channel it can decode. The class is implied by the name; the specific field-type constant reported is not established by this data.", + "source": "generated" + }, + "CCompressedStaticFullVector3::GetFlags": { + "text": "Reports the capability or behavior flags describing this codec, queried when deciding how its data must be treated. The class is implied by the name; the individual flag meanings are not established by this data.", + "source": "generated" + }, + "CCompressedStaticFullVector3::GetName": { + "text": "Supplies an identifying name for the codec; beyond that identification, the purpose is not established. The class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticFullVector3::GetSizeof": { + "text": "Reports the in-memory size associated with this codec's data, the figure a caller uses when allocating storage or striding through it. The class is implied by the name; read from the name alone, so exactly what is measured is unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::Instantiate": { + "text": "Constructs an instance of this codec so it can be registered and used to decode static vector channels. The class is implied by the name; read from the name alone, so what is created and where it is stored are unverified.", + "source": "generated" + }, + "CCompressedStaticFullVector3::~CCompressedStaticFullVector3": { + "text": "Destroys a CCompressedStaticFullVector3 instance, releasing whatever storage the codec owns. The class is implied by the name; read from the name, so the cleanup actually performed is unverified.", + "source": "generated" + }, + "CCompressedStaticInt::CanEncode": { + "text": "Tests whether this compressed-integer codec is able to encode a given body of source data, so a caller can choose a suitable codec instead of committing to one blindly. The class CCompressedStaticInt is implied by the name rather than bound in this data, so the acceptance criteria it applies are unverified.", + "source": "generated" + }, + "CCompressedStaticInt::CreateContainer": { + "text": "Allocates the container object that holds integer data compressed by this codec, giving encode and decode work somewhere to live. The class is implied by the name rather than bound in the data, so the container's contents and sizing rules are a name-level reading only.", + "source": "generated" + }, + "CCompressedStaticInt::DecodeFrame": { + "text": "Decompresses one frame's worth of integer values out of a compressed container into usable output, making it the natural place to observe or rewrite decoded values. The class is implied by the name and nothing beyond the name is derived, so frame indexing and output layout are unverified.", + "source": "generated" + }, + "CCompressedStaticInt::DecodeSize": { + "text": "Reports how large the decoded integer output is, letting a caller size a destination buffer for the decode. The class is implied by the name and the reading is name-level, so whether the figure covers a single frame or a whole container is unverified.", + "source": "generated" + }, + "CCompressedStaticInt::DeswizzleAndBlendContainer": { + "text": "Unpacks a container's swizzled (interleaved) compressed integers into their natural per-element layout and blends the result with a second set of values in the same pass. The class is implied by the name; the blend weighting and the roles of the two inputs are not established here.", + "source": "generated" + }, + "CCompressedStaticInt::DeswizzleContainer": { + "text": "Unpacks a container's swizzled compressed integers back into a plain per-element layout, the non-blending counterpart to CCompressedStaticInt::DeswizzleAndBlendContainer. The class is implied by the name, so the interleaving pattern it reverses is a name-level reading and unverified.", + "source": "generated" + }, + "CCompressedStaticInt::GetFieldType": { + "text": "Returns the field-type identifier describing the kind of data this codec handles, which generic code can branch on when several codec types are in play. The class is implied by the name, and the identifier's value space is not established by this data.", + "source": "generated" + }, + "CCompressedStaticInt::GetFlags": { + "text": "Returns this codec's flag bits, the usual way capability or behaviour options are queried when working with a codec generically. The class is implied by the name, and the meaning of individual bits is not established by this data.", + "source": "generated" + }, + "CCompressedStaticInt::GetName": { + "text": "Returns this codec's name string; beyond that, purpose is not established. The class CCompressedStaticInt is implied by the name, not bound in the data.", + "source": "generated" + }, + "CCompressedStaticInt::GetSizeof": { + "text": "Reports the in-memory size of the codec's element or object, the figure a caller needs for allocation and for stepping through packed data. The class is implied by the name and the reading is name-level, so exactly what is being measured is unverified.", + "source": "generated" + }, + "CCompressedStaticInt::Instantiate": { + "text": "Brings a usable instance of this codec into existence, the standard construction entry point when a codec is selected generically. Purpose beyond construction is not established, and the class is implied by the name rather than bound in the data.", + "source": "generated" + }, + "CCompressedStaticInt::~CCompressedStaticInt": { + "text": "Destroys the codec instance and releases any storage it owns. Ordinary destructor behaviour is implied by the name; no cleanup detail is derived, so ownership of containers the codec created should be treated as unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::CanEncode": { + "text": "Tests whether this compressed-quaternion codec can represent a given set of rotation data, letting a caller reject it and fall back to another codec. The class CCompressedStaticQuaternion is implied by the name rather than bound in the data, so the precision or tolerance test it applies is a name-level reading only.", + "source": "generated" + }, + "CCompressedStaticQuaternion::CreateContainer": { + "text": "Allocates the container object that holds quaternion rotation data compressed by this codec. The class is implied by the name rather than bound in the data, so the container's internal layout and sizing rules are unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::DecodeFrame": { + "text": "Decompresses one frame's worth of quaternion rotations out of a compressed container into usable orientations, making it the point at which decoded rotation values can be inspected or altered. The class is implied by the name, so frame selection and output ordering remain name-level readings.", + "source": "generated" + }, + "CCompressedStaticQuaternion::DecodeSize": { + "text": "Reports how large the decoded quaternion output is, so a caller can size a destination buffer for it. The class is implied by the name and the reading is name-level, so whether it counts a single frame or a full container is unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::DeswizzleAndBlendContainer": { + "text": "Unpacks a container's interleaved compressed quaternions into their natural layout and blends them with a second set of rotations in the same pass. The class is implied by the name; whether the blend is linear or spherical, and how it is weighted, is not established here.", + "source": "generated" + }, + "CCompressedStaticQuaternion::DeswizzleContainer": { + "text": "Unpacks a container's swizzled compressed quaternions back into a plain per-element layout, the non-blending counterpart to CCompressedStaticQuaternion::DeswizzleAndBlendContainer. The class is implied by the name, so the packing scheme it reverses is unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::GetFieldType": { + "text": "Returns the field-type identifier for the data this codec handles, letting generic code tell a rotation codec apart from other kinds. The class is implied by the name, and the identifier's value space is not established by this data.", + "source": "generated" + }, + "CCompressedStaticQuaternion::GetFlags": { + "text": "Returns this codec's flag bits, the usual query for capability or behaviour options when handling a codec generically. The class is implied by the name, and the meaning of individual bits is not established here.", + "source": "generated" + }, + "CCompressedStaticQuaternion::GetName": { + "text": "Returns this codec's name string; beyond that, purpose is not established. The class CCompressedStaticQuaternion is implied by the name, not bound in the data.", + "source": "generated" + }, + "CCompressedStaticQuaternion::GetSizeof": { + "text": "Reports the in-memory size associated with this codec, the figure a caller needs for allocation and for stepping through packed rotation data. The class is implied by the name and the reading is name-level, so what exactly it measures is unverified.", + "source": "generated" + }, + "CCompressedStaticQuaternion::Instantiate": { + "text": "Creates a usable instance of this quaternion codec, the standard construction entry point when a codec is selected generically. Purpose beyond construction is not established, and the class is implied by the name rather than bound in the data.", + "source": "generated" + }, + "CCompressedStaticQuaternion::~CCompressedStaticQuaternion": { + "text": "Destroys the codec instance and frees any storage it holds. Ordinary destructor behaviour is implied by the name; no cleanup detail is derived, so ownership of containers the codec created should be treated as unverified.", + "source": "generated" + }, + "CCompressedStaticShort::CanEncode": { + "text": "Tests whether given source data can be represented in this static short-integer compressed form, so a compressor can decide before committing to the format. The class and the test are implied by the name; what inputs are inspected and what makes encoding fail are unverified.", + "source": "generated" + }, + "CCompressedStaticShort::CreateContainer": { + "text": "Allocates the packed storage container that holds this format's compressed static short data, the object a compressor writes into and a decoder later reads. Its role is implied by the name; the container layout and who owns the allocation are not established here.", + "source": "generated" + }, + "CCompressedStaticShort::DecodeFrame": { + "text": "Reads one frame's worth of short values back out of a compressed static container, producing usable data at playback time. The per-frame decode is implied by the name; the frame indexing scheme and destination conventions are unverified.", + "source": "generated" + }, + "CCompressedStaticShort::DecodeSize": { + "text": "Reports how large the decoded result of this compressed short format is, letting a caller size a destination buffer before decoding into it. The measurement is implied by the name; whether it counts bytes, elements, or a per-frame stride is not established.", + "source": "generated" + }, + "CCompressedStaticShort::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed short data and blends the result with existing values instead of overwriting them, the variant used when a decode must be mixed into a running result. Both halves are implied by the name; the blend weighting and the source/destination roles are unverified.", + "source": "generated" + }, + "CCompressedStaticShort::DeswizzleContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed short layout into straight per-element ordering that consuming code can index normally. The de-interleaving is implied by the name; the exact packing scheme and output ordering are not established.", + "source": "generated" + }, + "CCompressedStaticShort::GetFieldType": { + "text": "Returns the field-type identifier this codec handles, so generic compression code can branch on what kind of data a container carries. The role is implied by the name; the set of type values it can report is not established here.", + "source": "generated" + }, + "CCompressedStaticShort::GetFlags": { + "text": "Returns the flag bits describing this compressed static short format's properties or capabilities, the value generic code checks before choosing a decode path. Implied by the name; the meaning of individual bits is not established.", + "source": "generated" + }, + "CCompressedStaticShort::GetName": { + "text": "Returns the identifying name of this compressed static short format, useful when logging or selecting a codec by name. Beyond that the purpose is not established, and the class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticShort::GetSizeof": { + "text": "Reports the in-memory size figure associated with this compressed short format, what a caller needs when allocating storage or striding across stored elements. Implied by the name; whether it measures one element, the container, or the codec object itself is not established.", + "source": "generated" + }, + "CCompressedStaticShort::Instantiate": { + "text": "Constructs a working instance of this compressed static short codec, the entry point for obtaining one at runtime. The construction role is implied by the name; where the storage comes from and how the instance is registered are not established.", + "source": "generated" + }, + "CCompressedStaticShort::~CCompressedStaticShort": { + "text": "Destructor for the compressed static short codec, releasing whatever the instance holds when it is torn down. The class is implied by the name; which buffers or containers it frees is not established.", + "source": "generated" + }, + "CCompressedStaticVector2D::CanEncode": { + "text": "Tests whether given two-component vector data can be represented in this static compressed form, letting a compressor choose the format before committing to it. The class and the test are implied by the name; the inputs inspected and the rejection criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::CreateContainer": { + "text": "Allocates the packed storage container holding this format's compressed static 2D-vector data, the target a compressor fills and a decoder later reads. Its role is implied by the name; the container layout and allocation ownership are not established here.", + "source": "generated" + }, + "CCompressedStaticVector2D::DecodeFrame": { + "text": "Reads one frame's worth of two-component vector values back out of a compressed static container for use at playback time. The per-frame decode is implied by the name; the frame indexing and destination conventions are unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::DecodeSize": { + "text": "Reports how large the decoded result of this compressed 2D-vector format is, so a caller can size a destination buffer before decoding. The measurement is implied by the name; whether it counts bytes, elements, or a per-frame stride is not established.", + "source": "generated" + }, + "CCompressedStaticVector2D::DeswizzleAndBlendContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed vector data and blends it into existing values rather than overwriting them, the variant used when a decode must mix into a running result. Both halves are implied by the name; the blend weighting and source/destination roles are unverified.", + "source": "generated" + }, + "CCompressedStaticVector2D::DeswizzleContainer": { + "text": "Unpacks the container's interleaved (swizzled) compressed 2D-vector layout into straight per-element ordering that consuming code can index directly. The de-interleaving is implied by the name; the packing scheme and resulting component ordering are not established.", + "source": "generated" + }, + "CCompressedStaticVector2D::GetFieldType": { + "text": "Returns the field-type identifier this codec handles, letting generic compression code branch on the kind of data a container holds. The role is implied by the name; the set of reportable type values is not established here.", + "source": "generated" + }, + "CCompressedStaticVector2D::GetFlags": { + "text": "Returns the flag bits describing this compressed static 2D-vector format's properties or capabilities, the value generic code inspects before picking a decode path. Implied by the name; the meaning of individual bits is not established.", + "source": "generated" + }, + "CCompressedStaticVector2D::GetName": { + "text": "Returns the identifying name of this compressed static 2D-vector format, useful for logging or selecting a codec by name. Beyond that the purpose is not established, and the class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticVector2D::GetSizeof": { + "text": "Reports the in-memory size figure for this compressed 2D-vector format, what a caller needs to allocate storage or stride across stored elements. Implied by the name; whether it measures one element, the container, or the codec object itself is not established.", + "source": "generated" + }, + "CCompressedStaticVector2D::Instantiate": { + "text": "Constructs a working instance of this compressed static 2D-vector codec, the entry point for obtaining one at runtime. The construction role is implied by the name; the storage it draws on and any registration it performs are not established.", + "source": "generated" + }, + "CCompressedStaticVector2D::~CCompressedStaticVector2D": { + "text": "Destructor for the compressed static 2D-vector codec, releasing whatever the instance holds when it is torn down. The class is implied by the name; which buffers or containers it frees is not established.", + "source": "generated" + }, + "CCompressedStaticVector3::CanEncode": { + "text": "Tests whether a block of static three-component vector data can be represented in this compressed form, so a packer can accept the codec or fall back to another. Read from the name; the owning class is implied by the name, and the accept/reject criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::CreateContainer": { + "text": "Allocates the storage container this codec uses to hold compressed static Vector3 data before encoding or decoding work happens against it. Read from the name; the owning class is implied by the name, so the container's layout and ownership rules are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::DecodeFrame": { + "text": "Decodes one frame's worth of static three-component vector values out of the compressed stream into usable output. Read from the name; the owning class is implied by the name, and the frame addressing and output destination are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::DecodeSize": { + "text": "Reports the size of the decoded static Vector3 data, the value you would need to size an output buffer before decoding. Read from the name; the owning class is implied by the name, so whether it describes one frame or a whole stream is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::DeswizzleAndBlendContainer": { + "text": "Unpacks the codec's swizzled container into per-element Vector3 order while blending the result against another set of values, for when a decoded sample must be weighted rather than used directly. Read from the name; the owning class is implied by the name, and the blending rule is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::DeswizzleContainer": { + "text": "Rearranges the codec's swizzled container back into straightforward per-element Vector3 layout, the plain unpack path without any blending step. Read from the name; the owning class is implied by the name, and the storage orders it converts between are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::GetFieldType": { + "text": "Reports which data field type this codec handles, so a consumer can match a compressed stream to a codec that understands it. Read from the name; the owning class is implied by the name, and the meaning of the returned type value is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::GetFlags": { + "text": "Returns the codec's flag word describing its capabilities or behavior, the kind of value a consumer checks before applying it to a stream. Read from the name; the owning class is implied by the name, and the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::GetName": { + "text": "Returns this codec's identifying name string. Purpose beyond identification is not established, and the owning class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticVector3::GetSizeof": { + "text": "Reports an in-memory size for the codec, the sort of figure an allocator or registry needs when making room for one. Read from the name; the owning class is implied by the name, and whether it measures the codec object or its data is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::Instantiate": { + "text": "Creates a working instance of this compressed static Vector3 codec, the construction entry point a codec registry would use. Read from the name; the owning class is implied by the name, and where the new instance is stored is unverified.", + "source": "generated" + }, + "CCompressedStaticVector3::~CCompressedStaticVector3": { + "text": "Destroys a CCompressedStaticVector3 instance and releases whatever container or scratch memory it was holding. Standard destructor behavior; the owning class is implied by the name in this data.", + "source": "generated" + }, + "CCompressedStaticVector4D::CanEncode": { + "text": "Tests whether a block of static four-component vector data can be represented in this compressed form, letting a packer accept the codec or choose another. Read from the name; the owning class is implied by the name, and the accept/reject criteria are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::CreateContainer": { + "text": "Allocates the storage container this codec uses for compressed static four-component vector data before encode or decode work runs against it. Read from the name; the owning class is implied by the name, so the container's layout and ownership rules are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::DecodeFrame": { + "text": "Decodes one frame's worth of static four-component vector values out of the compressed stream into usable output. Read from the name; the owning class is implied by the name, and the frame addressing and output destination are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::DecodeSize": { + "text": "Reports the size of the decoded four-component vector data, the value you would use to size an output buffer before decoding. Read from the name; the owning class is implied by the name, so whether it covers one frame or a whole stream is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::DeswizzleAndBlendContainer": { + "text": "Unpacks the codec's swizzled container into per-element four-component order while blending the result against another set of values, for when a decoded sample must be weighted rather than taken directly. Read from the name; the owning class is implied by the name, and the blending rule is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::DeswizzleContainer": { + "text": "Rearranges the codec's swizzled container back into straightforward per-element four-component layout, the plain unpack path with no blending step. Read from the name; the owning class is implied by the name, and the storage orders it converts between are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::GetFieldType": { + "text": "Reports which data field type this codec handles, so a consumer can pair a compressed stream with a codec that understands it. Read from the name; the owning class is implied by the name, and the meaning of the returned type value is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::GetFlags": { + "text": "Returns the codec's flag word describing its capabilities or behavior, checked before applying it to a particular stream. Read from the name; the owning class is implied by the name, and the individual flag meanings are unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::GetName": { + "text": "Returns this codec's identifying name string. Purpose beyond identification is not established, and the owning class is implied by the name.", + "source": "generated" + }, + "CCompressedStaticVector4D::GetSizeof": { + "text": "Reports an in-memory size for the codec, the figure an allocator or registry needs when reserving room for one. Read from the name; the owning class is implied by the name, and whether it measures the codec object or its data is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::Instantiate": { + "text": "Creates a working instance of this compressed static four-component vector codec, the construction entry point a codec registry would use. Read from the name; the owning class is implied by the name, and where the new instance is stored is unverified.", + "source": "generated" + }, + "CCompressedStaticVector4D::~CCompressedStaticVector4D": { + "text": "Destroys a CCompressedStaticVector4D instance and releases whatever container or scratch memory it was holding. Standard destructor behavior; the owning class is implied by the name in this data.", + "source": "generated" + }, + "CCredits::InputRollCredits": { + "text": "Handles the `RollCredits` entity-IO input on `CCredits`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCredits::InputRollOutroCredits": { + "text": "Handles the `RollOutroCredits` entity-IO input on `CCredits`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCredits::InputSetLogoLength": { + "text": "Handles the `SetLogoLength` entity-IO input on `CCredits`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCredits::InputShowLogo": { + "text": "Handles the `ShowLogo` entity-IO input on `CCredits`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CCustomGameEventManager::ScriptSend_ServerToPlayer": { + "text": "Sends a custom game event from the server to one specific player rather than broadcasting it, exposed under a ScriptSend_ prefix that marks it as the script-facing binding. Read from the name; it is located by signature in libserver, so the payload encoding and how the target player is addressed are unverified.", + "source": "generated" + }, + "CDOTABehaviorAbility::OnAnimationActivityComplete": { + "text": "Handles the moment the owning unit's current animation activity finishes playing, the hook a behavior ability uses to react once its animation has run out. Read from the name; the CDOTABehaviorAbility class is implied by the name, and what the handler does in response is unverified.", + "source": "generated" + }, + "CDOTABehaviorAbility::OnAnimationEvent": { + "text": "Handles an event fired from within the owning unit's playing animation, letting a behavior ability act on tagged moments in a sequence. Read from the name; the CDOTABehaviorAbility class is implied by the name, and which events reach this handler is unverified.", + "source": "generated" + }, + "CDOTABehaviorAbility::OnInvalidatePath": { + "text": "Reacts to the owning unit's movement path being invalidated, giving a behavior ability a chance to drop or recompute cached path state. Read from the name; the CDOTABehaviorAbility class is implied by the name, and the cleanup it actually performs is unverified.", + "source": "generated" + }, + "CDOTABehaviorAbility::OnKilled": { + "text": "Reacts to the owning unit being killed, the point at which a behavior ability would end or tear down the behavior it was driving. Read from the name; the CDOTABehaviorAbility class is implied by the name, and the death context it receives is unverified.", + "source": "generated" + }, + "CDOTABehaviorAbility::OnModelChanged": { + "text": "Reacts to the owning unit's model being swapped out, letting a behavior ability refresh anything bound to the previous model. Read from the name; the CDOTABehaviorAbility class is implied by the name, and what it refreshes is unverified.", + "source": "generated" + }, + "CDOTABehaviorAbility::OnUnitTeleported": { + "text": "Reacts to the owning unit being teleported, so a behavior ability can reset position-dependent state instead of continuing from a stale location. Read from the name; the CDOTABehaviorAbility class is implied by the name, and the reset it performs is unverified.", + "source": "generated" + }, + "CDOTAConsumableEconItem::NotifyGC": { + "text": "Notifies the Game Coordinator backend about this consumable economy item, the path used when a consumable's state has to be recorded outside the game server. Read from the name; it is located by signature in libserver, and the contents and trigger conditions of the notification are unverified.", + "source": "generated" + }, + "CDOTAConsumableEconItem::RequiresGC": { + "text": "Reports whether this consumable economy item needs Game Coordinator involvement, letting the server skip backend work for consumables that can be handled locally. Read from the name; it is located by signature in libserver, and the conditions it tests are unverified.", + "source": "generated" + }, + "CDOTAConsumableEconItem::ShouldSendServerPlayers": { + "text": "Reports whether the server's player list should be included when this consumable economy item is reported, gating that part of the item's bookkeeping. Read from the name; it is located by signature in libserver, so what consumes the answer is unverified.", + "source": "generated" + }, + "CDOTAHeroEconItemAbility::CanUse": { + "text": "Decides whether a hero's econ-item ability is usable right now, with the embedded string 'gamemode restricted' pointing at a game-mode eligibility test as one of the rejection reasons. The rest of the gating is read from the name and is not derived here.", + "source": "generated" + }, + "CDOTA_BaseNPC::UnitThink": { + "text": "Runs a DOTA unit's periodic think step, the recurring per-unit update that advances the NPC's own state. Read from the name and the class's m_nNextUnitThink field, which schedules the next such update; no prototype is derived, so the work performed and its cadence are unverified.", + "source": "generated" + }, + "CDOTA_BotAction::OnAbilityExecuted": { + "text": "Lets a bot action react to an ability having been executed, so an in-progress plan can be updated or abandoned. Read from the name; this data does not establish whose cast is reported or what state the handler changes.", + "source": "generated" + }, + "CDOTA_BotAction::OnAttacked": { + "text": "Handles the notification that the bot has been attacked while this action is running, giving the action a chance to respond. Read from the name; the attacker information supplied and the resulting behaviour change are not derived.", + "source": "generated" + }, + "CDOTA_BotAction::OnDidDamage": { + "text": "Handles the notification that the bot dealt damage during this action, the hook an action uses to track its own output. Read from the name; what gets recorded and how it steers the action are not derived.", + "source": "generated" + }, + "CDOTA_BotAction::OnEnd": { + "text": "Performs the bot action's teardown when the action finishes, releasing whatever the action was holding. Read from the name; a prototype is derived for this entry, but the specific cleanup work is not.", + "source": "generated" + }, + "CDOTA_BotAction::OnTakeDamage": { + "text": "Handles the bot taking damage while this action is active, the signal an action needs to notice that its plan is getting the bot killed. Read from the name; the actual reaction is not derived.", + "source": "generated" + }, + "CDOTA_BotAction::ShouldBeQueued": { + "text": "Reports whether this action should be queued behind the bot's current work rather than taking over immediately, which is how a bot's pending actions stay in order. A prototype is derived, but the conditions the test applies are read from the name only.", + "source": "generated" + }, + "CDOTA_BotAction_DispenseWard::OnStart": { + "text": "Begins the bot's ward-dispensing action, setting up the placement when the action starts; the embedded string 'CDOTA_Bot::Action_Attack called with NULL target.' indicates a guard that complains when an action is begun without a target. The setup details themselves are read from the name.", + "source": "generated" + }, + "CDOTA_BotAction_MoveTo::Think": { + "text": "Advances the bot's move-to action each thinking step, steering toward the destination and emitting 'Failed pathfind by %s, location %2.0f %2.0f %2.0f' when no path to that spot can be found, which is the log line to watch when scripted bot movement stalls. Beyond that, the per-step logic is read from the name.", + "source": "generated" + }, + "CDOTA_BotMode::GetDebugValue": { + "text": "Supplies the bot mode's debug figure, the quantity surfaced in bot debugging output next to the mode's text label. A prototype is derived, but what the value measures is read from the name only.", + "source": "generated" + }, + "CDOTA_BotMode::GetDesiredLocation": { + "text": "Reports the world position the bot mode wants the hero to be at \u2014 the anchor point a mode uses to pull the bot toward its objective. A prototype is derived, but how each mode picks that location is not.", + "source": "generated" + }, + "CDOTA_BotMode::OnAbilityExecuted": { + "text": "Lets the active bot mode react to an ability being executed, updating the mode's read on the situation. Taken from the name; this data does not establish whose cast is reported or what the mode changes in response.", + "source": "generated" + }, + "CDOTA_BotMode::OnAttacked": { + "text": "Lets the bot mode respond to the bot being attacked, for instance by reconsidering whether the current mode still fits. Read from the name; the attacker details supplied and the resulting behaviour are not derived.", + "source": "generated" + }, + "CDOTA_BotMode::OnDidDamage": { + "text": "Lets the bot mode register that the bot dealt damage, feeding the mode's assessment of how a fight is going. Read from the name; what is recorded and how it shifts the mode are not derived.", + "source": "generated" + }, + "CDOTA_BotMode_AssembleWithHumans::GetDebugString": { + "text": "Builds the debug label 'Assembling with Humans - %s', filling in what the bot is grouping up on. Read it in bot debug output to confirm a bot has decided to regroup with its human teammates.", + "source": "generated" + }, + "CDOTA_BotMode_AssembleWithHumans::GetDesire": { + "text": "Scores how strongly the bot wants to group up with human players at this moment \u2014 the desire figure used to weigh this mode against the alternatives. Its own name is the string anchor, so the inputs to the score are read from the name rather than derived.", + "source": "generated" + }, + "CDOTA_BotMode_AssembleWithHumans::Think": { + "text": "Runs the per-step work of the assemble-with-humans mode, keeping the bot moving toward its human teammates while the mode is active. Its own name is the string anchor, so the concrete grouping logic is a name-level reading.", + "source": "generated" + }, + "CDOTA_BotMode_Assemble_Human::GetDebugString": { + "text": "Produces the debug label 'Inferred Assembling' for the human-inferred assemble mode, which is what the bot AI shows when it deduces that a human player is grouping up. Useful for telling inferred human intent apart from a bot's own assemble mode in debug output.", + "source": "generated" + }, + "CDOTA_BotMode_DefendAlly::GetDebugString": { + "text": "Formats the debug label 'Defending ally - %s from %s', naming the teammate being protected and the threat. Read it in bot debug output to see which ally a bot has committed to defending and against whom.", + "source": "generated" + }, + "CDOTA_BotMode_DefendAlly_Human::GetDebugString": { + "text": "Formats 'Inferred Ally Defense - %s from %s' for the human-inferred version of ally defence, naming the ally and the threat the bot believes a human is answering. Use it to separate inferred human intent from a bot's own defend-ally mode.", + "source": "generated" + }, + "CDOTA_BotMode_DefendTower::GetDebugString": { + "text": "Formats the debug label 'Defending %s Tower' with the tower the bot is holding. Read it in bot debug output to see which building a defending bot has committed to.", + "source": "generated" + }, + "CDOTA_BotMode_DefendTower_Human::GetDebugString": { + "text": "Formats 'Inferred Defending %s Tower- %1.3f' for the human-inferred tower-defence mode, naming the tower plus a further figure the mode tracks. Useful when checking what the bot AI believes a human player is defending.", + "source": "generated" + }, + "CDOTA_BotMode_Farm::GetDebugString": { + "text": "Formats the debug label 'Farm - Neutral camp at (%.0f, %.0f)' with the coordinates of the neutral camp the bot has settled on. Read it to see exactly which camp a farming bot is heading for.", + "source": "generated" + }, + "CDOTA_BotMode_Farm_Human::GetDebugString": { + "text": "Produces the debug label 'Inferred Farming' for the human-inferred farm mode, which is what the bot AI reports when it reads a human player as farming. Handy for distinguishing inferred human behaviour from a bot's own farm mode.", + "source": "generated" + }, + "CDOTA_BotMode_PushTower::GetDebugString": { + "text": "Formats the debug label 'Pushing %s Lane' with the lane the bot is pushing. Read it in bot debug output to confirm which lane a bot has committed to pressuring.", + "source": "generated" + }, + "CDOTA_BotMode_PushTower_Human::GetDebugString": { + "text": "Formats 'Inferred Pushing %s Lane' for the human-inferred push mode, naming the lane the bot AI believes a human player is pushing. Use it to tell inferred human pressure apart from a bot's own push mode in debug output.", + "source": "generated" + }, + "CDOTA_BotMode_Retreat::OnEnd": { + "text": "Performs the retreat mode's teardown once the bot stops running away, clearing whatever the mode was holding. A prototype is derived for this entry, but the specific cleanup is read from the name only.", + "source": "generated" + }, + "CDOTA_BotMode_Retreat::OnTakeDamage": { + "text": "Lets the retreat mode react to damage taken while the bot is fleeing \u2014 the input a retreat needs to notice that escaping is failing. Read from the name; the actual response is not derived.", + "source": "generated" + }, + "CDOTA_BotMode_Retreat_Human::GetDebugString": { + "text": "Produces the debug label 'Inferred Retreating' for the human-inferred retreat mode, shown when the bot AI reads a human player as pulling out. Useful for separating inferred human intent from a bot's own retreat mode in debug output.", + "source": "generated" + }, + "CDOTA_BotMode_Roam::GetDebugString": { + "text": "Formats the debug label 'Roaming towards lane %s - target %s', naming the lane the bot is roaming to and the target it has in mind. Read it to see a roaming bot's destination and intended victim.", + "source": "generated" + }, + "CDOTA_BotMode_Roam::OnEnd": { + "text": "Wraps up the roam mode once the bot stops roaming, and carries the localisation token 'DOTA_Chat_Bot_RoamLane' \u2014 the team-chat line about a bot roaming to a lane. The teardown is read from the name, and the conditions attached to that chat message are not derived.", + "source": "generated" + }, + "CDOTA_BotMode_Roam_Human::GetDebugString": { + "text": "Formats 'InferredRoaming towards lane %s - target %s' for the human-inferred roam mode, naming the lane and target the bot AI believes a human is heading for. Read it to see what a bot expects its human teammate to gank.", + "source": "generated" + }, + "CDOTA_BotMode_Roshan::GetDebugString": { + "text": "Formats the debug label 'Roshan - %2.2f' with one figure the Roshan mode tracks; the format string does not name that quantity. Read it in bot debug output to see when bots are weighing or committing to a Roshan attempt.", + "source": "generated" + }, + "CDOTA_BotMode_Roshan_Human::GetDebugString": { + "text": "Formats 'Inferred Roshan - (%2.2f %2.2f)' for the human-inferred Roshan mode, carrying two figures the mode tracks that the format string does not name. Useful for checking when the bot AI believes human players are going for Roshan.", + "source": "generated" + }, + "CDOTA_BotMode_TeamRoam::CalculateDesiredLocation": { + "text": "Computes the map position the team-roaming bot mode wants to move toward; the `dota_bot_debug_force_lotus_pool` string sits inside it, a debug override that pins that destination at a lotus pool. Hook this when changing where grouped bots roam, though the exact inputs behind the choice are unverified.", + "source": "generated" + }, + "CDOTA_BotMode_TutorialBoss::GetDebugString": { + "text": "Builds the debug text describing the tutorial-boss bot mode's state, with `TutorialBoss` present verbatim as literal text inside it. Read it when dumping bot-mode state to a debug overlay or console; the label's full contents are unverified.", + "source": "generated" + }, + "CDOTA_BotMode_TutorialBoss::OnEnd": { + "text": "Runs the teardown for the tutorial-boss bot mode when that mode stops being the bot's active mode. Read from the name; a prototype is derived, but what state it clears is unverified.", + "source": "generated" + }, + "CDOTA_BotMode_Ward::GetDebugColor": { + "text": "Supplies the color used to draw the ward bot mode in bot debug visualization, so each mode is distinguishable on screen. Read from the name; the color encoding and where it is drawn are unverified.", + "source": "generated" + }, + "CDOTA_Bot_AbilityUsage::ClearsIllusionState": { + "text": "Reports whether the ability this usage handler drives clears an illusion-related state, letting bot ability scoring account for that effect. Read from the name; a prototype is derived, but the specific state involved is unverified.", + "source": "generated" + }, + "CDOTA_Bot_AbilityUsage::FindFilter": { + "text": "Looks up the filter the bot ability-usage layer applies when narrowing candidates for this ability. Read from the name; no prototype is derived here, so the inputs and what the filter selects on are unverified.", + "source": "generated" + }, + "CDOTA_Bot_AbilityUsage::ShouldBreakChannel": { + "text": "Decides whether the bot should interrupt a channelled ability rather than let the channel continue. Override it on a custom ability-usage handler to control bot channel discipline; read from the name, with the deciding conditions unverified.", + "source": "generated" + }, + "CDOTA_Bot_AbilityUsage::UseOnIllusionState": { + "text": "Sets the illusion-state condition governing when this ability usage applies, named as the counterpart to CDOTA_Bot_AbilityUsage::ClearsIllusionState's query. Read from the name; a prototype is derived, but the state values it accepts are unverified.", + "source": "generated" + }, + "CDOTA_Bot_AbilityUsage_Axe_CullingBlade::GetCurrentUsageDesire": { + "text": "Scores how strongly the bot currently wants to cast Axe's Culling Blade; the `kill_threshold_scepter` ability special appears inside it, the scepter execute threshold the desire is weighed against. Copy this shape when writing desire scoring for a custom ability; the desire scale is unverified.", + "source": "generated" + }, + "CDOTA_Bot_AbilityUsage_Necrolyte_Scythe::GetCurrentUsageDesire": { + "text": "Scores how strongly the bot currently wants to cast Necrolyte's Scythe, with the `damage_per_health_scepter` ability special present inside it as the scepter damage value the lethality judgement leans on. Read from that anchor and the name; the desire scale is unverified.", + "source": "generated" + }, + "CDOTA_SpeechCallbackForwardToPlayersAnnouncer::Go": { + "text": "Fires the announcer speech callback out to players, with `heroname` present as a substitution key filled into the spoken line. Use it as the hook point when forwarding custom announcer lines; the recipient selection is unverified.", + "source": "generated" + }, + "CDOTA_Tiny_ScepterTree::Spawn": { + "text": "Performs the entity spawn-time setup for Tiny's scepter tree as it is created in the world. The class is implied by the name rather than bound by the data \u2014 this sits in an unbound vtable slot, so the owner is unconfirmed.", + "source": "generated" + }, + "CDOTA_Unit_Hero_Beastmaster_Beasts::OnKilledThink": { + "text": "Runs the think step handling Beastmaster's summoned beasts once the unit has been killed, continuing per-tick logic through the death. The class is implied by the name, not established by the data, since this is an unbound vtable slot.", + "source": "generated" + }, + "CDecalGameSystem::LoopInit": { + "text": "Performs the decal game system's loop-initialization stage as the engine brings game systems up for a session. The class is implied by the name \u2014 the slot is unbound \u2014 and what the decal system prepares here is unverified.", + "source": "generated" + }, + "CDefSaveRestoreBlockHandler::PostRestore": { + "text": "Runs the fix-up pass after this save block's data has been read back, letting the handler resolve anything that could not be settled during the read. Read from the name; a prototype is derived, but the fix-ups performed are unverified.", + "source": "generated" + }, + "CDefSaveRestoreBlockHandler::PostSave": { + "text": "Runs the cleanup pass after this handler's save block has been written out. Read from the name; no prototype is derived here, so what it releases or restores is unverified.", + "source": "generated" + }, + "CDefSaveRestoreBlockHandler::PreRestore": { + "text": "Prepares handler state before its save block is read back, giving it a chance to clear or stage data ahead of the incoming values. Read from the name; a prototype is derived, though the preparation itself is unverified.", + "source": "generated" + }, + "CDefSaveRestoreBlockHandler::PreSave": { + "text": "Prepares handler state before its save block is written, so the captured data is consistent at write time. Read from the name; no prototype is derived here, and the specific preparation is unverified.", + "source": "generated" + }, + "CDefSaveRestoreBlockHandler::Restore": { + "text": "Reads a saved data block back into live game state; the `g_bInCommentaryMode` global appears inside it, indicating commentary-mode state travels this restore path. Read from that anchor and the name \u2014 the block format and the commentary interaction are unverified.", + "source": "generated" + }, + "CDemoFile::Close": { + "text": "Closes an open demo file, releasing the handle and finishing the recording or playback it backs. The class is implied by the name, this being an unbound vtable slot, although a prototype is derived for it.", + "source": "generated" + }, + "CDynamicLight::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CDynamicLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicLight::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CDynamicLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicLight::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CDynamicLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::AnimThink": { + "text": "Advances the dynamic prop's animation think, driving the random-animator scheduling configured by m_bRandomAnimator, m_flNextRandAnim, m_flMinRandAnimDuration and m_flMaxRandAnimDuration. The class is implied by the name, this being an unbound vtable slot; the think's timing is unverified.", + "source": "generated" + }, + "CDynamicProp::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputDisableCollision": { + "text": "Handles the `DisableCollision` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputEnableCollision": { + "text": "Handles the `EnableCollision` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimation": { + "text": "Handles the `SetAnimation` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationLooping": { + "text": "Handles the `SetAnimationLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationNoReset": { + "text": "Handles the `SetAnimationNoReset` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationNoResetLooping": { + "text": "Handles the `SetAnimationNoResetLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationNoResetNotLooping": { + "text": "Handles the `SetAnimationNoResetNotLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetAnimationNotLooping": { + "text": "Handles the `SetAnimationNotLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetDefaultAnimationNotLooping": { + "text": "Handles the `SetDefaultAnimationNotLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetGlowOverride": { + "text": "Handles the `SetGlowOverride` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetGlowRange": { + "text": "Handles the `SetGlowRange` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetIdleAnimation": { + "text": "Handles the `SetDefaultAnimation` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetIdleAnimationNotLooping": { + "text": "Handles the `SetIdleAnimationNotLooping` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputSetPlaybackRate": { + "text": "Handles the `SetPlaybackRate` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputStartGlowing": { + "text": "Handles the `StartGlowing` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputStopGlowing": { + "text": "Handles the `StopGlowing` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CDynamicProp::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CDynamicProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEconItemView::CanAddSockets": { + "text": "Reports whether more sockets can still be added to the item this view wraps. Read from the name and the view's m_AttributeList; the rules it applies, such as definition limits or existing socket count, are not established by this data.", + "source": "generated" + }, + "CEconItemView::GetAccountID": { + "text": "Returns the account identifier stored on the item view in m_iAccountID, identifying whose item this is. Read from the name and that field; its behaviour on a view where m_bInitialized is false is not established here.", + "source": "generated" + }, + "CEconItemView::GetCustomDesc": { + "text": "Retrieves the custom description text set on the item this view wraps, as distinct from the item definition's stock description. Read from the name; where the string comes from, and what it yields when no custom description exists, are not established here.", + "source": "generated" + }, + "CEconItemView::GetCustomName": { + "text": "Retrieves the custom name a player has given the item this view wraps, rather than the definition's stock name. Read from the name; the string's storage and the unnamed-item case are not established by this data.", + "source": "generated" + }, + "CEconItemView::GetDataDescMap": { + "text": "Returns the data description map for this item view, the field table by which engine code describes the type. Read from the name; the map's contents and how the engine consumes it are not established by this data.", + "source": "generated" + }, + "CEconItemView::GetFlags": { + "text": "Returns the flag bits carried on the item view, corresponding to the m_unClientFlags field. Read from the name and that field; the meaning of individual bits is not established by this data.", + "source": "generated" + }, + "CEconItemView::GetGemInfo": { + "text": "Retrieves the gem information associated with a socket on this item view. Read from the name and its pairing with CEconItemView::IsSocketable; what a gem record holds, and how a socket is selected, are not established here.", + "source": "generated" + }, + "CEconItemView::GetInUse": { + "text": "Reports whether the item this view wraps is currently in use. Read from the name; what counts as in-use, and where that state is stored, are not established by this data.", + "source": "generated" + }, + "CEconItemView::GetInventoryToken": { + "text": "Returns the inventory token for the item this view wraps, the value locating it within the owner's inventory and plausibly backed by m_iInventoryPosition. Read from the name and that field; the token's encoding is unverified.", + "source": "generated" + }, + "CEconItemView::GetItemDefinition": { + "text": "Resolves the item definition behind this view and touches item expiry, since the string \"expiration date\" is anchored in this function. The view's stored m_iItemDefinitionIndex is what the lookup keys on; whether an expired item still resolves a definition is not established by this data.", + "source": "generated" + }, + "CEconItemView::GetItemID": { + "text": "Returns the unique item identifier held in m_iItemID for the item this view wraps. Read from the name and that field; whether the value is meaningful before m_bInitialized is set is unverified.", + "source": "generated" + }, + "CEconItemView::GetItemLevel": { + "text": "Returns the item's level, corresponding to the m_iEntityLevel field on the view. Read from the name and that field; whether the value is read directly or resolved through the item definition is not established here.", + "source": "generated" + }, + "CEconItemView::GetOrigin": { + "text": "Returns the item's origin value, tracked on the view as m_unOverrideOrigin. Read from the name and that field; whether \"origin\" here means an acquisition-source code or something positional is not established by this data.", + "source": "generated" + }, + "CEconItemView::GetQuality": { + "text": "Returns the quality tier of the item this view wraps, corresponding to m_iEntityQuality. Read from the name and that field; the numeric quality scale and any definition-level fallback are not established by this data.", + "source": "generated" + }, + "CEconItemView::GetQuantity": { + "text": "Returns the stack quantity for the item this view wraps, corresponding to m_iEntityQuantity. Read from the name and that field; how unstackable items report through it is not established here.", + "source": "generated" + }, + "CEconItemView::GetStyle": { + "text": "Returns the style index selected for the item, with m_nOverrideStyle holding the view's stored override. Read from the name and that field; whether an unset override falls back to a default style is not established by this data.", + "source": "generated" + }, + "CEconItemView::IsSocketable": { + "text": "Reports whether the item this view wraps accepts sockets at all. Read from the name; it pairs with CEconItemView::CanAddSockets when you need both eligibility and remaining capacity, though the distinction between the two is unverified.", + "source": "generated" + }, + "CEconItemView::IsStyleUnlocked": { + "text": "Reports whether a given style is unlocked for this item, consulting stored unlock state \u2014 the string \"unlocked styles\" is anchored in this function. Use it alongside CEconItemView::GetStyle when validating m_nOverrideStyle; the storage format of the unlocked set is unverified.", + "source": "generated" + }, + "CEconItemView::IterateAttributes": { + "text": "Walks the attributes attached to this item view, visiting each in turn; the view's m_AttributeList, a CAttributeList, is the collection involved. Read from the name and that field; the iteration protocol it exposes is not established by this data.", + "source": "generated" + }, + "CEconItemView::Schema_DynamicBinding": { + "text": "Provides the runtime schema binding for CEconItemView, the hook by which schema tooling resolves this type's fields at runtime. Read from the name; how the schema system consumes it is not established by this data.", + "source": "generated" + }, + "CEconStyleInfo::BInitFromKV": { + "text": "Parses a style definition out of a KeyValues block into CEconStyleInfo \u2014 the key string \"entity_scale_flying\" is anchored here, so model and scale style entries are among what it reads. No prototype is derived and the class carries no schema fields, so the remaining keys and the failure behaviour are unverified.", + "source": "generated" + }, + "CEngineAppSystemGroup::MainLoop": { + "text": "Runs the engine application's main loop in libengine2, driving frame iteration for the app system group. Read from the name at low confidence with no prototype derived, so the loop's structure and exit conditions are unverified.", + "source": "generated" + }, + "CEngineServer::GetClientConVarValue": { + "text": "Fetches the value a named console variable currently holds on a specific client, the server-side way to query a client's cvar state. The owning class CEngineServer is implied by the name; this is an unbound vtable slot with no class in the data, so the interface it belongs to is unverified.", + "source": "generated" + }, + "CEngineServer::SetFakeClientConVarValue": { + "text": "Sets a console variable's value on a fake (bot) client, giving bots the cvar state a real client would report itself. The class CEngineServer is implied by the name; this is an unbound vtable slot with no class in the data, so the owning interface is unverified.", + "source": "generated" + }, + "CEngineServiceMgr::SleepAfterMainLoop": { + "text": "Sleeps or yields after a main-loop pass, pacing the engine's loop rate rather than spinning. Read from the name in libengine2 with no prototype derived, so the sleep duration and the condition for sleeping are unverified.", + "source": "generated" + }, + "CEngineServiceMgr::SwitchToLoop": { + "text": "Switches the engine service manager to a different named loop, the mode change behind moving between menu, level and other engine loops. The class CEngineServiceMgr is implied by the name; this is an unbound vtable slot, so the owning interface and the loop identifiers it accepts are unverified.", + "source": "generated" + }, + "CEngineServiceMgr::_MainLoop": { + "text": "Runs the engine service manager's main loop in libengine2, the per-iteration driver for whichever loop is currently active. Read from the name with no prototype derived, so what a single iteration actually performs is unverified.", + "source": "generated" + }, + "CEntityComponentHelperT::Allocate": { + "text": "Allocates a CBodyComponentPoint body component, the template helper instantiation that supplies point-body components to entities. Read from the name and its template argument at low confidence with no prototype derived, so the allocation source and the component's lifetime are unverified.", + "source": "generated" + }, + "CEntityDataInstantiator::CreateDataObject": { + "text": "Creates a CWatcherList data object and attaches it to an entity, giving that entity watcher-list storage held outside its own layout. Keyed by CEntityInstance; use it when an entity needs such storage added, though the container backing the association is unverified.", + "source": "generated" + }, + "CEntityDataInstantiator::DestroyDataObject": { + "text": "Destroys the CWatcherList data object held for an entity and releases its storage. Keyed by CEntityInstance; whether it tolerates an entity that has no such object attached is not established by this data.", + "source": "generated" + }, + "CEntityDataInstantiator::GetDataObject": { + "text": "Retrieves the CWatcherList data object already attached to an entity, as a lookup rather than a create. Keyed by CEntityInstance; what it yields when no object exists for that entity is not established here.", + "source": "generated" + }, + "CEntityDataInstantiator::CreateDataObject": { + "text": "Creates a groundlink_t data object for an entity, attaching per-entity ground-link storage of the kind that tracks ground contact relationships. Keyed by CEntityInstance; the record's contents and the exact meaning of a ground link are unverified.", + "source": "generated" + }, + "CEntityDataInstantiator::DestroyDataObject": { + "text": "Destroys the groundlink_t data object held for an entity and releases its storage. Keyed by CEntityInstance; whether it tolerates an entity with no ground-link object attached is not established by this data.", + "source": "generated" + }, + "CEntityDataInstantiator::GetDataObject": { + "text": "Retrieves the groundlink_t data object already attached to an entity, as a lookup rather than a create. Keyed by CEntityInstance; what it yields when the entity has no such object is not established here.", + "source": "generated" + }, + "CEntityDataInstantiator::CreateDataObject": { + "text": "Allocates a physicspushlist_t data object and attaches it to an entity, providing the per-entity push-list storage used by physics pushing. Read from the name and the template parameter; the allocation and attachment mechanics are not established by this data.", + "source": "generated" + }, + "CEntityDataInstantiator::DestroyDataObject": { + "text": "Releases the physicspushlist_t data object attached to an entity, freeing that per-entity storage. Read from the name; pair it with CEntityDataInstantiator::CreateDataObject when managing push-list lifetime on entities you touch.", + "source": "generated" + }, + "CEntityDataInstantiator::GetDataObject": { + "text": "Looks up the physicspushlist_t data object already attached to an entity so callers can inspect or mutate the push list. Read from the name; whether it creates the object when one is absent is not established here.", + "source": "generated" + }, + "CEntityDissolve::InputDissolve": { + "text": "Handles the `Dissolve` entity-IO input on `CEntityDissolve`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEntityInstance::Precache": { + "text": "Performs an entity's precache work, the hook where an entity type registers assets it will need before gameplay uses them. The class is implied by the name, sitting at an unbound vtable slot, so the owning object and precache context are unverified.", + "source": "generated" + }, + "CEntityInstance::UpdateOnRemove": { + "text": "Runs an entity's teardown as it is being removed, where a type drops references, stops effects, and detaches from systems. The class is implied by the name, so the owning type and exactly what state it clears are unverified.", + "source": "generated" + }, + "CEntityKeyValues::LegacyUnserializeKeys": { + "text": "Parses entity key/value pairs from the older, pre-KV3 serialized form into a CEntityKeyValues block. Read from the name at low confidence, alongside its presence in libworldrenderer with map and world entity data; the legacy format itself is not established here.", + "source": "generated" + }, + "CEntityKeyValues::LoadFromKV3": { + "text": "Populates a CEntityKeyValues object from KV3 data, the keyvalues format entity properties are authored and shipped in. Read from the name at low confidence; the accepted KV3 flavours and the behaviour on malformed input are not established here.", + "source": "generated" + }, + "CEntityKeyValues::Unserialize": { + "text": "Reads a serialized entity keyvalues blob back into a live CEntityKeyValues object, a general deserialization entry point for entity properties. Read from the name; which encoding it expects, and how it relates to CEntityKeyValues::LoadFromKV3, are not established by this data.", + "source": "generated" + }, + "CEntityReport::Add": { + "text": "Registers an entity with the report so it is tracked by the entity accounting and diagnostics this class collects. The class is implied by the name, so the report object's storage and what it does with the entry are unverified.", + "source": "generated" + }, + "CEntityReport::DeleteEntity": { + "text": "Notes an entity's deletion in the report so the tracking data reflects entities that have gone away. The class is implied by the name; the bookkeeping performed on the deletion is unverified.", + "source": "generated" + }, + "CEntityReport::LeavePVS": { + "text": "Notes that an entity has left the potentially visible set, letting the report account for entities that stop being replicated. The class is implied by the name, so the PVS scope \u2014 per-client or global \u2014 is unverified.", + "source": "generated" + }, + "CEntityReport::NetworkPacketFinished": { + "text": "Marks the completion of a network packet for reporting purposes, giving the entity report a per-packet boundary to aggregate its counters against. The class is implied by the name; the aggregation it performs is unverified.", + "source": "generated" + }, + "CEntityReport::Record": { + "text": "Records an entity event together with its associated data, a data-capture entry point for entity reporting. The class is implied by the name, so what is captured and where it is stored are unverified.", + "source": "generated" + }, + "CEntityReport::~CEntityReport": { + "text": "Destroys the entity report object and releases the tracking storage it holds. The class is implied by the name, and as a destructor it should not be expected to carry reporting behaviour beyond cleanup.", + "source": "generated" + }, + "CEntitySaveRestoreBlockHandler::PreSave": { + "text": "Prepares entities for a save and warns `PreSave(%d): entity identity is missing, may cause a crash` when an entity lacks its identity. Treat it as save-time entity validation: entities a mod creates must hold a valid CEntityIdentity before a save is taken.", + "source": "generated" + }, + "CEntitySaveRestoreBlockHandler::Restore": { + "text": "Restores world entity state from save data, logging `%s: restoring world from save data` while doing so. It is the load-side counterpart to CEntitySaveRestoreBlockHandler::Save for the entity block of a save file.", + "source": "generated" + }, + "CEntitySaveRestoreBlockHandler::Save": { + "text": "Writes the entity block of a save file, tagged in the binary with `Entity KV3 Write`, indicating entity state is serialized as KV3. Persistent entity state added by a mod should be expected to travel through this KV3 write path.", + "source": "generated" + }, + "CEntitySpawner::StartNewEntity": { + "text": "Begins construction of a new `CBaseEntity` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawner::StartNewEntity": { + "text": "Begins construction of a new `CDOTA_BaseNPC` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawner::StartNewEntity": { + "text": "Begins construction of a new `CDOTA_DeathProphet_Exorcism_Spirit` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawner::StartNewEntity": { + "text": "Begins construction of a new `CDotaQuest` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawner::StartNewEntity": { + "text": "Begins construction of a new `CDotaSubquestBase` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawner::StartNewEntity": { + "text": "Begins construction of a new `CDynamicProp` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawner::StartNewEntity": { + "text": "Begins construction of a new `CItemGenericTriggerHelper` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawner::StartNewEntity": { + "text": "Begins construction of a new `CTriggerMultiple` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerAsyncBase::StartNewEntity": { + "text": "Begins construction of a new `CBaseEntity` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerAsyncBase::StartNewEntity": { + "text": "Begins construction of a new `CPhysicsProp` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CBaseEntity` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CBaseEntity` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTABaseAbility` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDOTABaseAbility` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTATeam` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_BaseNPC` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDOTA_BaseNPC` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_DeathProphet_Exorcism_Spirit` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDOTA_DeathProphet_Exorcism_Spirit` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_Hero_Recorder` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_Item` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_Item_Physical` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDOTA_Item_Physical` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_Item_Rune` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDOTA_Item_Rune` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_Pet_CarriedItem` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDOTA_Pet_CarriedItem` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_TempTree` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDOTA_TempTree` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_Unit_Announcer` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDOTA_Unit_Courier` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDOTA_Unit_Courier` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDotaQuest` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDotaQuest` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDotaSubquestBase` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDotaSubquestBase` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CDynamicProp` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CDynamicProp` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CEntityDissolve` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CEntityDissolve` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CItemGenericTriggerHelper` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CItemGenericTriggerHelper` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CPhysicsProp` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CPhysicsProp` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEntitySpawnerBase::OnEntitySpawned": { + "text": "Notification hook invoked for the spawner when a `CTriggerMultiple` entity finishes spawning.", + "source": "derived" + }, + "CEntitySpawnerBase::StartNewEntity": { + "text": "Begins construction of a new `CTriggerMultiple` entity for the spawner that owns this factory.", + "source": "derived" + }, + "CEnvBeam::InputStrikeOnce": { + "text": "Handles the `StrikeOnce` entity-IO input on `CEnvBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvBeam::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CEnvBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvBeam::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CEnvBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvBeam::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CEnvBeam`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvCubemapFog::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CEnvCubemapFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvCubemapFog::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvCubemapFog`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvDeferredLight::InputSetLightColor": { + "text": "Handles the `LightColor` entity-IO input on `CEnvDeferredLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvDeferredLight::InputSetLightIntensity": { + "text": "Handles the `Intensity` entity-IO input on `CEnvDeferredLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvDeferredLight::InputSetLightRadius": { + "text": "Handles the `Radius` entity-IO input on `CEnvDeferredLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvDeferredLight::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CEnvDeferredLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvDeferredLight::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CEnvDeferredLight`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvEntityMaker::InputForceSpawn": { + "text": "Handles the `ForceSpawn` entity-IO input on `CEnvEntityMaker`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvEntityMaker::InputForceSpawnAtEntityOrigin": { + "text": "Handles the `ForceSpawnAtEntityOrigin` entity-IO input on `CEnvEntityMaker`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvExplosion::InputExplode": { + "text": "Handles the `Explode` entity-IO input on `CEnvExplosion`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvFade::InputFade": { + "text": "Handles the `Fade` entity-IO input on `CEnvFade`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputAddToCounter": { + "text": "Handles the `AddToCounter` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputGetCounter": { + "text": "Handles the `GetCounter` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputRemove": { + "text": "Handles the `Remove` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputSetCounter": { + "text": "Handles the `SetCounter` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvGlobal::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CEnvGlobal`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvInstructorHint::InputEndHint": { + "text": "Handles the `EndHint` entity-IO input on `CEnvInstructorHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvInstructorHint::InputShowHint": { + "text": "Handles the `ShowHint` entity-IO input on `CEnvInstructorHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvInstructorVRHint::InputEndHint": { + "text": "Handles the `EndHint` entity-IO input on `CEnvInstructorVRHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvInstructorVRHint::InputShowHint": { + "text": "Handles the `ShowHint` entity-IO input on `CEnvInstructorVRHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvParticleGlow::InputSetAlphaScale": { + "text": "Handles the `setalphascale` entity-IO input on `CEnvParticleGlow`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvParticleGlow::InputSetColorTint": { + "text": "Handles the `setcolortint` entity-IO input on `CEnvParticleGlow`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvParticleGlow::InputSetScale": { + "text": "Handles the `setscale` entity-IO input on `CEnvParticleGlow`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvShake::InputAmplitude": { + "text": "Handles the `Amplitude` entity-IO input on `CEnvShake`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvShake::InputFrequency": { + "text": "Handles the `Frequency` entity-IO input on `CEnvShake`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvShake::InputStartShake": { + "text": "Handles the `StartShake` entity-IO input on `CEnvShake`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvShake::InputStopShake": { + "text": "Handles the `StopShake` entity-IO input on `CEnvShake`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSoundscape::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CEnvSoundscape`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSoundscape::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvSoundscape`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSoundscape::InputToggleEnabled": { + "text": "Handles the `ToggleEnabled` entity-IO input on `CEnvSoundscape`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSpark::InputSparkOnce": { + "text": "Handles the `SparkOnce` entity-IO input on `CEnvSpark`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSpark::InputStartSpark": { + "text": "Handles the `StartSpark` entity-IO input on `CEnvSpark`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSpark::InputStopSpark": { + "text": "Handles the `StopSpark` entity-IO input on `CEnvSpark`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvSpark::InputToggleSpark": { + "text": "Handles the `ToggleSpark` entity-IO input on `CEnvSpark`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvTilt::InputStartTilt": { + "text": "Handles the `StartTilt` entity-IO input on `CEnvTilt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvTilt::InputStopTilt": { + "text": "Handles the `StopTilt` entity-IO input on `CEnvTilt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputSetAnisotropy": { + "text": "Handles the `SetAnisotropy` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputSetDrawDistance": { + "text": "Handles the `SetDrawDistance` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputSetFadeSpeed": { + "text": "Handles the `SetFadeSpeed` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputSetScattering": { + "text": "Handles the `SetFogStrength` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogController::InputSetToDefaults": { + "text": "Handles the `SetToDefaults` entity-IO input on `CEnvVolumetricFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogVolume::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CEnvVolumetricFogVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvVolumetricFogVolume::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvVolumetricFogVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvWindVolume::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CEnvWindVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CEnvWindVolume::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CEnvWindVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFieldPathHuffmanEncoder::InternalNode::IsLeafNode": { + "text": "Answers the leaf test for an internal, child-bearing node of the field-path Huffman tree that compresses entity field paths for networking. Read from the name and the InternalNode scope; the tree layout and traversal are not established by this data.", + "source": "generated" + }, + "CFieldPathHuffmanEncoder::InternalNode::~InternalNode": { + "text": "Destroys an internal node of the field-path Huffman tree and releases the child links it owns. The class is implied by the name, and being a destructor it carries cleanup rather than encoding logic.", + "source": "generated" + }, + "CFieldPathHuffmanEncoder::LeafNode::IsLeafNode": { + "text": "Answers the leaf test for a terminal node of the field-path Huffman tree, the node kind that carries an encoded field-path symbol. Read from the name and the LeafNode scope; what payload the leaf holds is not established here.", + "source": "generated" + }, + "CFieldPathHuffmanEncoder::LeafNode::~LeafNode": { + "text": "Destroys a leaf node of the field-path Huffman tree and releases its storage. The class is implied by the name; as a destructor it carries cleanup rather than encoder behaviour.", + "source": "generated" + }, + "CFileHandle::~CFileHandle": { + "text": "Tears down a file handle object, releasing the underlying file resources it owns. The class is implied by the name, so which resources are released is unverified; treat it as filesystem cleanup rather than gameplay code.", + "source": "generated" + }, + "CFioReadOnlyFile::FS_fread": { + "text": "Reads bytes out of a read-only file, an fread-style read entry point on this filesystem file object. The class is implied by the name; buffering behaviour and how short reads are reported are not established by this data.", + "source": "generated" + }, + "CFlattenedSerializer::ApplyOverrides_R": { + "text": "Applies field overrides to a flattened serializer, descending into nested structures as the `_R` suffix indicates. Useful when reasoning about why a networked field's encoding differs from its schema default; where the overrides come from is not established here.", + "source": "generated" + }, + "CFlattenedSerializer::BuildHierarchy_R": { + "text": "Builds the nested field hierarchy of a flattened serializer, walking sub-structures recursively per the `_R` suffix. Read from the name at low confidence; how the resulting hierarchy is represented is not established by this data.", + "source": "generated" + }, + "CFlattenedSerializer::MaybeWriteFlattenedSerializers_R": { + "text": "Conditionally writes out flattened serializer data \u2014 a dump or export of the network serializer tables \u2014 descending into nested serializers. The `Maybe` prefix indicates a gate, plausibly a convar or debug flag, which this data does not identify.", + "source": "generated" + }, + "CFlattenedSerializer::RemoveFakeFields": { + "text": "Strips fields marked fake from a flattened serializer so they are excluded from the networked field set. Handy context when a schema field exists but never appears on the wire; the criteria that mark a field fake are not established here.", + "source": "generated" + }, + "CFlattenedSerializer::SetRecursiveProxyIndices_R": { + "text": "Assigns proxy indices for recursively nested fields of a flattened serializer, the addressing that lets nested structures be referenced during network encoding. Read from the name and the `_R` suffix; the index scheme itself is not established by this data.", + "source": "generated" + }, + "CFlattenedSerializerSpewFunc_Log::Spew": { + "text": "Emits flattened-serializer diagnostic text into the logging output, acting as the log-backed spew sink for serializer messages. The class is implied by the name, so the log channel and message formatting are unverified.", + "source": "generated" + }, + "CFlattenedSerializerSpewFunc_Log::~CFlattenedSerializerSpewFunc_Log": { + "text": "Tears down the log-backed spew sink used for flattened serializer diagnostics. The class is implied by the name; as a destructor, expect resource cleanup only.", + "source": "generated" + }, + "CFlattenedSerializers::BuildEntityClassNetworkSerializer": { + "text": "Builds the network serializer for an entity class, producing the flattened field table that drives replication of that class. The class is implied by the name; this is the serializer-building machinery a custom entity class needs to gain a wire layout.", + "source": "generated" + }, + "CFogController::InputSet2DSkyboxFogFactor": { + "text": "Handles the `Set2DSkyboxFogFactor` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSet2DSkyboxFogFactorLerpTo": { + "text": "Handles the `Set2DSkyboxFogFactorLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetAngles": { + "text": "Handles the `SetAngles` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetColor": { + "text": "Handles the `SetColor` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetColorLerpTo": { + "text": "Handles the `SetColorLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetColorSecondary": { + "text": "Handles the `SetColorSecondary` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetColorSecondaryLerpTo": { + "text": "Handles the `SetColorSecondaryLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetEndDist": { + "text": "Handles the `SetEndDist` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetEndDistLerpTo": { + "text": "Handles the `SetEndDistLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetFarZ": { + "text": "Handles the `SetFarZ` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetMaxDensity": { + "text": "Handles the `SetMaxDensity` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetMaxDensityLerpTo": { + "text": "Handles the `SetMaxDensityLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetStartDist": { + "text": "Handles the `SetStartDist` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputSetStartDistLerpTo": { + "text": "Handles the `SetStartDistLerpTo` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputStartFogTransition": { + "text": "Handles the `StartFogTransition` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogController::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CFogController`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogVolume::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CFogVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFogVolume::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CFogVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputSetExcluded": { + "text": "Handles the `SetExcluded` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputSetInvert": { + "text": "Handles the `SetInvert` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputSetNonsolid": { + "text": "Handles the `SetNonsolid` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputSetSolid": { + "text": "Handles the `SetSolid` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputTurnOff": { + "text": "Handles the `Disable` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncBrush::InputTurnOn": { + "text": "Handles the `Enable` entity-IO input on `CFuncBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncElectrifiedVolume::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CFuncElectrifiedVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncElectrifiedVolume::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CFuncElectrifiedVolume`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncInteractionLayerClip::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CFuncInteractionLayerClip`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncInteractionLayerClip::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CFuncInteractionLayerClip`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputClose": { + "text": "Handles the `Close` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputOpen": { + "text": "Handles the `Open` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputResetPosition": { + "text": "Handles the `ResetPosition` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputSetMoveDistanceFromEnd": { + "text": "Handles the `SetMoveDistanceFromEnd` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputSetMoveDistanceFromStart": { + "text": "Handles the `SetMoveDistanceFromStart` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputSetPosition": { + "text": "Handles the `SetPosition` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncMoveLinear::InputTeleportToTarget": { + "text": "Handles the `TeleportToTarget` entity-IO input on `CFuncMoveLinear`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncNavBlocker::InputBlockNav": { + "text": "Handles the `BlockNav` entity-IO input on `CFuncNavBlocker`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncNavBlocker::InputUnblockNav": { + "text": "Handles the `UnblockNav` entity-IO input on `CFuncNavBlocker`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncPlat::InputGoDown": { + "text": "Handles the `GoDown` entity-IO input on `CFuncPlat`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncPlat::InputGoUp": { + "text": "Handles the `GoUp` entity-IO input on `CFuncPlat`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncPlat::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncPlat`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputDisableAccelDecel": { + "text": "Handles the `DisableAccelDecel` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputEnableAccelDecel": { + "text": "Handles the `EnableAccelDecel` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputReverse": { + "text": "Handles the `Reverse` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputSetStartPos": { + "text": "Handles the `SetStartPos` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputSnapToStartPos": { + "text": "Handles the `SnapToStartPos` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStart": { + "text": "Handles the `Start` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStartBackward": { + "text": "Handles the `StartBackward` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStartForward": { + "text": "Handles the `StartForward` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputStopAtStartPos": { + "text": "Handles the `StopAtStartPos` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotating::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncRotating`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputPitch": { + "text": "Handles the `Pitch` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputReturnToInitialOrientation": { + "text": "Handles the `ReturnToInitialOrientation` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputReturnToPreviousOrientation": { + "text": "Handles the `ReturnToPreviousOrientation` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputRoll": { + "text": "Handles the `Roll` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputSetRotateType": { + "text": "Handles the `SetRotateType` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputSetRotatorTarget": { + "text": "Handles the `SetRotatorTarget` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputStart": { + "text": "Handles the `Start` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputStartForward": { + "text": "Handles the `StartForward` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncRotator::InputYaw": { + "text": "Handles the `Yaw` entity-IO input on `CFuncRotator`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTimescale::InputReset": { + "text": "Handles the `Reset` entity-IO input on `CFuncTimescale`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTimescale::InputStart": { + "text": "Handles the `Start` entity-IO input on `CFuncTimescale`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTimescale::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncTimescale`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputLockOrientation": { + "text": "Handles the `LockOrientation` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputMoveToPathNode": { + "text": "Handles the `MoveToPathNode` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputResume": { + "text": "Handles the `Resume` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputReverse": { + "text": "Handles the `Reverse` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetMaxSpeed": { + "text": "Handles the `SetMaxSpeed` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetSpeedDir": { + "text": "Handles the `SetSpeedDir` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetSpeedDirAccel": { + "text": "Handles the `SetSpeedDirAccel` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputSetSpeedReal": { + "text": "Handles the `SetSpeedReal` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputStartBackward": { + "text": "Handles the `StartBackward` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputStartForward": { + "text": "Handles the `StartForward` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputTeleportToPathNode": { + "text": "Handles the `TeleportToPathNode` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrackTrain::InputUnlockOrientation": { + "text": "Handles the `UnlockOrientation` entity-IO input on `CFuncTrackTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrain::InputStart": { + "text": "Handles the `Start` entity-IO input on `CFuncTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrain::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CFuncTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CFuncTrain::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CFuncTrain`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGameEntitySystem::CreateEntities": { + "text": "Creates entities within the game entity system, a server-side path for bringing entities into existence from supplied data. Read from the name at low confidence; whether it consumes keyvalues, a map block, or a spawn list is not established here.", + "source": "generated" + }, + "CGameEventManager::UnserializeEvent": { + "text": "Reconstructs a game event from its serialized network form, turning received bytes back into a usable event object. The class is implied by the name, so the wire encoding it expects and its failure behaviour are unverified.", + "source": "generated" + }, + "CGameEventSystem::Connect": { + "text": "Brings the game event system up against the engine interfaces it needs before it can be used, the connect step of an engine system's lifecycle. Read from the name, with the class implied by the name; what it acquires is unverified.", + "source": "generated" + }, + "CGameEventSystem::Disconnect": { + "text": "Releases the engine interfaces the event system holds, leaving it disconnected but not yet destroyed. Read from the name, with the class implied by the name; exactly what is released is unverified.", + "source": "generated" + }, + "CGameEventSystem::GetBuildType": { + "text": "Reports the build flavour the event system identifies itself with to the engine's system registry, a lifecycle accessor rather than an event operation. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameEventSystem::GetDependencies": { + "text": "Reports the other engine systems this one requires, the information a system registry uses when bringing systems up. Read from the name, with the class implied by the name; the form the list takes is not established here.", + "source": "generated" + }, + "CGameEventSystem::GetEventSource": { + "text": "Exposes the event source the system publishes game events through, which is what you need when working with the engine-side source rather than a single event. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameEventSystem::GetTier": { + "text": "Reports the initialization tier the event system belongs to within the engine's system registry. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameEventSystem::Init": { + "text": "Lifecycle initialization entry point for the event system; the name does not establish what it sets up. The class is implied by the name.", + "source": "generated" + }, + "CGameEventSystem::IsSingleton": { + "text": "Reports whether the event system is restricted to a single instance, a lifecycle query the engine's system registry consumes. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameEventSystem::PostEntityEventAbstract": { + "text": "Fires a game event tied to a specific entity so listeners receive it with that entity as context. Use the entity-scoped post path when an event belongs to one entity rather than the whole game; read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameEventSystem::PostEventAbstract": { + "text": "Fires a game event into the system for delivery to registered handlers, the general-purpose post path a plugin uses to raise an event. Read from the name, with the class implied by the name; delivery scope and client targeting are unverified.", + "source": "generated" + }, + "CGameEventSystem::PostEventAbstract_Local": { + "text": "Fires a game event for local delivery only, keeping it on this host rather than replicating it to clients. Read from the name and its `_Local` suffix, with the class implied by the name; the exact scope is unverified.", + "source": "generated" + }, + "CGameEventSystem::PreShutdown": { + "text": "Performs the early teardown pass while the event system is still usable, the point to drop references before full shutdown. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameEventSystem::ProcessQueuedEvents": { + "text": "Drains events that were queued rather than delivered immediately and hands them to their handlers, so deferred events take effect here. Read from the name, with the class implied by the name; queue policy and re-entrancy are unverified.", + "source": "generated" + }, + "CGameEventSystem::PurgeQueuedEvents": { + "text": "Discards pending queued events without delivering them, the way to clear stale events across a level change or reset. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameEventSystem::QueryInterface": { + "text": "Looks up a requested interface on the event system, the usual interface-query accessor. The name does not establish which interfaces it serves; the class is implied by the name.", + "source": "generated" + }, + "CGameEventSystem::Reconnect": { + "text": "Re-establishes an engine interface the system had already connected, for cases where an interface is swapped or reloaded. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameEventSystem::RegisterGameEvent": { + "text": "Registers a game event definition with the system so that event can be posted and listened for by name. A custom event needs registering before it is usable; read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameEventSystem::RegisterGameEventHandlerAbstract": { + "text": "Subscribes a handler so it receives a given game event, the hook point for reacting to engine events from a plugin. Read from the name, with the class implied by the name; matching and lifetime rules are unverified.", + "source": "generated" + }, + "CGameEventSystem::Shutdown": { + "text": "Shuts the event system down and releases what it holds. The name does not establish what is torn down; the class is implied by the name.", + "source": "generated" + }, + "CGameEventSystem::UnregisterGameEventHandlerAbstract": { + "text": "Removes a previously subscribed handler so it stops receiving events, which a plugin needs on unload to avoid stale callbacks. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameGibManager::InputSetMaxPieces": { + "text": "Handles the `SetMaxPieces` entity-IO input on `CGameGibManager`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGameGibManager::InputSetMaxPiecesDX8": { + "text": "Handles the `SetMaxPiecesDX8` entity-IO input on `CGameGibManager`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGameNetworkStringTables::InitStringTableDefinitions": { + "text": "Sets up the server's network string table definitions; the code carries the diagnostic text `ent_spew_derived_classes: Found %d entities deriving from %s`, tying this work to enumerating entity classes while the definitions are built. Which tables are defined is not established by this data.", + "source": "generated" + }, + "CGameNetworkStringTables::SV_CreateNetworkStringTables": { + "text": "Creates the server-side network string tables, the name/index tables the server shares with clients, and carries the `[server]` tag string. Read from that anchor plus the name; which tables are created and their sizes are not established here.", + "source": "generated" + }, + "CGameResourceService::BuildResourceManifest": { + "text": "Assembles the manifest of resources a map or session needs so they can be loaded together. Read from the name, with the class implied by the name; what feeds the manifest is unverified.", + "source": "generated" + }, + "CGameResourceService::PrecacheEntitiesAndConfirmResourcesAreLoaded": { + "text": "Precaches the resources entities require and confirms they finished loading before play continues, the gate custom entity assets must pass to avoid missing models or sounds. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CGameSystemAbstractFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CVScriptGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemAbstractFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CVScriptGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemAbstractFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CVScriptGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemAbstractFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CVScriptGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemAbstractFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CVScriptGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemAbstractFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CVScriptGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemAbstractFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CVScriptGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemAbstractFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CVScriptGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemAbstractFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CVScriptGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemAbstractFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CVScriptGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CAimTargetManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAimTargetManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CAimTargetManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAimTargetManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CAimTargetManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAimTargetManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CAimTargetManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CAimTargetManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAimTargetManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CAimTargetManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAimTargetManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CAimTargetManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAimTargetManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CAimTargetManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAimTargetManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CAimTargetManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAimTargetManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CAimTargetManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAimTargetManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CBodyGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CBodyGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CBodyGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CBodyGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CBodyGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CBodyGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CBodyGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CBodyGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CBodyGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CBodyGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CBodyGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CBodyGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CBodyGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CBodyGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CBodyGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CBodyGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CBodyGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CBodyGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CBodyGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CCheckClient` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCheckClient` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CCheckClient` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCheckClient` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CCheckClient` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCheckClient` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CCheckClient` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CCheckClient` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCheckClient` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CCheckClient` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCheckClient` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CCheckClient` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCheckClient` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CCheckClient` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCheckClient` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CCheckClient` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCheckClient` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CCheckClient` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCheckClient` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CColorCorrectionSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CColorCorrectionSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CColorCorrectionSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CColorCorrectionSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CColorCorrectionSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CColorCorrectionSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CColorCorrectionSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CColorCorrectionSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CColorCorrectionSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CColorCorrectionSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CColorCorrectionSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CColorCorrectionSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CColorCorrectionSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CColorCorrectionSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CColorCorrectionSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CColorCorrectionSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CColorCorrectionSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CColorCorrectionSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CColorCorrectionSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CCommentarySystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCommentarySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CCommentarySystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCommentarySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CCommentarySystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCommentarySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CCommentarySystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CCommentarySystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCommentarySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CCommentarySystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCommentarySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CCommentarySystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCommentarySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CCommentarySystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCommentarySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CCommentarySystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCommentarySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CCommentarySystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCommentarySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAEventLog` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAEventLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAEventLog` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAEventLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAEventLog` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAEventLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAEventLog` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTAEventLog` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAEventLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAEventLog` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAEventLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTAEventLog` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAEventLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAEventLog` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAEventLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAEventLog` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAEventLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTAEventLog` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAEventLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVScriptGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVScriptGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVScriptGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAVScriptGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVScriptGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVScriptGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVScriptGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVScriptGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVScriptGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVScriptGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVScriptGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActiveModifiersList` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActiveModifiersList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActiveModifiersList` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActiveModifiersList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActiveModifiersList` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActiveModifiersList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActiveModifiersList` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActiveModifiersList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActiveModifiersList` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActiveModifiersList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActiveModifiersList` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActiveModifiersList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActiveModifiersList` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActiveModifiersList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_QuestSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_QuestSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_QuestSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_QuestSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_QuestSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_QuestSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_QuestSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_QuestSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_QuestSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_QuestSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_QuestSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_QuestSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_QuestSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_QuestSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_QuestSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_QuestSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_QuestSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_QuestSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_QuestSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_UnitFilterCache` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_UnitFilterCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_UnitFilterCache` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_UnitFilterCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_UnitFilterCache` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_UnitFilterCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_UnitFilterCache` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_UnitFilterCache` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_UnitFilterCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_UnitFilterCache` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_UnitFilterCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_UnitFilterCache` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_UnitFilterCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_UnitFilterCache` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_UnitFilterCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_UnitFilterCache` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_UnitFilterCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_UnitFilterCache` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_UnitFilterCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDebugOverlayGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDebugOverlayGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDebugOverlayGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDebugOverlayGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDebugOverlayGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDebugOverlayGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDebugOverlayGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDebugOverlayGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDebugOverlayGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDebugOverlayGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDebugOverlayGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDebugOverlayGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDebugOverlayGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDebugOverlayGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDebugOverlayGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDebugOverlayGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDebugOverlayGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDebugOverlayGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDebugOverlayGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDecalGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDecalGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDecalGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDecalGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDecalGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDecalGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDecalGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDecalGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDecalGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDecalGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDecalGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDecalGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDecalGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDecalGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDecalGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDecalGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDecalGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDecalGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDecalGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CEntityDebugGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CEntityDebugGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CEntityDebugGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CEntityDebugGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CEntityDebugGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CEntityDebugGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CEntityDebugGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CEntityDebugGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CEntityDebugGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CEntityDebugGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CEntityDebugGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CEntityDebugGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CEntityDebugGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CEntityDebugGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CEntityDebugGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CEntityDebugGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CEntityDebugGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CEntityDebugGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CEntityDebugGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CGameRulesGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameRulesGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CGameRulesGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameRulesGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CGameRulesGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameRulesGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CGameRulesGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CGameRulesGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameRulesGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CGameRulesGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameRulesGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CGameRulesGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameRulesGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CGameRulesGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameRulesGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CGameRulesGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameRulesGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CGameRulesGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameRulesGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CHLTVDirector` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CHLTVDirector` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CHLTVDirector` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CHLTVDirector` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CHLTVDirector` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CHLTVDirector` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CHLTVDirector` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CHLTVDirector` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CHLTVDirector` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CHLTVDirector` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CLightQueryGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLightQueryGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CLightQueryGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLightQueryGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CLightQueryGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLightQueryGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CLightQueryGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CLightQueryGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLightQueryGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CLightQueryGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLightQueryGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CLightQueryGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLightQueryGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CLightQueryGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLightQueryGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CLightQueryGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLightQueryGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CLightQueryGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLightQueryGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CMarkupManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CMarkupManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CMarkupManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CMarkupManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CMarkupManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CMarkupManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CMarkupManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CMarkupManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CMarkupManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CMarkupManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CMarkupManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CMarkupManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CMarkupManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CMarkupManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CMarkupManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CMarkupManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CMarkupManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CMarkupManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CMarkupManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CNavGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNavGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CNavGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNavGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CNavGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNavGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CNavGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CNavGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNavGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CNavGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNavGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CNavGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNavGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CNavGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNavGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CNavGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNavGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CNavGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNavGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CNotifyManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNotifyManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CNotifyManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNotifyManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CNotifyManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNotifyManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CNotifyManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CNotifyManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNotifyManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CNotifyManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNotifyManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CNotifyManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNotifyManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CNotifyManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNotifyManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CNotifyManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNotifyManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CNotifyManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CNotifyManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CPVSManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPVSManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CPVSManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPVSManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CPVSManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPVSManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CPVSManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CPVSManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPVSManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CPVSManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPVSManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CPVSManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPVSManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CPVSManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPVSManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CPVSManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPVSManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CPVSManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPVSManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CPhysicsGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPhysicsGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CPhysicsGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPhysicsGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CPhysicsGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CPhysicsGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPhysicsGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CPhysicsGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPhysicsGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CPhysicsGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPhysicsGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CPhysicsGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPhysicsGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CPhysicsGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPhysicsGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CPhysicsGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPhysicsGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CPrecacheGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheRegister` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheRegister` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheRegister` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheRegister` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheRegister` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheRegister` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CPrecacheRegister` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheRegister` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheRegister` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheRegister` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheRegister` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheRegister` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheRegister` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheRegister` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheRegister` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheRegister` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheRegister` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CPrecacheRegister` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPrecacheRegister` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CPropData` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPropData` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CPropData` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPropData` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CPropData` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CPropData` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPropData` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CPropData` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPropData` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CPropData` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPropData` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CPropData` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPropData` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CPropData` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPropData` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CPropData` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPropData` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CRenderGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRenderGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CRenderGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRenderGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CRenderGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CRenderGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRenderGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CRenderGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRenderGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CRenderGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRenderGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CRenderGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRenderGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CRenderGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRenderGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CRenderGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRenderGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CServerAchievementManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CServerAchievementManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CServerAchievementManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CServerAchievementManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CServerAchievementManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CServerAchievementManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CServerAchievementManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CServerAchievementManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CServerAchievementManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CServerAchievementManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CServerAchievementManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CServerAchievementManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CServerAchievementManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CServerAchievementManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CServerAchievementManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CServerAchievementManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CServerAchievementManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CServerAchievementManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CServerAchievementManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSoundscapeSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundscapeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSoundscapeSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundscapeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CSoundscapeSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundscapeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CSoundscapeSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CSoundscapeSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundscapeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CSoundscapeSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundscapeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CSoundscapeSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundscapeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CSoundscapeSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundscapeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CSoundscapeSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundscapeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CSoundscapeSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundscapeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSource1LegacyGameEventGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource1LegacyGameEventGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSource1LegacyGameEventGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource1LegacyGameEventGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CSource1LegacyGameEventGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource1LegacyGameEventGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CSource1LegacyGameEventGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CSource1LegacyGameEventGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource1LegacyGameEventGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CSource1LegacyGameEventGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource1LegacyGameEventGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CSource1LegacyGameEventGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource1LegacyGameEventGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CSource1LegacyGameEventGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource1LegacyGameEventGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CSource1LegacyGameEventGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource1LegacyGameEventGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CSource1LegacyGameEventGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource1LegacyGameEventGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSource2EntitySystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource2EntitySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CSource2EntitySystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource2EntitySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CSource2EntitySystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CSource2EntitySystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource2EntitySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CSource2EntitySystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource2EntitySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CSource2EntitySystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource2EntitySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CSource2EntitySystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource2EntitySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CSource2EntitySystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource2EntitySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CSource2EntitySystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSource2EntitySystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupCompletionCallbackGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupCompletionCallbackGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupCompletionCallbackGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupCompletionCallbackGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CSpawnGroupCompletionCallbackGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupCompletionCallbackGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupCompletionCallbackGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupCompletionCallbackGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupCompletionCallbackGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupCompletionCallbackGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupCompletionCallbackGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupCompletionCallbackGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupCompletionCallbackGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupCompletionCallbackGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupCompletionCallbackGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupCompletionCallbackGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupCompletionCallbackGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupMgrGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupMgrGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupMgrGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupMgrGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupMgrGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupMgrGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CSpawnGroupMgrGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupMgrGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupMgrGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupMgrGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupMgrGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupMgrGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupMgrGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupMgrGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupMgrGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupMgrGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupMgrGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CSpawnGroupMgrGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSpawnGroupMgrGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `GameEvent_RegisterHookupGameSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `GameEvent_RegisterHookupGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `GameEvent_RegisterHookupGameSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `GameEvent_RegisterHookupGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `GameEvent_RegisterHookupGameSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `GameEvent_RegisterHookupGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `GameEvent_RegisterHookupGameSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `GameEvent_RegisterHookupGameSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `GameEvent_RegisterHookupGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `GameEvent_RegisterHookupGameSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `GameEvent_RegisterHookupGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `GameEvent_RegisterHookupGameSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `GameEvent_RegisterHookupGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `GameEvent_RegisterHookupGameSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `GameEvent_RegisterHookupGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `GameEvent_RegisterHookupGameSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `GameEvent_RegisterHookupGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemReallocatingFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `GameEvent_RegisterHookupGameSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `GameEvent_RegisterHookupGameSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CAnchorList` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnchorList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CAnchorList` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnchorList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CAnchorList` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnchorList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CAnchorList` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CAnchorList` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnchorList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CAnchorList` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnchorList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CAnchorList` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnchorList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CAnchorList` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnchorList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CAnchorList` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnchorList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CAnchorList` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnchorList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CAnnouncerSharedThinker` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnnouncerSharedThinker` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CAnnouncerSharedThinker` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnnouncerSharedThinker` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CAnnouncerSharedThinker` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CAnnouncerSharedThinker` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnnouncerSharedThinker` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CAnnouncerSharedThinker` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnnouncerSharedThinker` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CAnnouncerSharedThinker` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnnouncerSharedThinker` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CAnnouncerSharedThinker` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnnouncerSharedThinker` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CAnnouncerSharedThinker` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CAnnouncerSharedThinker` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CCustomGameEventManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomGameEventManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CCustomGameEventManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomGameEventManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CCustomGameEventManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CCustomGameEventManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomGameEventManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CCustomGameEventManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomGameEventManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CCustomGameEventManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomGameEventManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CCustomGameEventManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomGameEventManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CCustomGameEventManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomGameEventManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CCustomGameEventManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomGameEventManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CCustomNetTableManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomNetTableManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CCustomNetTableManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomNetTableManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CCustomNetTableManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomNetTableManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CCustomNetTableManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CCustomNetTableManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomNetTableManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CCustomNetTableManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomNetTableManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CCustomNetTableManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomNetTableManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CCustomNetTableManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CCustomNetTableManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAChallengeSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAChallengeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAChallengeSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAChallengeSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAChallengeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAChallengeSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAChallengeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAChallengeSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAChallengeSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTACustomGameCache` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTACustomGameCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTACustomGameCache` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTACustomGameCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTACustomGameCache` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTACustomGameCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTACustomGameCache` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTACustomGameCache` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTACustomGameCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTACustomGameCache` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTACustomGameCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTACustomGameCache` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTACustomGameCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTACustomGameCache` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTACustomGameCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTACustomGameCache` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTACustomGameCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTACustomGameCache` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTACustomGameCache` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAFogOfWarSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAFogOfWarSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAFogOfWarSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAFogOfWarSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAFogOfWarSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTAFogOfWarSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAFogOfWarSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAFogOfWarSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAFogOfWarSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTAFogOfWarSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAFogOfWarSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAFogOfWarSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAFogOfWarSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAFogOfWarSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAFogOfWarSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTAFogOfWarSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAFogOfWarSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGCServerSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGCServerSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGCServerSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGCServerSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGCServerSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGCServerSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAGCServerSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGCServerSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGCServerSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGCServerSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGCServerSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGCServerSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGCServerSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGCServerSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGCServerSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGCServerSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGCServerSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGCServerSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGCServerSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGameManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGameManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAGameManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGameManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGameManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGameManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGameManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGameManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGameManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGameManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGameManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGameManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGameManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTAGameManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAGameManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHLTVDirector` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHLTVDirector` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHLTVDirector` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAHLTVDirector` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHLTVDirector` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHLTVDirector` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHLTVDirector` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHLTVDirector` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHLTVDirector` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHLTVDirector` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHLTVDirector` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHeroList` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHeroList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHeroList` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHeroList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAHeroList` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHeroList` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHeroList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHeroList` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHeroList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHeroList` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHeroList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHeroList` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHeroList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHeroList` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHeroList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTAHeroList` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAHeroList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAInventoryManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAInventoryManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAInventoryManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAInventoryManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAInventoryManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAInventoryManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAInventoryManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTAInventoryManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAInventoryManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAInventoryManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAInventoryManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTAInventoryManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAInventoryManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAInventoryManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAInventoryManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAInventoryManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAInventoryManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTAInventoryManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAInventoryManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTASpectatorGraphManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTASpectatorGraphManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTASpectatorGraphManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTASpectatorGraphManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTASpectatorGraphManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTASpectatorGraphManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTASpectatorGraphManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTASpectatorGraphManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTASpectatorGraphManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTASpectatorGraphManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTASpectatorGraphManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTASpectatorGraphManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTASpectatorGraphManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTASpectatorGraphManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTASpectatorGraphManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTASpectatorGraphManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTASpectatorGraphManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTASpectatorGraphManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTASpectatorGraphManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVoteSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVoteSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVoteSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVoteSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVoteSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVoteSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTAVoteSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVoteSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVoteSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVoteSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVoteSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVoteSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVoteSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVoteSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVoteSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVoteSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVoteSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTAVoteSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTAVoteSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AbilityAnimations` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AbilityAnimations` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_AbilityAnimations` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AbilityAnimations` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AbilityAnimations` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AbilityAnimations` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AbilityAnimations` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AbilityAnimations` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AbilityAnimations` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActionDelayer` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActionDelayer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActionDelayer` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActionDelayer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActionDelayer` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActionDelayer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_ActionDelayer` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActionDelayer` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActionDelayer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActionDelayer` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActionDelayer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActionDelayer` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActionDelayer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActionDelayer` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActionDelayer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActionDelayer` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActionDelayer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ActionDelayer` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ActionDelayer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AttackRecordManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AttackRecordManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_AttackRecordManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AttackRecordManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AttackRecordManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AttackRecordManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AttackRecordManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AttackRecordManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AttackRecordManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AttackRecordManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AttackRecordManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AttackRecordManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AttackRecordManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AttackRecordManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AttackRecordManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AutoCombinableItems` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AutoCombinableItems` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_AutoCombinableItems` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AutoCombinableItems` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AutoCombinableItems` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AutoCombinableItems` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AutoCombinableItems` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AutoCombinableItems` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AutoCombinableItems` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AutoCombinableItems` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AutoCombinableItems` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AutoCombinableItems` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AutoCombinableItems` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_AutoCombinableItems` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_AutoCombinableItems` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_BinaryObjectSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_BinaryObjectSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_BinaryObjectSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_BinaryObjectSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_BinaryObjectSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_BinaryObjectSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_BinaryObjectSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_BinaryObjectSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_BinaryObjectSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_BinaryObjectSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_BinaryObjectSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_BinaryObjectSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_BinaryObjectSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_BinaryObjectSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_BinaryObjectSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatAnalyzer` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatAnalyzer` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatAnalyzer` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_CombatAnalyzer` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatAnalyzer` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatAnalyzer` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatAnalyzer` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatAnalyzer` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatAnalyzer` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatAnalyzer` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatLog` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_CombatLog` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatLog` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatLog` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatLog` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatLog` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatLog` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CombatLog` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CombatLog` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Commander` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Commander` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Commander` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Commander` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Commander` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Commander` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_Commander` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Commander` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Commander` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Commander` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Commander` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Commander` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Commander` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Commander` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Commander` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Commander` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Commander` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Commander` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Commander` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CustomUIManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CustomUIManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CustomUIManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CustomUIManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CustomUIManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CustomUIManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_CustomUIManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CustomUIManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CustomUIManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CustomUIManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CustomUIManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CustomUIManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CustomUIManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_CustomUIManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_CustomUIManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Grinder` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Grinder` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Grinder` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Grinder` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Grinder` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Grinder` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_Grinder` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Grinder` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Grinder` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Grinder` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Grinder` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Grinder` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Grinder` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Grinder` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Grinder` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ProjectileManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ProjectileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ProjectileManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ProjectileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ProjectileManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ProjectileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_ProjectileManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ProjectileManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ProjectileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ProjectileManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ProjectileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ProjectileManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ProjectileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ProjectileManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ProjectileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ProjectileManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ProjectileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_ProjectileManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_ProjectileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_RealtimeCombatAnalyzer` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_RealtimeCombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_RealtimeCombatAnalyzer` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_RealtimeCombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_RealtimeCombatAnalyzer` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_RealtimeCombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_RealtimeCombatAnalyzer` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_RealtimeCombatAnalyzer` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_RealtimeCombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_RealtimeCombatAnalyzer` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_RealtimeCombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_RealtimeCombatAnalyzer` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_RealtimeCombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_RealtimeCombatAnalyzer` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_RealtimeCombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_RealtimeCombatAnalyzer` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_RealtimeCombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_RealtimeCombatAnalyzer` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_RealtimeCombatAnalyzer` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_TeleportTimerManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_TeleportTimerManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_TeleportTimerManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_TeleportTimerManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_TeleportTimerManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_TeleportTimerManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_TeleportTimerManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_TeleportTimerManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_TeleportTimerManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_TeleportTimerManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_TeleportTimerManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Tutorial` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Tutorial` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Tutorial` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Tutorial` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Tutorial` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Tutorial` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDOTA_Tutorial` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Tutorial` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Tutorial` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Tutorial` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Tutorial` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Tutorial` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Tutorial` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Tutorial` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Tutorial` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Tutorial` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Tutorial` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDOTA_Tutorial` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDOTA_Tutorial` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CDirtySpatialPartitionEntityList` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDirtySpatialPartitionEntityList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDirtySpatialPartitionEntityList` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDirtySpatialPartitionEntityList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDirtySpatialPartitionEntityList` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDirtySpatialPartitionEntityList` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDirtySpatialPartitionEntityList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDirtySpatialPartitionEntityList` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDirtySpatialPartitionEntityList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDirtySpatialPartitionEntityList` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDirtySpatialPartitionEntityList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDirtySpatialPartitionEntityList` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDirtySpatialPartitionEntityList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDirtySpatialPartitionEntityList` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDirtySpatialPartitionEntityList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDirtySpatialPartitionEntityList` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDirtySpatialPartitionEntityList` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CDotaStatManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDotaStatManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CDotaStatManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CDotaStatManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDotaStatManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CDotaStatManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDotaStatManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CDotaStatManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDotaStatManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CDotaStatManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDotaStatManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CDotaStatManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDotaStatManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CDotaStatManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CDotaStatManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CFlexSceneFileManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFlexSceneFileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CFlexSceneFileManager` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFlexSceneFileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CFlexSceneFileManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFlexSceneFileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CFlexSceneFileManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CFlexSceneFileManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFlexSceneFileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CFlexSceneFileManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFlexSceneFileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CFlexSceneFileManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFlexSceneFileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CFlexSceneFileManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFlexSceneFileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CFlexSceneFileManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFlexSceneFileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CFlexSceneFileManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFlexSceneFileManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CFogSystem` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFogSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CFogSystem` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFogSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CFogSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFogSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CFogSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CFogSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFogSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CFogSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFogSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CFogSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFogSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CFogSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFogSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CFogSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFogSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CFogSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CFogSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CGameTimescale` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameTimescale` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CGameTimescale` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameTimescale` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CGameTimescale` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameTimescale` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CGameTimescale` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CGameTimescale` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameTimescale` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CGameTimescale` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameTimescale` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CGameTimescale` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameTimescale` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CGameTimescale` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameTimescale` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CGameTimescale` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameTimescale` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CGameTimescale` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGameTimescale` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CGlobalState` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGlobalState` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CGlobalState` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGlobalState` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CGlobalState` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGlobalState` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CGlobalState` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CGlobalState` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGlobalState` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CGlobalState` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGlobalState` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CGlobalState` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGlobalState` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CGlobalState` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGlobalState` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CGlobalState` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGlobalState` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CGlobalState` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CGlobalState` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CItemGeneration` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CItemGeneration` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CItemGeneration` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CItemGeneration` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CItemGeneration` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CItemGeneration` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CItemGeneration` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CItemGeneration` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CItemGeneration` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CItemGeneration` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CItemGeneration` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CItemGeneration` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CItemGeneration` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CItemGeneration` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CItemGeneration` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CItemGeneration` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CItemGeneration` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CItemGeneration` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CItemGeneration` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CLagCompensationManager` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLagCompensationManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CLagCompensationManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLagCompensationManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CLagCompensationManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CLagCompensationManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLagCompensationManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CLagCompensationManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLagCompensationManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CLagCompensationManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLagCompensationManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CLagCompensationManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLagCompensationManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CLagCompensationManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLagCompensationManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CLagCompensationManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CLagCompensationManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CPlayerVoiceListener` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPlayerVoiceListener` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CPlayerVoiceListener` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPlayerVoiceListener` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CPlayerVoiceListener` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CPlayerVoiceListener` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPlayerVoiceListener` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CPlayerVoiceListener` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPlayerVoiceListener` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CPlayerVoiceListener` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPlayerVoiceListener` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CPlayerVoiceListener` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPlayerVoiceListener` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CPlayerVoiceListener` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPlayerVoiceListener` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CPlayerVoiceListener` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CPlayerVoiceListener` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CRagdollLRURetirement` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRagdollLRURetirement` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CRagdollLRURetirement` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRagdollLRURetirement` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CRagdollLRURetirement` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRagdollLRURetirement` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CRagdollLRURetirement` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CRagdollLRURetirement` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRagdollLRURetirement` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CRagdollLRURetirement` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRagdollLRURetirement` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CRagdollLRURetirement` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRagdollLRURetirement` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CRagdollLRURetirement` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRagdollLRURetirement` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CRagdollLRURetirement` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRagdollLRURetirement` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CRagdollLRURetirement` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CRagdollLRURetirement` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CResponseQueueManager` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CResponseQueueManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CResponseQueueManager` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CResponseQueueManager` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CResponseQueueManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CResponseQueueManager` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CResponseQueueManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CResponseQueueManager` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CResponseQueueManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CResponseQueueManager` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CResponseQueueManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CResponseQueueManager` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CResponseQueueManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CResponseQueueManager` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CResponseQueueManager` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSoundControllerImp` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundControllerImp` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CSoundControllerImp` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundControllerImp` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CSoundControllerImp` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundControllerImp` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CSoundControllerImp` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CSoundControllerImp` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundControllerImp` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CSoundControllerImp` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundControllerImp` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CSoundControllerImp` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundControllerImp` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CSoundControllerImp` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundControllerImp` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CSoundControllerImp` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundControllerImp` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CSoundControllerImp` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundControllerImp` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CSoundEmitterSystem` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundEmitterSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CSoundEmitterSystem` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::Init": { + "text": "`IGameSystemFactory` implementation for the `CSoundEmitterSystem` game system \u2014 the `Init` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundEmitterSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CSoundEmitterSystem` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundEmitterSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CSoundEmitterSystem` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundEmitterSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CSoundEmitterSystem` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundEmitterSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CSoundEmitterSystem` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundEmitterSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CSoundEmitterSystem` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CSoundEmitterSystem` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CVisibilityMonitor` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVisibilityMonitor` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `CVisibilityMonitor` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVisibilityMonitor` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `CVisibilityMonitor` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVisibilityMonitor` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `CVisibilityMonitor` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `CVisibilityMonitor` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVisibilityMonitor` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `CVisibilityMonitor` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVisibilityMonitor` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `CVisibilityMonitor` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVisibilityMonitor` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `CVisibilityMonitor` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVisibilityMonitor` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `CVisibilityMonitor` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `CVisibilityMonitor` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::CreateGameSystem": { + "text": "`IGameSystemFactory` implementation for the `DOTA_CombatLog_Record` game system \u2014 the creation hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `DOTA_CombatLog_Record` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::DestroyGameSystem": { + "text": "`IGameSystemFactory` implementation for the `DOTA_CombatLog_Record` game system \u2014 the teardown hook of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `DOTA_CombatLog_Record` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetPriority": { + "text": "`IGameSystemFactory` implementation for the `DOTA_CombatLog_Record` game system \u2014 the registration-priority query the engine orders systems by of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `DOTA_CombatLog_Record` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::GetStaticGameSystem": { + "text": "Returns the process-wide `DOTA_CombatLog_Record` game-system instance, creating it on first use.", + "source": "derived" + }, + "CGameSystemStaticFactory::IsReallocating": { + "text": "`IGameSystemFactory` implementation for the `DOTA_CombatLog_Record` game system \u2014 the query for whether this factory reallocates its system rather than holding one statically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `DOTA_CombatLog_Record` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::PostInit": { + "text": "`IGameSystemFactory` implementation for the `DOTA_CombatLog_Record` game system \u2014 the `PostInit` stage, which the engine runs once the earlier `Init` pass is done of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `DOTA_CombatLog_Record` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::SetGlobalPtr": { + "text": "`IGameSystemFactory` implementation for the `DOTA_CombatLog_Record` game system \u2014 the hook that installs the system's global pointer of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `DOTA_CombatLog_Record` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::ShouldAutoAdd": { + "text": "`IGameSystemFactory` implementation for the `DOTA_CombatLog_Record` game system \u2014 the query for whether the engine registers this system automatically of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `DOTA_CombatLog_Record` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameSystemStaticFactory::Shutdown": { + "text": "`IGameSystemFactory` implementation for the `DOTA_CombatLog_Record` game system \u2014 the `Shutdown` stage of the engine's game-system lifecycle. Engine plumbing rather than gameplay: it is how `DOTA_CombatLog_Record` gets stood up, not where its behaviour lives.", + "source": "derived" + }, + "CGameUIService::Init": { + "text": "Lifecycle initialization entry point for the UI service; the name does not establish what it sets up. The class is implied by the name.", + "source": "generated" + }, + "CGenericConstraint::InputSetAngularDampingRatioX": { + "text": "Handles the `SetAngularDampingRatioX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularDampingRatioY": { + "text": "Handles the `SetAngularDampingRatioY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularDampingRatioZ": { + "text": "Handles the `SetAngularDampingRatioZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularFrequencyX": { + "text": "Handles the `SetAngularFrequencyX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularFrequencyY": { + "text": "Handles the `SetAngularFrequencyY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularFrequencyZ": { + "text": "Handles the `SetAngularFrequencyZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularMotionLockedX": { + "text": "Handles the `SetAngularMotionLockedX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularMotionLockedY": { + "text": "Handles the `SetAngularMotionLockedY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetAngularMotionLockedZ": { + "text": "Handles the `SetAngularMotionLockedZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearDampingRatioX": { + "text": "Handles the `SetLinearDampingRatioX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearDampingRatioY": { + "text": "Handles the `SetLinearDampingRatioY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearDampingRatioZ": { + "text": "Handles the `SetLinearDampingRatioZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearFrequencyX": { + "text": "Handles the `SetLinearFrequencyX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearFrequencyY": { + "text": "Handles the `SetLinearFrequencyY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearFrequencyZ": { + "text": "Handles the `SetLinearFrequencyZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearMotionLockedX": { + "text": "Handles the `SetLinearMotionLockedX` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearMotionLockedY": { + "text": "Handles the `SetLinearMotionLockedY` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGenericConstraint::InputSetLinearMotionLockedZ": { + "text": "Handles the `SetLinearMotionLockedZ` entity-IO input on `CGenericConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGlobalThreadPool::Start": { + "text": "Starts the engine's global worker thread pool so queued jobs can begin running. Read from the name, with the class implied by the name; thread counts, affinity and scheduling are unverified.", + "source": "generated" + }, + "CGunTarget::InputStart": { + "text": "Handles the `Start` entity-IO input on `CGunTarget`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGunTarget::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CGunTarget`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CGunTarget::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CGunTarget`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CHLTVClient::ActivatePlayer": { + "text": "Activates the player slot for an HLTV spectator client, moving that client into the active in-game state. Read from the name, with the class implied by the name; conditions and side effects are unverified.", + "source": "generated" + }, + "CHLTVFrame::IsMemPoolAllocated": { + "text": "Reports whether the HLTV frame was allocated from a memory pool rather than the general heap, which governs how it must be freed. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CHLTVFrame::~CHLTVFrame": { + "text": "Destroys an HLTV frame and releases what it holds. The class is implied by the name, and the exact resources freed are not established here.", + "source": "generated" + }, + "CHostStateMgr::QueueNewRequest": { + "text": "Queues a new host-state change request for later handling instead of applying it immediately. Read from the name, with the class implied by the name; the request kinds accepted and the queue's ordering rules are unverified.", + "source": "generated" + }, + "CIODelayAlarmThread::~CIODelayAlarmThread": { + "text": "Destroys the I/O delay alarm thread object, ending the thread that watches for delayed I/O. Read from the name, with the class implied by the name; what it stops or joins is unverified.", + "source": "generated" + }, + "CInfoDynamicShadowHint::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CInfoDynamicShadowHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoDynamicShadowHint::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CInfoDynamicShadowHint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoGameEventProxy::InputGenerateGameEvent": { + "text": "Handles the `GenerateGameEvent` entity-IO input on `CInfoGameEventProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoOffscreenPanoramaTexture::InputAddCSSClass": { + "text": "Handles the `AddCSSClass` entity-IO input on `CInfoOffscreenPanoramaTexture`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoOffscreenPanoramaTexture::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CInfoOffscreenPanoramaTexture`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoOffscreenPanoramaTexture::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CInfoOffscreenPanoramaTexture`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoOffscreenPanoramaTexture::InputRemoveCSSClass": { + "text": "Handles the `RemoveCSSClass` entity-IO input on `CInfoOffscreenPanoramaTexture`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoPlayerStart::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CInfoPlayerStart`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoPlayerStart::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CInfoPlayerStart`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoPlayerStart::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CInfoPlayerStart`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoVisibilityBox::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CInfoVisibilityBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInfoVisibilityBox::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CInfoVisibilityBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CInputService::OnProfileStorageAvailable": { + "text": "Notification handler for the moment a user's profile storage becomes available, letting the input service pick up settings that were waiting on it. Read from the name, with the class implied by the name.", + "source": "generated" + }, + "CItemGeneric::InputStartAmbientSound": { + "text": "Handles the `StartAmbientSound` entity-IO input on `CItemGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CItemGeneric::InputStopAmbientSound": { + "text": "Handles the `StopAmbientSound` entity-IO input on `CItemGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CItemGeneric::InputToggleAmbientSound": { + "text": "Handles the `ToggleAmbientSound` entity-IO input on `CItemGeneric`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CItemSocket_Autograph::GetString": { + "text": "Yields the string value carried by an autograph item socket; the code holds the anchor `_ClientModifierLevel`, a socket attribute-key suffix it works with. Which stored field is produced is not established by this data.", + "source": "generated" + }, + "CItemSocket_Color::GetString": { + "text": "Yields the string form of a colour item socket, building it through the token `Econ_Socket_Color_%s_Legacy` for legacy colour sockets. Useful when you need a socket's colour as text; the value substituted into that token is not established here.", + "source": "generated" + }, + "CItemSocket_Effect::GetString": { + "text": "Produces the localization token for an item's socketed particle effect, formatting the anchor #Attrib_Particle%u with the effect's index. Use it when reading or overriding how cosmetic socket effects are labelled; the anchor fixes the token shape, but what supplies the index and when it is built are unverified.", + "source": "generated" + }, + "CKeepUpright::InputSetAngularLimit": { + "text": "Handles the `SetAngularLimit` entity-IO input on `CKeepUpright`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CKeepUpright::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CKeepUpright`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CKeepUpright::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CKeepUpright`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLineBatchLayoutInfo::GetCopy": { + "text": "Returns a duplicate of a batched line-layout record so callers can hold or edit a snapshot without touching the original. The owning class is implied by the name rather than recovered from the vtable, and whether the copy is deep or shallow is unverified.", + "source": "generated" + }, + "CLineBatchLayoutInfo::Render": { + "text": "Draws the batch of laid-out text lines this record describes. The class is implied by the name and the vtable slot is unbound, so the draw surface, coordinate space, and state it consumes are unverified.", + "source": "generated" + }, + "CLineBatchLayoutInfo::~CLineBatchLayoutInfo": { + "text": "Tears down a batched line-layout record and releases the per-line data it holds. The class is implied by the name and the slot is unbound, so which buffers it actually owns and frees is unverified.", + "source": "generated" + }, + "CLineLayoutInfo::GetCopy": { + "text": "Returns a duplicate of a single line's layout record, letting callers keep or modify a snapshot independently of the original. The class is implied by the name, not recovered from the binary, and the copy's depth is unverified.", + "source": "generated" + }, + "CLineLayoutInfo::Render": { + "text": "Draws the single laid-out text line this record describes. The class is implied by the name and the vtable slot is unbound, so the drawing target and the layout state it reads are unverified.", + "source": "generated" + }, + "CLineLayoutInfo::~CLineLayoutInfo": { + "text": "Destroys one line's layout record, releasing the glyph and run data held for that line. The class is implied by the name and the slot is unbound, so the exact ownership it relinquishes is unverified.", + "source": "generated" + }, + "CLocalize::AddFile": { + "text": "Registers a localization string file with the localize system so its tokens become resolvable for lookup. This is the entry point for adding custom translation files from a mod; read from the name, so the accepted path form and how duplicate tokens are merged are unverified.", + "source": "generated" + }, + "CLogicAchievement::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicAchievement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAchievement::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicAchievement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAchievement::InputFireEvent": { + "text": "Handles the `FireEvent` entity-IO input on `CLogicAchievement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAchievement::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CLogicAchievement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicActiveAutosave::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicActiveAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicActiveAutosave::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicActiveAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicActivityEvent::InputFireEvent": { + "text": "Handles the `FireEvent` entity-IO input on `CLogicActivityEvent`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAutosave::InputSave": { + "text": "Handles the `Save` entity-IO input on `CLogicAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAutosave::InputSaveDangerous": { + "text": "Handles the `SaveDangerous` entity-IO input on `CLogicAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicAutosave::InputSetMinHitpointsThreshold": { + "text": "Handles the `SetMinHitpointsThreshold` entity-IO input on `CLogicAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranch::InputSetValue": { + "text": "Handles the `SetValue` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranch::InputSetValueTest": { + "text": "Handles the `SetValueTest` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranch::InputTest": { + "text": "Handles the `Test` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranch::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranch::InputToggleTest": { + "text": "Handles the `ToggleTest` entity-IO input on `CLogicBranch`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranchList::InputTest": { + "text": "Handles the `Test` entity-IO input on `CLogicBranchList`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranchList::Input_OnLogicBranchChanged": { + "text": "Handles the `_OnLogicBranchChanged` entity-IO input on `CLogicBranchList`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicBranchList::Input_OnLogicBranchRemoved": { + "text": "Handles the `_OnLogicBranchRemoved` entity-IO input on `CLogicBranchList`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCase::InputPickRandom": { + "text": "Handles the `PickRandom` entity-IO input on `CLogicCase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCase::InputPickRandomShuffle": { + "text": "Handles the `PickRandomShuffle` entity-IO input on `CLogicCase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCase::InputResetShuffle": { + "text": "Handles the `ResetShuffle` entity-IO input on `CLogicCase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCase::InputValue": { + "text": "Handles the `InValue` entity-IO input on `CLogicCase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCollisionPair::InputDisableCollisions": { + "text": "Handles the `DisableCollisions` entity-IO input on `CLogicCollisionPair`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCollisionPair::InputDisableCollisionsWith": { + "text": "Handles the `DisableCollisionsWith` entity-IO input on `CLogicCollisionPair`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCollisionPair::InputEnableCollisions": { + "text": "Handles the `EnableCollisions` entity-IO input on `CLogicCollisionPair`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCompare::InputCompare": { + "text": "Handles the `Compare` entity-IO input on `CLogicCompare`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCompare::InputSetCompareValue": { + "text": "Handles the `SetCompareValue` entity-IO input on `CLogicCompare`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCompare::InputSetValue": { + "text": "Handles the `SetValue` entity-IO input on `CLogicCompare`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicCompare::InputSetValueCompare": { + "text": "Handles the `SetValueCompare` entity-IO input on `CLogicCompare`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicDistanceAutosave::InputSave": { + "text": "Handles the `Save` entity-IO input on `CLogicDistanceAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicDistanceAutosave::InputSaveDangerous": { + "text": "Handles the `SaveDangerous` entity-IO input on `CLogicDistanceAutosave`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicDistanceCheck::InputCheckDistance": { + "text": "Handles the `CheckDistance` entity-IO input on `CLogicDistanceCheck`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicGameEventListener::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicGameEventListener`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicGameEventListener::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicGameEventListener`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicGameEventListener::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CLogicGameEventListener`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetMeasureReference": { + "text": "Handles the `SetMeasureReference` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetMeasureTarget": { + "text": "Handles the `SetMeasureTarget` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetTarget": { + "text": "Handles the `SetTarget` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetTargetReference": { + "text": "Handles the `SetTargetReference` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicMeasureMovement::InputSetTargetScale": { + "text": "Handles the `SetTargetScale` entity-IO input on `CLogicMeasureMovement`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicNPCCounter::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CLogicNPCCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicNPCCounter::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CLogicNPCCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLogicNPCCounter::InputSetSourceEntity": { + "text": "Handles the `SetSourceEntity` entity-IO input on `CLogicNPCCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeConsole` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Destroys a console loop-mode instance and releases it. The class is implied by the name from an unbound vtable slot, so what teardown it performs before freeing is unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type identifier for the console mode, which callers use to match a factory to the mode they want. The class is implied by the name, and the identifier's encoding is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Brings the console loop-mode factory into a usable state for serving mode creation. Beyond generic factory startup the purpose is not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the console loop-mode factory down and releases what it holds. Beyond generic teardown the specifics are not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeGame` loop mode \u2014 the engine's top-level mode object for this run state.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Destroys a gameplay loop-mode instance and frees it. A prototype is derived, but what resources it releases and under what conditions the engine wants it destroyed are unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the type identifier of the gameplay loop mode this factory produces, letting callers pick the factory matching a mode. A prototype is derived; the identifier's encoding and value space are read from the name and unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Initializes the gameplay loop-mode factory so it can serve mode creation. Beyond generic startup its purpose is not established, though a prototype is derived.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the gameplay loop-mode factory down and releases what it holds. Beyond generic teardown the specifics are not established, though a prototype is derived.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeInGameUI` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Destroys an in-game UI loop-mode instance and releases it. The class is implied by the name from an unbound vtable slot, so the cleanup it performs is unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type identifier for the in-game UI mode, used to match a factory to the mode a caller wants. The class is implied by the name, and the identifier's encoding is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Brings the in-game UI loop-mode factory into a usable state for serving mode creation. Beyond generic factory startup the purpose is not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the in-game UI loop-mode factory down and releases what it holds. Beyond generic teardown the specifics are not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeLevelLoad` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Destroys a level-load loop-mode instance and releases it, ending the loading-phase mode. The class is implied by the name from an unbound vtable slot, so the cleanup it performs is unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type identifier for the level-loading mode, letting callers match a factory to that mode. The class is implied by the name, and the identifier's encoding is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Brings the level-load loop-mode factory into a usable state for serving mode creation. Beyond generic factory startup the purpose is not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the level-load loop-mode factory down and releases what it holds. Beyond generic teardown the specifics are not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeMainMenu` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Destroys a main-menu loop-mode instance and releases it. The class is implied by the name from an unbound vtable slot, so the cleanup it performs before freeing is unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type identifier for the main-menu mode, used to match a factory to that mode. The class is implied by the name, and the identifier's encoding is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Brings the main-menu loop-mode factory into a usable state for serving mode creation. Beyond generic factory startup the purpose is not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the main-menu loop-mode factory down and releases what it holds. Beyond generic teardown the specifics are not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeRemoteConnect` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Destroys a remote-connect loop-mode instance and releases it, ending the mode covering connection to a remote server. The class is implied by the name from an unbound vtable slot, so the cleanup it performs is unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports the loop-mode type identifier for the remote-connect mode, letting callers match a factory to that mode. The class is implied by the name, and the identifier's encoding is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Brings the remote-connect loop-mode factory into a usable state for serving mode creation. Beyond generic factory startup the purpose is not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Shuts the remote-connect loop-mode factory down and releases what it holds. Beyond generic teardown the specifics are not established; the class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::CreateLoopMode": { + "text": "Creates the `CLoopModeSourceTVRelay` loop mode \u2014 the engine's top-level mode object for this run state. The vtable slot carries no class binding, so the owning class is implied by the name, not by the data.", + "source": "derived" + }, + "CLoopModeFactory::DestroyLoopMode": { + "text": "Tears down a SourceTV relay loop mode the factory produced, releasing it when that relay session ends. Read from the name; the class is implied by the name, so the exact teardown work is unverified.", + "source": "generated" + }, + "CLoopModeFactory::GetLoopModeType": { + "text": "Reports which loop mode type this SourceTV relay factory produces, letting a caller tell a relay factory apart from other loop-mode factories. Read from the name; the class is implied by the name, so the identifier's form is unverified.", + "source": "generated" + }, + "CLoopModeFactory::Init": { + "text": "Purpose is not established beyond generic initialization of the SourceTV relay loop-mode factory. The class is implied by the name.", + "source": "generated" + }, + "CLoopModeFactory::Shutdown": { + "text": "Purpose is not established beyond generic shutdown of the SourceTV relay loop-mode factory. The class is implied by the name.", + "source": "generated" + }, + "CLoopModeGame::OnFirstMapLoaded": { + "text": "Handles the game loop mode's reaction to the first map finishing load, the natural spot for one-time setup that needs a live world. Read from the name; the class is implied by the name, and what it does with the loaded map is unverified.", + "source": "generated" + }, + "CLoopModeLevelLoad::MaybeSwitchToGameLoop": { + "text": "Decides whether the level-load loop mode should give way to the game loop mode, switching when loading has progressed far enough and leaving things alone otherwise. Read from the name; the class is implied by the name, so the switch conditions are unverified.", + "source": "generated" + }, + "CLoopModeLevelLoad::OnLoopActivate": { + "text": "Runs the level-load loop mode's activation handling, the point at which that mode becomes active and can prepare load-time state. Read from the name; the class is implied by the name, so the setup it performs is unverified.", + "source": "generated" + }, + "CLoopModeTypeClientServer::PollAndProcessInput": { + "text": "Polls pending input for the client/server loop type and processes what it finds, draining that input for the current frame. Read from the name and its libengine2 location; no prototype is derived, so the input sources and timing are unverified.", + "source": "generated" + }, + "CLoopTypeClientServer::AllocateLoopMode": { + "text": "Allocates a loop mode object for the client/server loop type, the mode the engine runs for a hosted session. Read from the name; the class is implied by the name, so which mode kinds it can produce is unverified.", + "source": "generated" + }, + "CLuaVM::AddSearchPath": { + "text": "Registers an additional filesystem location the VM consults when resolving script files to load, so add-on or tool content can live outside the default content roots. The CLuaVM class is implied by the name, and this is a name-level reading, so the accepted path form and how duplicates are handled are unverified.", + "source": "generated" + }, + "CLuaVM::AreHandlesEqual": { + "text": "Compares two script-value handles and reports whether they designate the same underlying script object, which is what you want when de-duplicating cached handles rather than comparing contents. The CLuaVM class is implied by the name; whether the comparison is identity-based or value-based is not established here.", + "source": "generated" + }, + "CLuaVM::ArrayAddToTail": { + "text": "Appends a value onto the end of a script array held by the VM, growing it by one element. The CLuaVM class is implied by the name, and the append reading comes from the name, though this entry carries high confidence.", + "source": "generated" + }, + "CLuaVM::ClearValue": { + "text": "Clears a stored script value, releasing whatever a table slot, scope entry, or handle currently holds. The CLuaVM class is implied by the name, and the reading is name-level, so what exactly is cleared and whether the slot is removed or merely emptied is unverified.", + "source": "generated" + }, + "CLuaVM::CollectGarbage": { + "text": "Runs a garbage-collection pass inside the scripting VM so script objects that are no longer referenced get reclaimed; useful after tearing down a batch of script state. The CLuaVM class is implied by the name, and whether the pass is full or incremental is not established here.", + "source": "generated" + }, + "CLuaVM::CompileScript": { + "text": "Compiles script source text into a form the VM can execute, without executing it. The CLuaVM class is implied by the name, and this is a name-level reading, so how compile errors are surfaced and where the compiled result is kept are unverified.", + "source": "generated" + }, + "CLuaVM::ConvertFromScriptTable": { + "text": "Converts a script table into an engine-side native representation, the direction you need when script hands structured data back to C++ code. The CLuaVM class is implied by the name, and the target representation and how nested or non-convertible values are treated are unverified.", + "source": "generated" + }, + "CLuaVM::CopyHandle": { + "text": "Produces a second handle referring to the same script value, so a caller can retain its own reference independently of the original. The CLuaVM class is implied by the name; whether the copy carries its own lifetime that must be released separately is not established here.", + "source": "generated" + }, + "CLuaVM::CopyValue": { + "text": "Copies a script value from one location to another, for example duplicating an entry between tables or scopes. The CLuaVM class is implied by the name, and the reading is name-level, so whether the copy is shallow or deep is unverified.", + "source": "generated" + }, + "CLuaVM::CreateArray": { + "text": "Creates a new empty script array object inside the VM for engine code to populate and hand to script. The CLuaVM class is implied by the name, and this is a name-level reading, so initial sizing behaviour and how the new array is handed back are unverified.", + "source": "generated" + }, + "CLuaVM::CreateFromScriptTableInternal": { + "text": "Builds a native object out of a script table, an internal-suffixed form of that conversion not intended as the public entry point. The CLuaVM class is implied by the name, and this is a name-level reading, so the object kinds it supports and its error behaviour are unverified.", + "source": "generated" + }, + "CLuaVM::CreateKeyValuesFromTable": { + "text": "Turns a script table into a KeyValues structure, giving engine subsystems that consume KeyValues a way to accept data authored in script. The CLuaVM class is implied by the name, and how nested tables, arrays, and value types map into KeyValues is not established here.", + "source": "generated" + }, + "CLuaVM::CreateScope": { + "text": "Creates a fresh script scope, an isolated environment in which script code can run with its own set of names instead of sharing globals. The CLuaVM class is implied by the name, and although the entry is high confidence, what the scope inherits is a name-level reading.", + "source": "generated" + }, + "CLuaVM::CreateTable": { + "text": "Creates a new script table in the VM, the general-purpose keyed container engine code populates before passing data to script. The CLuaVM class is implied by the name, and this is a name-level reading, so preallocation behaviour and how the table is returned to the caller are unverified.", + "source": "generated" + }, + "CLuaVM::DumpState": { + "text": "Writes out the VM's current internal state in readable form, which is the entry point you reach for when diagnosing a script environment that has gone wrong. The CLuaVM class is implied by the name, and what the dump covers and where it is emitted are unverified.", + "source": "generated" + }, + "CLuaVM::EnableLocalDiskAccess": { + "text": "Permits the VM to load script files straight from local disk instead of restricting it to packaged content, which is what makes edit-and-reload iteration on scripts practical during development. The CLuaVM class is implied by the name, and whether the switch can be turned back off is not established here.", + "source": "generated" + }, + "CLuaVM::ExecuteFunction": { + "text": "Runs a script function inside the VM and surfaces its result to the caller, the main path for engine code driving script logic. The CLuaVM class is implied by the name, and how arguments are supplied and how script-side errors are reported are unverified.", + "source": "generated" + }, + "CLuaVM::ForwardConsoleCommand": { + "text": "Hands a console command over to the script environment so script code can implement or intercept it, which is how script-defined commands become reachable from the console. The CLuaVM class is implied by the name, and command matching and the meaning of a handled result are unverified.", + "source": "generated" + }, + "CLuaVM::Frame": { + "text": "Performs the VM's per-frame servicing work, the periodic tick a script environment needs to keep coroutines, timers, and incremental housekeeping progressing. The CLuaVM class is implied by the name, and exactly what work happens in a frame, and how often, is not established here.", + "source": "generated" + }, + "CLuaVM::GenerateUniqueKey": { + "text": "Produces a key that does not collide with keys already in use, for code that must stash values in script tables without inventing names by hand. The CLuaVM class is implied by the name, and the key's form and the scope its uniqueness holds over are unverified.", + "source": "generated" + }, + "CLuaVM::GetArrayCount": { + "text": "Reports how many elements a script array currently holds, the length query to use before iterating one. The CLuaVM class is implied by the name, and this is a name-level reading, so behaviour when the value is not an array is unverified.", + "source": "generated" + }, + "CLuaVM::GetId": { + "text": "Retrieves an identifier from the VM, but the name does not establish what the identifier names or how it is scoped, so its purpose is not established. The CLuaVM class is implied by the name.", + "source": "generated" + }, + "CLuaVM::GetInstanceValue": { + "text": "Reads a value belonging to a script instance that was registered with the VM, the accessor for reaching into an object exposed to script. The CLuaVM class is implied by the name, and although the entry is high confidence, how the instance and member are selected is a name-level reading.", + "source": "generated" + }, + "CLuaVM::GetInternalVM": { + "text": "Hands back the underlying language interpreter state that CLuaVM wraps, giving code that needs raw interpreter access a way past the abstraction. The CLuaVM class is implied by the name, and what the returned state may safely be used for is not established here.", + "source": "generated" + }, + "CLuaVM::GetKeyValue": { + "text": "Reads the value stored under a given key in a script table. The CLuaVM class is implied by the name, and this is a name-level reading, so key typing, missing-key behaviour, and how the result is delivered are unverified.", + "source": "generated" + }, + "CLuaVM::GetLanguage": { + "text": "Reports which scripting language this VM instance is running, useful when engine code must branch on the language backing a script environment. The CLuaVM class is implied by the name, and the identifier's form and the set of values it can take are unverified.", + "source": "generated" + }, + "CLuaVM::GetLanguageName": { + "text": "Gives the scripting language's readable name, the form you would put in logs or diagnostics rather than branch on. The CLuaVM class is implied by the name, and while the entry is high confidence, the exact strings it yields are a name-level reading.", + "source": "generated" + }, + "CLuaVM::GetNumElements": { + "text": "Reports the number of elements held by a script container, the size query for iterating or bounds-checking. The CLuaVM class is implied by the name, and this is a name-level reading, so which container kinds it accepts and its behaviour on other value types are unverified.", + "source": "generated" + }, + "CLuaVM::GetNumTableEntries": { + "text": "Reports how many entries a script table contains, the count to consult when walking a table's contents. The CLuaVM class is implied by the name, and whether the count includes inherited or non-enumerable entries is not established here.", + "source": "generated" + }, + "CLuaVM::GetRootTable": { + "text": "Retrieves the VM's root table, the top-level namespace scripts see and the place engine code puts globals it wants script to reach. The CLuaVM class is implied by the name, and this is a name-level reading, so per-scope variation and handle ownership are unverified.", + "source": "generated" + }, + "CLuaVM::GetScalarValue": { + "text": "Reads a script value as a plain scalar rather than as a handle to a script object, which is what you want when pulling numbers, strings, or booleans out of script. The CLuaVM class is implied by the name, and the conversion rules for non-scalar values are unverified.", + "source": "generated" + }, + "CLuaVM::GetValue": { + "text": "Reads a value out of a script table or scope, the general accessor for pulling script-side data into engine code. The CLuaVM class is implied by the name, and this is a name-level reading, so key handling and missing-value behaviour are unverified.", + "source": "generated" + }, + "CLuaVM::Init": { + "text": "Brings the scripting VM up to a usable state; beyond that startup role, the name does not establish what it configures, so its purpose is not established. The CLuaVM class is implied by the name.", + "source": "generated" + }, + "CLuaVM::IsArray": { + "text": "Tests whether a script value is an array, the type check to run before treating a value as an indexable sequence. The CLuaVM class is implied by the name, and this is a name-level reading, so how it distinguishes arrays from ordinary tables is unverified.", + "source": "generated" + }, + "CLuaVM::IsTable": { + "text": "Tests whether a script value refers to a Lua table, so native code can branch before treating it as a keyed collection. Both this reading and the owning CLuaVM class are implied by the name; CLuaVM::IsArray is the sibling check, and the handle form is unverified.", + "source": "generated" + }, + "CLuaVM::LoadAndCompileScriptFile": { + "text": "Loads a script file from disk and compiles it into the VM, giving you a script the VM can run. This reading and the owning CLuaVM class are implied by the name; CLuaVM::CompileScript is the in-memory counterpart, and how compile errors surface is unverified.", + "source": "generated" + }, + "CLuaVM::LookupFunction": { + "text": "Resolves a named script function into a handle native code can hold and use to call into Lua. This reading and the owning CLuaVM class are implied by the name; CLuaVM::ReleaseFunction is the matching release for that handle.", + "source": "generated" + }, + "CLuaVM::NuggetManager": { + "text": "Exposes the VM's nugget manager, the object the scripting layer uses to track nuggets; what a nugget actually holds is not established by this data. The reading and the owning CLuaVM class are implied by the name.", + "source": "generated" + }, + "CLuaVM::RaiseException": { + "text": "Raises a script-level exception inside the VM, which is how native code signals failure to running Lua. This reading and the owning CLuaVM class are implied by the name; CLuaVM::SetErrorCallback is the related error-reporting hook.", + "source": "generated" + }, + "CLuaVM::ReadState": { + "text": "Restores previously serialized script state back into the VM, the load half of state persistence. This reading and the owning CLuaVM class are implied by the name; CLuaVM::WriteState is the save counterpart, and the storage format and covered state are unverified.", + "source": "generated" + }, + "CLuaVM::ReferenceScope": { + "text": "Takes a reference on a script scope so it stays alive while native code holds it. This reading and the owning CLuaVM class are implied by the name; CLuaVM::CreateScope makes scopes and CLuaVM::ReleaseScope drops the hold.", + "source": "generated" + }, + "CLuaVM::RegisterFunction": { + "text": "Registers a native function with the VM so scripts can call it by name, the main way a mod exposes C++ entry points to Lua. This reading and the owning CLuaVM class are implied by the name; the binding descriptor's shape is unverified.", + "source": "generated" + }, + "CLuaVM::RegisterInstance": { + "text": "Binds a native object instance into the VM so scripts can reach it as a script value. This reading and the owning CLuaVM class are implied by the name; CLuaVM::RemoveInstance unbinds it and CLuaVM::SetInstanceUniqueId gives it an id.", + "source": "generated" + }, + "CLuaVM::RegisterScriptClass": { + "text": "Registers a native class description with the VM so scripts can work with instances of that type. This reading and the owning CLuaVM class are implied by the name; use it alongside CLuaVM::RegisterInstance when exposing concrete native objects.", + "source": "generated" + }, + "CLuaVM::ReleaseFunction": { + "text": "Releases a script function handle the VM was holding, dropping the reference so the function can be collected. This reading and the owning CLuaVM class are implied by the name; it is the counterpart to CLuaVM::LookupFunction.", + "source": "generated" + }, + "CLuaVM::ReleaseScope": { + "text": "Releases a script scope, dropping the VM's hold so its contents can be collected. This reading and the owning CLuaVM class are implied by the name; it pairs with CLuaVM::CreateScope and CLuaVM::ReferenceScope.", + "source": "generated" + }, + "CLuaVM::ReleaseScript": { + "text": "Releases a compiled script, freeing the VM resources held for it. This reading and the owning CLuaVM class are implied by the name; the compile-side counterparts are CLuaVM::CompileScript and CLuaVM::LoadAndCompileScriptFile.", + "source": "generated" + }, + "CLuaVM::ReleaseValue": { + "text": "Releases a script value the VM was holding for native code, dropping its reference so garbage collection can reclaim it. This reading and the owning CLuaVM class are implied by the name; the related accessors are CLuaVM::GetValue and CLuaVM::SetValue.", + "source": "generated" + }, + "CLuaVM::RemoveInstance": { + "text": "Removes a previously bound native object instance from the VM so scripts can no longer reach it. This reading and the owning CLuaVM class are implied by the name; it is the counterpart to CLuaVM::RegisterInstance.", + "source": "generated" + }, + "CLuaVM::Run": { + "text": "Runs a script in the VM, executing its top-level code. This reading and the owning CLuaVM class are implied by the name; CLuaVM::ExecuteFunction covers invoking an individual function, and how script errors are reported here is unverified.", + "source": "generated" + }, + "CLuaVM::SetEnumValue": { + "text": "Defines a named enum constant inside the VM so scripts can refer to a native enumeration symbolically instead of by raw number. This reading and the owning CLuaVM class are implied by the name; CLuaVM::SetValue handles ordinary values, and the scoping rules are unverified.", + "source": "generated" + }, + "CLuaVM::SetErrorCallback": { + "text": "Installs the error-reporting callback for the VM, letting a mod route script errors into its own logging. This reading and the owning CLuaVM class are implied by the name; CLuaVM::SetOutputCallback is the equivalent hook for normal script output.", + "source": "generated" + }, + "CLuaVM::SetInstanceUniqueId": { + "text": "Assigns a unique identifier to a registered script instance so that binding can be referred to by id. This reading and the owning CLuaVM class are implied by the name; it is used with instances established through CLuaVM::RegisterInstance.", + "source": "generated" + }, + "CLuaVM::SetOutputCallback": { + "text": "Installs the callback that receives the VM's script output text, letting a mod capture Lua print output for its own logging. This reading and the owning CLuaVM class are implied by the name; CLuaVM::SetErrorCallback is the error-side equivalent.", + "source": "generated" + }, + "CLuaVM::SetValue": { + "text": "Writes a value into a script table or scope under a given key, the main way native code pushes data into Lua. This reading and the owning CLuaVM class are implied by the name; CLuaVM::GetValue reads back and CLuaVM::ClearValue removes.", + "source": "generated" + }, + "CLuaVM::Shutdown": { + "text": "Shuts the VM down, tearing down script state and releasing the resources it holds. This reading and the owning CLuaVM class are implied by the name; CLuaVM::Init is the startup counterpart, and what survives shutdown is unverified.", + "source": "generated" + }, + "CLuaVM::ValueExists": { + "text": "Tests whether a key is present in a script table or scope, so native code can check before reading. This reading and the owning CLuaVM class are implied by the name; CLuaVM::GetValue fetches the value itself.", + "source": "generated" + }, + "CLuaVM::WriteState": { + "text": "Serializes the VM's script state out for saving, the persistence counterpart to CLuaVM::ReadState. This reading and the owning CLuaVM class are implied by the name; the format and exactly which state is captured are unverified.", + "source": "generated" + }, + "CLuaVM::~CLuaVM": { + "text": "Destroys the VM object, freeing what it owns as the instance goes away. Its role as a destructor and the owning CLuaVM class are implied by the name; CLuaVM::Shutdown is the explicit teardown entry point.", + "source": "generated" + }, + "CMapSpawnGroup::OnPostSpawnGroupLoad": { + "text": "Handles a map spawn group once its load has completed, the hook where that group's entities are available for post-load fixup. Read from the name and its libserver location; no prototype is derived, so the state it touches is unverified.", + "source": "generated" + }, + "CMarkupVolumeTagged::HasTag": { + "text": "Tests whether a tagged markup volume carries a particular tag, the lookup gameplay code uses to react to level-authored volumes. Relevant fields are m_Tags and m_GroupNames; read from the name, so the matching rules and grouping behaviour are unverified.", + "source": "generated" + }, + "CMaterialSystem2::FrameUpdate": { + "text": "Advances the material system by one frame, servicing whatever per-frame material work it maintains. Read from the name; the class is implied by the name, so what it updates each frame is unverified.", + "source": "generated" + }, + "CMaterialTypeManager::GetErrorMaterial": { + "text": "Supplies the fallback error material used in place of a material that failed to load or resolve, so there is always something valid to bind. Read from the name; the class is implied by the name, so the fallback's contents are unverified.", + "source": "generated" + }, + "CMaterialTypeManager::Init": { + "text": "Purpose is not established beyond generic initialization of the material type manager. The class is implied by the name.", + "source": "generated" + }, + "CMathColorBlend::InputValue": { + "text": "Handles the `InValue` entity-IO input on `CMathColorBlend`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputAdd": { + "text": "Handles the `Add` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputDivide": { + "text": "Handles the `Divide` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputGetValue": { + "text": "Handles the `GetValue` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputMultiply": { + "text": "Handles the `Multiply` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSetHitMax": { + "text": "Handles the `SetHitMax` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSetHitMin": { + "text": "Handles the `SetHitMin` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSetValue": { + "text": "Handles the `SetValue` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSetValueNoFire": { + "text": "Handles the `SetValueNoFire` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathCounter::InputSubtract": { + "text": "Handles the `Subtract` entity-IO input on `CMathCounter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathRemap::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CMathRemap`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathRemap::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CMathRemap`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMathRemap::InputValue": { + "text": "Handles the `InValue` entity-IO input on `CMathRemap`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMeshRayTrace::AddRef": { + "text": "Adds a reference to a mesh ray-trace object, keeping it alive while a caller holds it. Read from the name; the class is implied by the name, so the counting scheme is unverified.", + "source": "generated" + }, + "CMeshRayTrace::GetMeshTraceData": { + "text": "Supplies the trace data a mesh ray-trace object holds, the geometry payload rays are tested against. Read from the name; the class is implied by the name, so the data's layout and validity conditions are unverified.", + "source": "generated" + }, + "CMeshRayTrace::GetRayTracingEnvironment": { + "text": "Supplies the ray-tracing environment tied to the mesh, the acceleration structure that ray queries run against. Read from the name; the class is implied by the name, so what the environment holds is unverified.", + "source": "generated" + }, + "CMeshRayTrace::IsOutOfDate": { + "text": "Reports whether the mesh ray-trace data has gone stale against its source mesh and wants rebuilding, useful before trusting a cached trace result. Read from the name; the class is implied by the name, so the staleness criteria are unverified.", + "source": "generated" + }, + "CMeshRayTrace::Release": { + "text": "Drops a reference to a mesh ray-trace object, freeing it once the last reference goes away. Read from the name; the class is implied by the name, so the exact lifetime rules are unverified.", + "source": "generated" + }, + "CMeshRayTrace::~CMeshRayTrace": { + "text": "Destroys a mesh ray-trace object, giving back the trace data and ray-tracing structures it owns. Read from the name; the class is implied by the name, so the resources actually freed are unverified.", + "source": "generated" + }, + "CMeshUtils::Connect": { + "text": "Wires the mesh utilities module up to the outside services it needs when the module is brought online. Read from the name; the class is implied by the name, so which services it takes is unverified.", + "source": "generated" + }, + "CMeshUtils::CreateSkeletonSceneObject": { + "text": "Builds a scene object for a skeleton, the renderable representation that skinned mesh data hangs off. Read from the name; the class is implied by the name, so the inputs it needs and who owns the result are unverified.", + "source": "generated" + }, + "CMeshUtils::Disconnect": { + "text": "Undoes the mesh utilities module's wiring to outside services, dropping the interfaces it had picked up. Read from the name; the class is implied by the name, so what it releases is unverified.", + "source": "generated" + }, + "CMeshUtils::GetBuildType": { + "text": "Reports the build type the mesh utilities module identifies itself with, a value tooling can check for compatibility. Read from the name; the class is implied by the name, so the value's encoding is unverified.", + "source": "generated" + }, + "CMeshUtils::GetDependencies": { + "text": "Names the modules the mesh utilities module declares it depends on, so a host can satisfy them when loading it. Read from the name; the class is implied by the name, so the form of the dependency list is unverified.", + "source": "generated" + }, + "CMeshUtils::GetTier": { + "text": "Reports the initialization tier the mesh utilities module declares, the grouping an engine host uses to organize module startup. Read from the name; the class is implied by the name, so the tier value is unverified.", + "source": "generated" + }, + "CMeshUtils::Init": { + "text": "Purpose is not established beyond generic initialization of the mesh utilities module. The class is implied by the name.", + "source": "generated" + }, + "CMeshUtils::IsSingleton": { + "text": "Reports whether the mesh utilities module is meant to exist as a single shared instance rather than being instantiated per user. Read from the name; the class is implied by the name, so how the answer is consumed is unverified.", + "source": "generated" + }, + "CMeshUtils::PreShutdown": { + "text": "Handles the mesh utilities module's early-teardown stage, meant for work that has to happen ahead of a full shutdown. Read from the name; the class is implied by the name, so what it releases is unverified.", + "source": "generated" + }, + "CMeshUtils::QueryInterface": { + "text": "Hands back an interface the mesh utilities module exposes, looked up by an identifier the caller supplies. Read from the name; the class is implied by the name, so the lookup key and the interfaces on offer are unverified.", + "source": "generated" + }, + "CMeshUtils::Reconnect": { + "text": "Re-points the mesh utilities module at a replacement service interface, covering the case where a dependency is swapped out while running. Read from the name; the class is implied by the name, so the reconnection rules are unverified.", + "source": "generated" + }, + "CMeshUtils::Shutdown": { + "text": "Shuts the mesh utilities module down and tears down the state it created; beyond that generic teardown, purpose is not established. The class is implied by the name.", + "source": "generated" + }, + "CMessage::InputShowMessage": { + "text": "Handles the `ShowMessage` entity-IO input on `CMessage`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMessageEntity::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CMessageEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMessageEntity::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CMessageEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMessageEntity::InputSetMessage": { + "text": "Handles the `SetMessage` entity-IO input on `CMessageEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CModelModifier::Precache": { + "text": "Precaches the resources a model modifier needs so they are resident up front instead of being loaded mid-game, the usual place to register models and materials a modifier will reference. Read from the name and its libserver location; the exact resources it registers are unverified.", + "source": "generated" + }, + "CModelTypeManager::FinalizeResource": { + "text": "Completes setup of a loaded model-type resource so it is ready for use. Read from the name; the CModelTypeManager class is implied by the name, and no prototype is derived, so which resource kinds it accepts and what finalizing entails are unverified.", + "source": "generated" + }, + "CModelTypeManager::GetErrorModel": { + "text": "Hands back the fallback error model used in place of a model that could not be resolved \u2014 the stand-in a modder sees when an asset path is wrong. The class is implied by the name; with no derived prototype, the form of the fallback is unverified.", + "source": "generated" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_BlindingLight_Knockback`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_CameraFollow`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Creature_Full_Avoidance`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Creature_Full_Avoidance`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Creature_HybridFlyer`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_DataDriven`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Diabled_Invulnerable`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Ethereal_Blade_Ethereal`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Ethereal_Blade_Ethereal`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_GreaterClarity`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Bloodstone`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_Crimson_Guard`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_Crimson_Guard_Extra`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_Crimson_Guard_NoStack`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Editor`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Ethereal_Blade`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_Ethereal_Blade`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Ethereal_Blade_Slow`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_Ethereal_Blade_Slow`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Hood_Of_Defiance`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Hood_Of_Defiance_Barrier`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_MagicWand`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_MantaStyle`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Mantle`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_Mantle`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_MaskOfDeath`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_MaskOfDeath`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_OblivionStaff`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Octarine_Core`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_OgreAxe`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Orb_of_Venom`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Orb_of_Venom_Slow`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_RingOfHealth`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Shivas_Guard_Aura`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Shivas_Guard_Blast`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Shivas_Guard_Thinker`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Silver_Edge`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Skadi`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_Skadi`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Skadi_Slow`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_Skadi_Slow`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_StoutShield`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_TalismanOfEvasion`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_UltimateOrb`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_UltimateOrb`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_WraithBand`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Item_Yasha`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Item_Yasha`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_KeeperOfTheLight_BlindingLight`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_LootDrop_Thinker`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_LootDrop_Thinker`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Lua`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Lua`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Lua_Horizontal_Motion`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Lua_Horizontal_Motion`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Lua_Motion_Both`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Lua_Motion_Both`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Lua_Vertical_Motion`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Lua_Vertical_Motion`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_MagicImmune`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Manta`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Manta`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Manta_Phase`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Manta_Phase`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Create": { + "text": "Creates an instance of `CDOTA_Modifier_MjollnirChain`.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_MoveSpeed_Percentage`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Create": { + "text": "Creates an instance of `CDOTA_Modifier_Nevermore_Necromastery`.", + "source": "derived" + }, + "CModifierFactory::Create": { + "text": "Creates an instance of `CDOTA_Modifier_Nian_Leap`.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Phoenix_FireSpiritBurn`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Phoenix_FireSpiritCount`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Phoenix_IcarusDiveBurn`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Phoenix_Sun`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Phoenix_Sun`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Phoenix_Sun_Debuff`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Phoenix_Sun_Debuff`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Phoenix_SupernovaHiding`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Prosperous_Soul`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Create": { + "text": "Creates an instance of `CDOTA_Modifier_Razor_StaticLink`.", + "source": "derived" + }, + "CModifierFactory::Create": { + "text": "Creates an instance of `CDOTA_Modifier_SandKing_SandStorm`.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Silver_Edge_Debuff`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Silver_Edge_Debuff`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Silver_Edge_WindWalk`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Silver_Edge_WindWalk`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Slardar_Amplify_Damage`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Slardar_Amplify_Damage`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Slardar_Slithereen_Crush`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Slardar_Slithereen_Crush`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Slardar_Sprint`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_TangoHeal`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Create": { + "text": "Creates an instance of `CDOTA_Modifier_Tusk_WalrusKick_AirTime`.", + "source": "derived" + }, + "CModifierFactory::Create": { + "text": "Creates an instance of `CDOTA_Modifier_TutorialNPCBlocker`.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_TutorialNPCBlocker`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_TutorialNPCBlocker`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_TutorialNPCBlocker_Thinker`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_TutorialNPCBlocker_Thinker`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_UpgradedBarricade`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_UpgradedMortar`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Weaver_GeminateAttack`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Weaver_TimeLapse`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Create": { + "text": "Creates an instance of `CDOTA_Modifier_Windrunner_FocusFire`.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Wisp_Overcharge`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Wisp_Relocate_Return`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Wisp_Relocate_Return`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Wisp_Relocate_Thinker`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::IsSameType": { + "text": "Reports whether another instance is also `CDOTA_Modifier_Wisp_Relocate_Thinker`, used to match by concrete type.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Wisp_Spirits`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Zuus_LightningBoltThinker`, releasing what its creation allocated.", + "source": "derived" + }, + "CModifierFactory::Destroy": { + "text": "Destroys an instance of `CDOTA_Modifier_Zuus_ThundergodsWrathThinker`, releasing what its creation allocated.", + "source": "derived" + }, + "CMultiLightProxy::ApproachBrightnessThink": { + "text": "Eases the proxy's brightness toward its goal on a think tick, moving m_flCurrentBrightnessMultiplier toward m_flTargetBrightnessMultiplier for the lights it drives. Read from the name and those fields; the easing rate, think interval, and interaction with m_bPerformScreenFade are unverified.", + "source": "generated" + }, + "CMultiLightProxy::InputDisableLights": { + "text": "Handles the `DisableLights` entity-IO input on `CMultiLightProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMultiLightProxy::InputFlickerLights": { + "text": "Handles the `FlickerLights` entity-IO input on `CMultiLightProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMultiLightProxy::InputSetBrightnessDelta": { + "text": "Handles the `SetBrightnessDelta` entity-IO input on `CMultiLightProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CMultiLightProxy::InputSetLightsBrightnessMultiplier": { + "text": "Handles the `SetLightsBrightnessMultiplier` entity-IO input on `CMultiLightProxy`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CNameIndex::AcquirePreindexedName": { + "text": "Takes a reference to a name string that already has an index entry, yielding its interned handle rather than adding the string again. The CNameIndex class is implied by the name; without a derived prototype the lookup key and reference-counting behaviour are unverified.", + "source": "generated" + }, + "CNavDrawArea::DrawArea_Internal": { + "text": "Renders one navigation area's debug visualization and emits `Degenerate area %d` when that area's geometry has collapsed, which makes it the place to watch when auditing generated or hand-authored nav data. Remaining detail is read from the name; the draw style and the conditions that trigger it are not established.", + "source": "generated" + }, + "CNavVolume::CalcCellList": { + "text": "Works out which cells of the nav volume a query region touches \u2014 the spatial bucketing step underneath area lookups in the volume. Read from the name; a prototype is derived, but the region shape and how cells are ordered or bounded are unverified.", + "source": "generated" + }, + "CNavVolume::ForAreasOverlapping": { + "text": "Enumerates the nav areas overlapping a region of the volume, visiting each match in turn instead of building a collection; useful for cheap spatial queries during AI or spawn logic. Read from the name; the region shape and traversal order are unverified.", + "source": "generated" + }, + "CNavVolume::GetOrFindAreasOverlapping": { + "text": "Fetches the nav areas overlapping a region, computing them when a cached answer is not already available. Read from the name; a prototype is derived, but the cache lifetime, invalidation, and region shape are unverified.", + "source": "generated" + }, + "CNavVolume::GetRandomArea": { + "text": "Picks a random nav area out of the volume \u2014 the usual primitive for scattering spawn points or wander destinations. Read from the name; any weighting, filtering, or random-source choice is unverified.", + "source": "generated" + }, + "CNetConsoleMgr::OnSocketAccepted": { + "text": "Handles a newly admitted netconsole client socket, bringing that remote-console connection under the manager's control. The CNetConsoleMgr class is implied by the name; the per-connection state established here is unverified.", + "source": "generated" + }, + "CNetConsoleMgr::OnSocketClosed": { + "text": "Handles a netconsole client socket going away, releasing the manager's bookkeeping for that connection. The class is implied by the name; whether it covers clean disconnects, transport errors, or both is unverified.", + "source": "generated" + }, + "CNetConsoleMgr::ShouldAcceptSocket": { + "text": "Decides whether an incoming netconsole connection is admitted \u2014 the gate to hook when you want to restrict remote console access on a server. The class is implied by the name; the acceptance criteria, such as source address or password checks, are unverified.", + "source": "generated" + }, + "CNetworkClientService::OnClientFrameSimulate": { + "text": "Performs the client service's per-frame simulation work for a connected client, giving a per-tick hook point on the engine's client-service side. The CNetworkClientService class is implied by the name; what it simulates and where in the frame it lands are unverified.", + "source": "generated" + }, + "CNetworkEncodingStats::Clear": { + "text": "Resets accumulated network-encoding statistics back to empty, discarding counters gathered so far. The class is implied by the name; which counters are cleared versus retained is unverified.", + "source": "generated" + }, + "CNetworkEncodingStats::Flush": { + "text": "Pushes buffered encoding statistics out of the in-progress accumulator, committing pending measurements. The class is implied by the name; the destination of the flushed data and whether counters survive it are unverified.", + "source": "generated" + }, + "CNetworkEncodingStats::HookDeltaBits": { + "text": "Records the bit cost of a delta-encoded network update into the statistics \u2014 the sampling point behind per-field bandwidth accounting. The class is implied by the name; what the cost is attributed to is unverified.", + "source": "generated" + }, + "CNetworkEncodingStats::Init": { + "text": "Prepares the encoding-statistics collector for use; beyond that, purpose is not established. The CNetworkEncodingStats class is implied by the name.", + "source": "generated" + }, + "CNetworkEncodingStats::MessageData": { + "text": "Accounts for the encoded payload of a network message in the statistics, feeding per-message size tracking. The class is implied by the name; the categories recorded and how messages are keyed are unverified.", + "source": "generated" + }, + "CNetworkEncodingStats::Shutdown": { + "text": "Tears the encoding-statistics collector down and releases its state; beyond that, purpose is not established. The CNetworkEncodingStats class is implied by the name.", + "source": "generated" + }, + "CNetworkEncodingStats::Update": { + "text": "Advances the encoding statistics for the current sampling period, rolling accumulated samples forward. The class is implied by the name; the cadence and what gets recomputed are unverified.", + "source": "generated" + }, + "CNetworkFieldSerializerAllocator::FindOrAddField": { + "text": "Looks up a networked field's serializer entry and creates one when it is absent, so identical field descriptions share a single serializer. The CNetworkFieldSerializerAllocator class is implied by the name; the identity used for matching is unverified.", + "source": "generated" + }, + "CNetworkFieldSerializerAllocator::Purge": { + "text": "Frees the allocator's serializer storage, dropping the cached field serializers it holds. The class is implied by the name; what, if anything, survives the purge is unverified.", + "source": "generated" + }, + "CNetworkFieldSerializerAllocator::PurgeTemporaryData": { + "text": "Releases only the allocator's transient storage while leaving long-lived serializer entries in place \u2014 a lighter cleanup than a full purge. The class is implied by the name; which data counts as temporary is unverified.", + "source": "generated" + }, + "CNetworkFieldSerializerAllocator::Report": { + "text": "Produces a diagnostic report on the field serializers the allocator holds, handy when investigating networking-table growth. The class is implied by the name; the report's contents and where it is written are unverified.", + "source": "generated" + }, + "CNetworkGameServer::ActivateServer": { + "text": "Brings the game server into its active, playable state for the loaded level. The CNetworkGameServer class is implied by the name; the specific activation work and the state it leaves behind are unverified.", + "source": "generated" + }, + "CNetworkGameServer::CheckTimeouts": { + "text": "Examines connected clients for timed-out connections, spotting links that have stopped responding within the permitted window. Read from the name; the thresholds applied and the action taken on an expired client are unverified.", + "source": "generated" + }, + "CNetworkGameServer::DeactivateSteamGameServer": { + "text": "Shuts the server's Steam game-server session down, ending its registration with Steam's backend. The CNetworkGameServer class is implied by the name; exactly which Steam state is torn down is unverified.", + "source": "generated" + }, + "CNetworkGameServer::OnValidateAuthTicketResponse": { + "text": "Handles the verdict of a Steam auth-ticket validation for a connecting client \u2014 where authentication success or rejection lands on the server. Read from the name; the rejection handling and any ban- or licence-state detail are unverified.", + "source": "generated" + }, + "CNetworkGameServer::SendClientMessages": { + "text": "Ships the server's queued per-client network messages for the current tick. Read from the name; batching, prioritisation, and reliable-versus-unreliable handling are unverified.", + "source": "generated" + }, + "CNetworkGameServer::SpawnServer": { + "text": "Stands a server instance up for a map or session, creating the server-side state a fresh level needs. The CNetworkGameServer class is implied by the name; what is rebuilt versus preserved across a spawn is unverified.", + "source": "generated" + }, + "CNetworkGameServer::WriteClassInfosAndSerializesToBuffer": { + "text": "Serializes the server's class-info and field-serializer tables into a buffer for delivery to clients \u2014 the network schema handshake data. Read from the name; the buffer format, compression, and versioning are unverified.", + "source": "generated" + }, + "CNetworkGameServerBase::CNetworkGameServerBase": { + "text": "Constructs the base network game server object and initialises its state. Purpose beyond construction is not established.", + "source": "generated" + }, + "CNetworkGameServerBase::SetServerState": { + "text": "Sets the server's lifecycle state value \u2014 the marker other systems read to tell whether the server is loading, active, or shutting down. The CNetworkGameServerBase class is implied by the name; the available states and any side effects of a transition are unverified.", + "source": "generated" + }, + "CNetworkMessages::AssociateNetMessageGroupIdWithChannelCategory": { + "text": "Binds a net-message group id to a channel category, so messages carried under that group id pick up the category's networking treatment. The class CNetworkMessages is implied by the name, and the reading comes from the name, so the exact identifiers and effect on transmission are unverified.", + "source": "generated" + }, + "CNetworkMessages::AssociateNetMessageWithChannelCategoryAbstract": { + "text": "Associates a single network message with a channel category, in the abstract form that takes the message generically rather than as a concrete typed message. The class is implied by the name; this is a name-level reading, so what identifies the message and how the category is applied are unverified.", + "source": "generated" + }, + "CNetworkMessages::ComputeOrderForPriority": { + "text": "Turns a message or field priority value into the ordering rank the networking system uses for it. The class is implied by the name, and the mapping from priority to rank is read from the name alone, so its scale and direction are unverified.", + "source": "generated" + }, + "CNetworkMessages::FindOrCreateGroupId": { + "text": "Resolves a network-message group id for a given group, creating the id if that group has not been registered yet. Read from the name and located by signature in libnetworksystem; no prototype is derived, so the lookup key and creation rules are unverified.", + "source": "generated" + }, + "CNetworkMessages::FindOrCreateNetMessage": { + "text": "Resolves a registered network message by its identity, registering a new message entry when no match exists. The class is implied by the name; this reading is name-level, so the lookup criteria and what a freshly created message carries are unverified.", + "source": "generated" + }, + "CNetworkMessages::RegisterFieldChangeCallbackPriority": { + "text": "Registers a priority for a field-change callback, so change notifications can be ranked instead of treated as equal. The class is implied by the name; useful to know when hooking field-change notification, though the priority scale and how the callback is identified are unverified.", + "source": "generated" + }, + "CNetworkMessages::RegisterNetworkCategory": { + "text": "Registers a channel category with the network-message system, defining a category that messages and groups can be associated with. The class is implied by the name, and the reading rests on the name, so the category's configurable properties are unverified.", + "source": "generated" + }, + "CNetworkMessages::RegisterNetworkFieldSerializer": { + "text": "Registers a field serializer with the networking system, declaring how a particular networked field is encoded and decoded on the wire. The class is implied by the name; this is a name-level reading, so what the registration keys on is unverified.", + "source": "generated" + }, + "CNetworkP2PService::BroadcastP2PNetMessageAbstract": { + "text": "Sends a peer-to-peer network message, in its type-erased abstract form, out to the connected peers. Read from the name, and the owning class is implied by the name rather than recovered from the data, so the recipients and the message form are unverified.", + "source": "generated" + }, + "CNetworkP2PService::Connect": { + "text": "Establishes a peer-to-peer connection to a peer. Read from the name; the owning class is implied by the name rather than recovered from the data, so what identifies the target peer is unverified.", + "source": "generated" + }, + "CNetworkP2PService::Disconnect": { + "text": "Closes an existing peer-to-peer connection and drops the peer state that went with it. Read from the name; the owning class is implied by the name, not established by the data.", + "source": "generated" + }, + "CNetworkP2PService::GetAllPeersEventDispatcher": { + "text": "Provides the event dispatcher for peer events covering all peers, the natural hook point for observing peer activity from a mod. Read from the name; the class is implied by the name, so what the dispatcher exposes is unverified.", + "source": "generated" + }, + "CNetworkP2PService::GetBuildType": { + "text": "Reports the build type recorded for the service. Read from the name; the class is implied by the name, and what the value encodes is not established.", + "source": "generated" + }, + "CNetworkP2PService::GetDependencies": { + "text": "Reports the dependencies this service declares, a broader companion to CNetworkP2PService::GetServiceDependencies. Read from the name; the class is implied by the name, so what a dependency entry contains is unverified.", + "source": "generated" + }, + "CNetworkP2PService::GetName": { + "text": "Reports the service's name; no purpose beyond that accessor role is established. The class is implied by the name rather than recovered from the data.", + "source": "generated" + }, + "CNetworkP2PService::GetServiceDependencies": { + "text": "Reports the other services this one declares it requires, a service-scoped counterpart to CNetworkP2PService::GetDependencies. Read from the name; the class is implied by the name, and the dependency representation is unverified.", + "source": "generated" + }, + "CNetworkP2PService::GetServiceIndex": { + "text": "Reports the index the service holds in its host's service table, the value written by CNetworkP2PService::SetServiceIndex. Read from the name; the class is implied by the name, so the indexing scheme is unverified.", + "source": "generated" + }, + "CNetworkP2PService::GetTier": { + "text": "Reports the tier the service is classified under. Read from the name; the class is implied by the name, and the meaning of the tier values is not established.", + "source": "generated" + }, + "CNetworkP2PService::Init": { + "text": "Initialization entry point for the service; the specific work it performs is not established. The class is implied by the name rather than derived from the data.", + "source": "generated" + }, + "CNetworkP2PService::IsActive": { + "text": "Reports whether the service is currently active, the state that CNetworkP2PService::SetActive writes. Read from the name; the class is implied by the name, not recovered from the data.", + "source": "generated" + }, + "CNetworkP2PService::IsKnownPeer": { + "text": "Tests whether a given peer is already known to the service, useful as a check before contacting or trusting it. Read from the name; the class is implied by the name, so how a peer is identified here is unverified.", + "source": "generated" + }, + "CNetworkP2PService::IsSingleton": { + "text": "Reports whether the service is a singleton within its host. Read from the name; the class is implied by the name, and the data does not establish how the answer is used.", + "source": "generated" + }, + "CNetworkP2PService::OnLoopActivate": { + "text": "Handles the notification that the engine loop the service lives in has become active, the point at which it would bring its peer-to-peer work online. Read from the name; the class is implied by the name and the work performed is unverified.", + "source": "generated" + }, + "CNetworkP2PService::OnLoopDeactivate": { + "text": "Handles the notification that the containing engine loop has become inactive, where the service would quiesce its peer-to-peer work. Read from the name; the class is implied by the name, so what it tears down is unverified.", + "source": "generated" + }, + "CNetworkP2PService::OnPeerToPeerNetChannelCreated": { + "text": "Handles the creation of a new peer-to-peer net channel, the service's opportunity to adopt and track that channel. Read from the name; the class is implied by the name, so the bookkeeping involved is unverified.", + "source": "generated" + }, + "CNetworkP2PService::OnShutdownChannel": { + "text": "Handles a channel shutdown notification, where the service would release the state it kept for that channel. Read from the name; the class is implied by the name, and which channel is affected is not established.", + "source": "generated" + }, + "CNetworkP2PService::PeerGroupChanged": { + "text": "Reacts to a change in the peer group, the same subject that handlers given to CNetworkP2PService::RegisterPeerGroupHandler concern. Read from the name; the class is implied by the name, so the change detail involved is unverified.", + "source": "generated" + }, + "CNetworkP2PService::PreShutdown": { + "text": "Early shutdown pass for the service, a stage distinct from CNetworkP2PService::Shutdown. Read from the name; the class is implied by the name, and what it releases at this stage is not established.", + "source": "generated" + }, + "CNetworkP2PService::QueryInterface": { + "text": "Looks up an interface exposed by the service for a requested interface identifier. Read from the name; the class is implied by the name, so which interfaces are obtainable is unverified.", + "source": "generated" + }, + "CNetworkP2PService::Reconnect": { + "text": "Re-establishes a peer-to-peer connection that was lost or torn down. Read from the name; the class is implied by the name, and whether it reuses prior peer state is unverified.", + "source": "generated" + }, + "CNetworkP2PService::RegisterEventMap": { + "text": "Registers the service's event map, making its event handlers visible to the engine's event system. Read from the name; the class is implied by the name, so the map's contents are unverified.", + "source": "generated" + }, + "CNetworkP2PService::RegisterP2PNetMessageAbstract": { + "text": "Registers a peer-to-peer network message type in its type-erased abstract form so the service can carry it, the registration counterpart to CNetworkP2PService::BroadcastP2PNetMessageAbstract. Read from the name; the class is implied by the name, and the registry it feeds is unverified.", + "source": "generated" + }, + "CNetworkP2PService::RegisterPeerGroupHandler": { + "text": "Registers a handler that will be notified about peer-group changes; this is the entry point to use when a mod needs to observe group membership. Read from the name; the class is implied by the name, so the handler's shape is unverified.", + "source": "generated" + }, + "CNetworkP2PService::SetActive": { + "text": "Sets the service's active state, the flag reported by CNetworkP2PService::IsActive. Read from the name; the class is implied by the name rather than derived from the data.", + "source": "generated" + }, + "CNetworkP2PService::SetName": { + "text": "Sets the service's name, the value reported by CNetworkP2PService::GetName. Read from the name; the class is implied by the name, not recovered from the data.", + "source": "generated" + }, + "CNetworkP2PService::SetServiceIndex": { + "text": "Assigns the service's index within its host's service table, the value reported by CNetworkP2PService::GetServiceIndex. Read from the name; the class is implied by the name, and the indexing scheme is unverified.", + "source": "generated" + }, + "CNetworkP2PService::ShouldActivate": { + "text": "Reports whether the service wants activation in the current context, acting as a gate on it coming up at all. Read from the name; the class is implied by the name, and the conditions it tests are unverified.", + "source": "generated" + }, + "CNetworkP2PService::Shutdown": { + "text": "Shuts the service down, releasing the peer-to-peer connections and registrations it holds. Read from the name; the class is implied by the name, so exactly what is released is unverified.", + "source": "generated" + }, + "CNetworkP2PService::SteamIDAllowedToP2PConnect": { + "text": "Decides whether a given Steam ID is permitted to open a peer-to-peer connection, the obvious gate for restricting who may connect. Read from the name; the class is implied by the name, so the policy it applies is unverified.", + "source": "generated" + }, + "CNetworkP2PService::UnregisterPeerGroupHandler": { + "text": "Removes a previously registered peer-group handler, undoing CNetworkP2PService::RegisterPeerGroupHandler. Read from the name; the class is implied by the name, and how a handler is matched for removal is unverified.", + "source": "generated" + }, + "CNetworkP2PService::UpdatePeerConnectionStatus": { + "text": "Updates the connection status the service tracks for a peer, refreshing that record as the link's state changes. Read from the name and located by signature in libengine2; no prototype is derived, so the status values and the update conditions are unverified.", + "source": "generated" + }, + "CNetworkP2PService::~CNetworkP2PService": { + "text": "Destroys the service instance, releasing the peer-to-peer state and registrations it holds. Read from the name; the class is implied by the name, and the teardown it performs is unverified.", + "source": "generated" + }, + "CNetworkSerializer::AssignRangeMultiplier": { + "text": "Sets the range multiplier a serializer applies to a field's value, the scale factor that quantized network encoding uses when packing that value. Read from the name and located by signature in libnetworksystem; the reading is low-confidence and the affected field and units are unverified.", + "source": "generated" + }, + "CNetworkSerializerBindingBuildFilter::GetFieldPriority": { + "text": "Reports the priority a filter assigns to a field while a network serializer binding is being built, letting fields be ranked rather than treated uniformly. The class is implied by the name; the priority scale and what the field is identified by are unverified.", + "source": "generated" + }, + "CNetworkServerService::OnWriteNetworkingMetaFile": { + "text": "Handles the server's write of its networking meta file, the hook where the network server service contributes or finalizes that output. The class is implied by the name; the file's contents, location and the conditions for writing it are unverified.", + "source": "generated" + }, + "CNetworkServerService::StartupServer": { + "text": "Brings the game server's networking online for a session, the entry point a modder would watch or hook to react to server startup. The class is implied by the name; the startup inputs it takes and what state exists once it completes are unverified.", + "source": "generated" + }, + "CNetworkServerSpawnGroup::LoadEntities": { + "text": "Loads the entities belonging to a network server spawn group, instantiating that group's entity set server-side. The class is implied by the name; useful as the point where spawn-group entities come into existence, though the load's inputs and any staging behaviour are unverified.", + "source": "generated" + }, + "CNetworkService::ConfigureSockets": { + "text": "Applies the socket configuration the network service communicates over, establishing or re-applying its endpoints. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the exact settings it applies are unverified.", + "source": "generated" + }, + "CNetworkService::Connect": { + "text": "Brings the service's connection up, attaching it to whatever endpoint or host it talks to. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the target and the conditions are unverified.", + "source": "generated" + }, + "CNetworkService::Disconnect": { + "text": "Tears the service's connection down, detaching it from the endpoint it was attached to. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so what state survives the teardown is unverified.", + "source": "generated" + }, + "CNetworkService::GetBuildType": { + "text": "Reports the build type the service was produced under, the kind of value a modder would branch on when debug and release builds differ. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the value space is unverified.", + "source": "generated" + }, + "CNetworkService::GetDependencies": { + "text": "Reports the dependencies the service requires to come up, useful when ordering your own module against the engine's service set. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the form of the dependency list is unverified.", + "source": "generated" + }, + "CNetworkService::GetName": { + "text": "Retrieves the service's name, the counterpart to CNetworkService::SetName. Beyond that the name establishes no further purpose, and the owning CNetworkService class is implied by the name, not by the data.", + "source": "generated" + }, + "CNetworkService::GetServiceDependencies": { + "text": "Reports the other services this one depends on, distinct from the broader CNetworkService::GetDependencies. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the contents and form of the list are unverified.", + "source": "generated" + }, + "CNetworkService::GetServiceIndex": { + "text": "Retrieves the index the service is registered under, the counterpart to CNetworkService::SetServiceIndex and the handle you would use to identify it among registered services. The owning CNetworkService class is implied by the name, not by the data.", + "source": "generated" + }, + "CNetworkService::GetTier": { + "text": "Reports the tier the service belongs to, the layering value used to group engine services. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the tier numbering is unverified.", + "source": "generated" + }, + "CNetworkService::Init": { + "text": "Generic initialization entry point for the service; the name does not establish what it actually sets up, so treat its purpose as unestablished. The owning CNetworkService class is implied by the name, not by the data.", + "source": "generated" + }, + "CNetworkService::IsActive": { + "text": "Reports whether the service is currently active, the query counterpart to CNetworkService::SetActive. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so what activity means here is unverified.", + "source": "generated" + }, + "CNetworkService::IsSingleton": { + "text": "Reports whether the service is a singleton rather than something instantiated per user. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the meaning the engine attaches to the flag is unverified.", + "source": "generated" + }, + "CNetworkService::OnLoopActivate": { + "text": "Handles the service's activation within an engine loop, the hook where loop-scoped networking state would be brought up. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the triggering conditions are unverified.", + "source": "generated" + }, + "CNetworkService::OnLoopDeactivate": { + "text": "Handles the service's deactivation within an engine loop, the counterpart to CNetworkService::OnLoopActivate for releasing loop-scoped state. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the triggering conditions are unverified.", + "source": "generated" + }, + "CNetworkService::PreShutdown": { + "text": "Performs the service's pre-shutdown teardown step, the lighter cleanup distinguished by name from CNetworkService::Shutdown. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so what it releases is unverified.", + "source": "generated" + }, + "CNetworkService::QueryInterface": { + "text": "Looks up an interface the service exposes and hands back access to it, the usual way a module reaches engine functionality it did not link against. The owning CNetworkService class is implied by the name, not by the data, so the lookup key is unverified.", + "source": "generated" + }, + "CNetworkService::Reconnect": { + "text": "Re-establishes the service's connection after it has been dropped or needs re-targeting. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the retry behaviour and target are unverified.", + "source": "generated" + }, + "CNetworkService::RegisterEventMap": { + "text": "Registers the service's event map, the table associating engine events with the service's handling of them. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the map's shape is unverified.", + "source": "generated" + }, + "CNetworkService::SetActive": { + "text": "Sets the service's active state, the write counterpart to CNetworkService::IsActive and the switch for enabling or suspending it. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the side effects are unverified.", + "source": "generated" + }, + "CNetworkService::SetName": { + "text": "Assigns the service's name, the write counterpart to CNetworkService::GetName. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so whether the string is copied or referenced is unverified.", + "source": "generated" + }, + "CNetworkService::SetServiceIndex": { + "text": "Assigns the index the service is registered under, the write counterpart to CNetworkService::GetServiceIndex. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so who assigns the index is unverified.", + "source": "generated" + }, + "CNetworkService::ShouldActivate": { + "text": "Answers whether the service ought to be activated, a predicate a service can use to opt itself in or out. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the inputs to the decision are unverified.", + "source": "generated" + }, + "CNetworkService::Shutdown": { + "text": "Shuts the service down, releasing what it holds and leaving it inactive. Read from the name; the owning CNetworkService class is implied by the name, not by the data, so the exact resources released are unverified.", + "source": "generated" + }, + "CNetworkService::~CNetworkService": { + "text": "Destroys the service instance, releasing the memory and resources it owns. This is the destructor read from the name, and the owning CNetworkService class is implied by the name, not by the data.", + "source": "generated" + }, + "CNetworkStringDict::Count": { + "text": "Reports how many entries the string dictionary currently holds, the bound you would iterate against when walking it. Read from the name; the owning CNetworkStringDict class is implied by the name, not by the data, so whether the count includes freed slots is unverified.", + "source": "generated" + }, + "CNetworkStringDict::Element": { + "text": "Fetches the entry stored at a given index in the dictionary, the indexed accessor for walking its contents. Read from the name; the owning CNetworkStringDict class is implied by the name, not by the data, so what an element carries beyond its text is unverified.", + "source": "generated" + }, + "CNetworkStringDict::Find": { + "text": "Looks a string up in the dictionary and yields its index if the dictionary holds it, the lookup path for turning text into a compact handle. The owning CNetworkStringDict class is implied by the name, not by the data, so the not-found result is unverified.", + "source": "generated" + }, + "CNetworkStringDict::Insert": { + "text": "Adds a string to the dictionary and yields the index it is stored under, the interning path used to register new text. Read from the name; the owning CNetworkStringDict class is implied by the name, not by the data, so duplicate handling is unverified.", + "source": "generated" + }, + "CNetworkStringDict::IsValidIndex": { + "text": "Reports whether an index refers to a live entry in the dictionary, the guard to apply before indexing with CNetworkStringDict::Element. The owning CNetworkStringDict class is implied by the name, not by the data, so the validity rule is unverified.", + "source": "generated" + }, + "CNetworkStringDict::Purge": { + "text": "Empties the dictionary, discarding its stored strings and releasing their storage so it can be reused. Read from the name; the owning CNetworkStringDict class is implied by the name, not by the data, so whether previously handed-out indices survive is unverified.", + "source": "generated" + }, + "CNetworkStringDict::String": { + "text": "Retrieves the text for an entry in the dictionary, the reverse of CNetworkStringDict::Find for turning a handle back into a string. The owning CNetworkStringDict class is implied by the name, not by the data, so the lifetime of the returned text is unverified.", + "source": "generated" + }, + "CNetworkStringDict::~CNetworkStringDict": { + "text": "Destroys the string dictionary, releasing the entries and backing storage it owns. This is the destructor read from the name, and the owning CNetworkStringDict class is implied by the name, not by the data.", + "source": "generated" + }, + "CNetworkStringTable::AddString": { + "text": "Adds a string entry to a networked string table, the replicated name/index list such a table holds. The class is implied by the name; a prototype is derived, but duplicate handling and when the new entry becomes visible to clients are unverified.", + "source": "generated" + }, + "CNetworkStringTable::SetStringUserData": { + "text": "Attaches or replaces the user-data blob carried alongside an existing entry in a networked string table. The class is implied by the name; a prototype is derived, though how the entry is identified and whether the change replicates are not established here.", + "source": "generated" + }, + "CNetworkStringTable::UpdateMirrorTable": { + "text": "Brings a mirrored copy of the table back in step with the table's current contents. Located by signature in libengine2 and read from the name, so what the mirror is and when it is refreshed remain unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::Connect": { + "text": "Performs the container's connect-time bring-up, the point at which the string-table system is handed its startup context. The class is implied by the name, and this is a name-level reading of a lifecycle entry point, so the actual work it does is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::CreateStringTable": { + "text": "Creates a new network string table inside the container and registers it so it can later be looked up. The class is implied by the name; the naming, sizing and replication options available at creation are not established by this data.", + "source": "generated" + }, + "CNetworkStringTableContainer::DirectUpdate": { + "text": "Applies an update to string-table contents directly rather than through the container's usual incremental path. Located by signature in libengine2 and read from the name, so what it updates and when that is appropriate are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::Disconnect": { + "text": "Releases the connect-time context the container acquired, undoing its bring-up. The class is implied by the name, and the reading is name-level, so what is actually torn down is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::FindTable": { + "text": "Looks up an existing string table held by the container using its name. The class is implied by the name; a prototype is derived, though the matching rule and the behaviour when nothing matches are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetBuildType": { + "text": "Reports the build type the string-table system identifies itself with, part of the container's lifecycle description. The class is implied by the name, and the meaning of the reported value is not established here.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetDependencies": { + "text": "Reports the systems this container declares a dependency on, part of its lifecycle description. The class is implied by the name; the form and contents of that dependency list are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetNumTables": { + "text": "Reports how many string tables the container currently holds, the count a modder uses when walking them with CNetworkStringTableContainer::GetTable. The class is implied by the name; a prototype is derived, but what the count includes is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetTable": { + "text": "Fetches one of the container's string tables by position, the companion to CNetworkStringTableContainer::GetNumTables when enumerating them. The class is implied by the name; a prototype is derived, though out-of-range behaviour is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::GetTier": { + "text": "Reports the initialization tier the container declares, part of its lifecycle description. The class is implied by the name, and the tier value itself is not established here.", + "source": "generated" + }, + "CNetworkStringTableContainer::Init": { + "text": "Purpose beyond generic initialization of the container is not established; the name indicates nothing more specific. The class is implied by the name.", + "source": "generated" + }, + "CNetworkStringTableContainer::IsSingleton": { + "text": "Reports whether the string-table container is a singleton system, meaning one shared instance serves the process. The class is implied by the name, and the reading is name-level.", + "source": "generated" + }, + "CNetworkStringTableContainer::PreShutdown": { + "text": "Performs the container's pre-shutdown pass, work done ahead of the main teardown handled by CNetworkStringTableContainer::Shutdown. The class is implied by the name; what it releases at this stage is not established here.", + "source": "generated" + }, + "CNetworkStringTableContainer::QueryInterface": { + "text": "Resolves a named interface the container exposes, the usual way a caller obtains a specific interface from a Source-2 system object. The class is implied by the name; which interface names it accepts is not established here.", + "source": "generated" + }, + "CNetworkStringTableContainer::Reconnect": { + "text": "Re-establishes a system interface the container previously acquired, for cases where that interface is swapped after bring-up. The class is implied by the name, and this name-level reading leaves the reconnect conditions unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::RemoveAllTables": { + "text": "Empties the container of its string tables in one operation, discarding what they hold. The class is implied by the name; a prototype is derived, but whether table memory is freed or merely cleared is unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::SetAllowClientSideAddString": { + "text": "Toggles the container-level permission that lets client-side code add strings to tables, a useful switch when a mod adds entries outside the server. The class is implied by the name; the scope of the toggle and its default state are unverified.", + "source": "generated" + }, + "CNetworkStringTableContainer::Shutdown": { + "text": "Shuts the string-table container down, releasing what it holds. The class is implied by the name, and beyond generic teardown the purpose is not established.", + "source": "generated" + }, + "CNetworkStringTableContainer::~CNetworkStringTableContainer": { + "text": "Destroys the container instance along with the tables it owns. The class is implied by the name; a prototype is derived, but which resources the destructor actually frees is unverified.", + "source": "generated" + }, + "CNetworkStringTableItem::SetUserData": { + "text": "Sets the user-data payload carried by a single string-table entry, the per-item blob that travels with the string. Located by signature in libengine2 and read from the name, so size limits and replication behaviour are unverified.", + "source": "generated" + }, + "CNetworkSystem::InitGameServer": { + "text": "Brings up the networking system's game-server side, the state a process needs to act as a server. The class is implied by the name; a prototype is derived, though the initialization it performs is not established here.", + "source": "generated" + }, + "CNetworkSystem::Shutdown": { + "text": "Shuts the networking system down as a whole, a broader teardown than the server-side-only CNetworkSystem::ShutdownGameServer. The class is implied by the name; a prototype is derived, but what it closes is unverified.", + "source": "generated" + }, + "CNetworkSystem::ShutdownGameServer": { + "text": "Tears down the game-server side of the networking system, the counterpart to CNetworkSystem::InitGameServer. The class is implied by the name; a prototype is derived, though whether a later re-init is supported is unverified.", + "source": "generated" + }, + "CNetworkTransmitComponent::StateChanged": { + "text": "Marks an entity's transmit state as changed so its networking is re-evaluated; m_nTransmitStateOwnedCounter is the field to inspect alongside it. Located by signature in libserver and read from the name, so the conditions under which it applies are unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::OnCreateBlendState": { + "text": "Services a blend-state creation request in the null shader path, satisfying the call without producing a real GPU object \u2014 the arrangement a headless dedicated server runs under. The class is implied by the name, and whether it does anything beyond succeeding is unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::OnCreateDepthStencilState": { + "text": "Services a depth-stencil-state creation request in the null shader path, where no real graphics object is produced. The class is implied by the name; whether it records anything or simply succeeds is unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::OnCreateRasterizerState": { + "text": "Services a rasterizer-state creation request in the null shader path, satisfying the call on a build with no rendering back end. The class is implied by the name, and whether any state is retained is unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::OnCreateShader": { + "text": "Services a shader creation request in the null shader path, letting shader-consuming code run where no GPU shader can be built. The class is implied by the name; whether a placeholder object is produced is unverified.", + "source": "generated" + }, + "CNullShaderCreateCallbacks::~CNullShaderCreateCallbacks": { + "text": "Destroys the null shader-callback object. The class is implied by the name; a prototype is derived, but the destructor's work is not established.", + "source": "generated" + }, + "COrnamentProp::InputDetach": { + "text": "Handles the `Detach` entity-IO input on `COrnamentProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "COrnamentProp::InputSetAttached": { + "text": "Handles the `SetAttached` entity-IO input on `COrnamentProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPackedStore::GrowCount": { + "text": "Grows a count or capacity in the packed-store bookkeeping so more entries fit. Located by signature in libfilesystem_stdio at low confidence and read from the name, so what is grown, by how much, and when are unverified.", + "source": "generated" + }, + "CParticleControlPointModifier::Init": { + "text": "Sets up a particle control-point modifier, reading the control_point_number key that selects which control point the modifier drives. The anchor string is present in libserver; the rest of the setup, including defaults when the key is absent, is unverified.", + "source": "generated" + }, + "CParticleCreateModifier::Init": { + "text": "Initialises a particle-creation modifier from its configuration block, consuming the key `spawn_in_alternate_loadout_only`, a loadout gate on whether the modifier applies. The anchor establishes that key; the remaining fields it reads, and its effect on particle spawning, are not derived here.", + "source": "generated" + }, + "CParticleModifier::Init": { + "text": "Initialises a particle modifier from its configuration block, consuming the key `replacement_type`, which selects the kind of replacement the modifier performs. The anchor establishes that key; what is swapped in and the modifier's other inputs remain unverified.", + "source": "generated" + }, + "CPathCorner::InputInPass": { + "text": "Handles the `InPass` entity-IO input on `CPathCorner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathCorner::InputSetNextPathCorner": { + "text": "Handles the `SetNextPathCorner` entity-IO input on `CPathCorner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputRemoveFromTemplate": { + "text": "Handles the `RemoveFromTemplate` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputSetPathNodeStart": { + "text": "Handles the `SetPathNodeStart` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputSpawn": { + "text": "Handles the `Spawn` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathMoverEntitySpawner::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPathMoverEntitySpawner`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputDestroy": { + "text": "Handles the `DestroyImmediately` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputDisablePin": { + "text": "Handles the `DisablePin` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputSetRadius": { + "text": "Handles the `SetRadius` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputSetSlack": { + "text": "Handles the `SetSlack` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputStart": { + "text": "Handles the `Start` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathParticleRope::InputStopEndCap": { + "text": "Handles the `StopPlayEndCap` entity-IO input on `CPathParticleRope`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputDisableAlternatePath": { + "text": "Handles the `DisableAlternatePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputDisablePath": { + "text": "Handles the `DisablePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputEnableAlternatePath": { + "text": "Handles the `EnableAlternatePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputEnablePath": { + "text": "Handles the `EnablePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputPass": { + "text": "Handles the `InPass` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputToggleAlternatePath": { + "text": "Handles the `ToggleAlternatePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPathTrack::InputTogglePath": { + "text": "Handles the `TogglePath` entity-IO input on `CPathTrack`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPetModifier::Init": { + "text": "Initialises a pet modifier from its configuration block, consuming `pet_npc_script_override`, which names a script replacing the pet NPC's default behaviour. Read from that anchor; how the override is resolved and applied, and the modifier's other inputs, are unverified.", + "source": "generated" + }, + "CPhysBox::InputDisableMotion": { + "text": "Handles the `DisableMotion` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysBox::InputEnableMotion": { + "text": "Handles the `EnableMotion` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysBox::InputForceDrop": { + "text": "Handles the `ForceDrop` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysBox::InputSleep": { + "text": "Handles the `Sleep` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysBox::InputWake": { + "text": "Handles the `Wake` entity-IO input on `CPhysBox`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputBreak": { + "text": "Handles the `Break` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputDisableAngularConstraint": { + "text": "Handles the `DisableAngularConstraint` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputDisableLinearConstraint": { + "text": "Handles the `DisableLinearConstraint` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputEnableAngularConstraint": { + "text": "Handles the `EnableAngularConstraint` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputEnableLinearConstraint": { + "text": "Handles the `EnableLinearConstraint` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputOnBreak": { + "text": "Handles the `ConstraintBroken` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputSetMotorTargetVelocity": { + "text": "Handles the `SetMotorTargetVelocity` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputSetMotorTorqueFactor": { + "text": "Handles the `SetMotorTorqueFactor` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputTurnMotorOff": { + "text": "Handles the `TurnMotorOff` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputTurnMotorOn": { + "text": "Handles the `TurnMotorOn` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysConstraint::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CPhysConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysExplosion::InputExplode": { + "text": "Handles the `Explode` entity-IO input on `CPhysExplosion`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysFixed::InputSetAngularDampingRatio": { + "text": "Handles the `SetAngularDampingRatio` entity-IO input on `CPhysFixed`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysFixed::InputSetAngularFrequency": { + "text": "Handles the `SetAngularFrequency` entity-IO input on `CPhysFixed`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysFixed::InputSetLinearDampingRatio": { + "text": "Handles the `SetLinearDampingRatio` entity-IO input on `CPhysFixed`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysFixed::InputSetLinearFrequency": { + "text": "Handles the `SetLinearFrequency` entity-IO input on `CPhysFixed`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysForce::InputActivate": { + "text": "Handles the `Activate` entity-IO input on `CPhysForce`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysForce::InputDeactivate": { + "text": "Handles the `Deactivate` entity-IO input on `CPhysForce`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysForce::InputForceScale": { + "text": "Handles the `scale` entity-IO input on `CPhysForce`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetHingeFriction": { + "text": "Handles the `SetHingeFriction` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetMaxLimit": { + "text": "Handles the `SetMaxLimit` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetMinLimit": { + "text": "Handles the `SetMinLimit` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetMotorTargetAngle": { + "text": "Handles the `SetMotorTargetAngle` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysHinge::InputSetVelocity": { + "text": "Handles the `SetAngularVelocity` entity-IO input on `CPhysHinge`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysImpact::InputImpact": { + "text": "Handles the `Impact` entity-IO input on `CPhysImpact`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMagnet::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPhysMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMagnet::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CPhysMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMagnet::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CPhysMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMotor::InputSetFriction": { + "text": "Handles the `SetFriction` entity-IO input on `CPhysMotor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMotor::InputSetTargetSpeed": { + "text": "Handles the `SetSpeed` entity-IO input on `CPhysMotor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMotor::InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input on `CPhysMotor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysMotor::InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input on `CPhysMotor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysSlideConstraint::InputSetOffset": { + "text": "Handles the `SetOffset` entity-IO input on `CPhysSlideConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysSlideConstraint::InputSetSlideFriction": { + "text": "Handles the `SetSlideFriction` entity-IO input on `CPhysSlideConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysSlideConstraint::InputSetVelocity": { + "text": "Handles the `SetVelocity` entity-IO input on `CPhysSlideConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysWheelConstraint::InputSetMaxSuspensionOffset": { + "text": "Handles the `SetMaxSuspensionOffset` entity-IO input on `CPhysWheelConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysWheelConstraint::InputSetMinSuspensionOffset": { + "text": "Handles the `SetMinSuspensionOffset` entity-IO input on `CPhysWheelConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysWheelConstraint::InputSetSteeringMimicsEntity": { + "text": "Handles the `SetSteeringMimicsEntity` entity-IO input on `CPhysWheelConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsGameSystem::FrameBoundary": { + "text": "Marks a per-frame boundary for the physics game system, a point at which accumulated simulation state can be flushed or rolled over. Class attribution and behaviour are implied by the name and the slot is unbound in this data, so the work done at the boundary is unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::GameActivate": { + "text": "Brings the physics game system into its active, simulating state for the current session or level. Class attribution and behaviour are implied by the name, and the slot is unbound here, so what activation allocates or enables is unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::GameDeactivate": { + "text": "Takes the physics game system out of its active state, quiescing or tearing down simulation for the current session. Class attribution and behaviour are implied by the name, and the slot is unbound, so what is released versus retained is unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::GameInit": { + "text": "One-time startup of the physics game system, standing up the simulation world and its supporting state. Class attribution and behaviour are implied by the name, and the slot is unbound in this data, so what it constructs is unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::GameShutdown": { + "text": "Shuts the physics game system down, releasing the simulation world and the resources it holds. Class attribution and behaviour are implied by the name, and the slot is unbound here, so the exact teardown is unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::PostSpawnGroupUnload": { + "text": "Clears physics state belonging to a spawn group that has been unloaded, so bodies and collision data from streamed-out content do not linger. Class attribution and behaviour are implied by the name, and the slot is unbound, so the exact cleanup is unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::PreSpawnGroupLoad": { + "text": "Prepares the physics game system for a spawn group about to be loaded, staging or reserving state for the incoming content. Class attribution and behaviour are implied by the name, and the slot is unbound in this data, so what it prepares is unverified.", + "source": "generated" + }, + "CPhysicsGameSystem::PullKinematicTransformsWorker": { + "text": "Gathers current transforms for kinematic, animation-driven physics bodies, the worker-task form of that collection step. Read from the name and its resolution in libserver; no prototype is derived, so the data pulled and the threading arrangement are unverified.", + "source": "generated" + }, + "CPhysicsProp::InputDisableCollisions": { + "text": "Handles the `DisableCollisions` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputDisableDrag": { + "text": "Handles the `DisableDrag` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputDisableGravity": { + "text": "Handles the `DisableGravity` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputDisableMotion": { + "text": "Handles the `DisableMotion` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputEnableCollisions": { + "text": "Handles the `EnableCollisions` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputEnableDrag": { + "text": "Handles the `SetDragEnabled` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputEnableGravity": { + "text": "Handles the `SetGravityEnabled` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputEnableMotion": { + "text": "Handles the `EnableMotion` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSetAutoConvertBackFromDebris": { + "text": "Handles the `SetAutoConvertBackFromDebris` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSetGlowOverride": { + "text": "Handles the `SetGlowOverride` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSetGlowRange": { + "text": "Handles the `SetGlowRange` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSetMass": { + "text": "Handles the `SetMass` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputSleep": { + "text": "Handles the `Sleep` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputStartGlowing": { + "text": "Handles the `StartGlowing` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputStopGlowing": { + "text": "Handles the `StopGlowing` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsProp::InputWake": { + "text": "Handles the `Wake` entity-IO input on `CPhysicsProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputAddRestLength": { + "text": "Handles the `AddRestLength` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputRemoveRestLength": { + "text": "Handles the `RemoveRestLength` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputSetDampingRatio": { + "text": "Handles the `SetDampingRatio` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputSetFrequency": { + "text": "Handles the `SetFrequency` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPhysicsSpring::InputSetRestLength": { + "text": "Handles the `SetRestLength` entity-IO input on `CPhysicsSpring`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlatformFont::GetCharABCWidths": { + "text": "Retrieves a character's A, B and C spacing widths from the platform font: left bearing, glyph width and right bearing, the metrics text layout needs. Class attribution and behaviour are implied by the name, and the slot is unbound, so metric units and fallbacks are unverified.", + "source": "generated" + }, + "CPlatformFont::GetKernedCharWidth": { + "text": "Reports a character's advance width with kerning applied against its neighbour, for layout that honours kern pairs instead of raw advances. Class attribution and behaviour are implied by the name, and the slot is unbound here, so the kerning source is unverified.", + "source": "generated" + }, + "CPlatformFont::~CPlatformFont": { + "text": "Destroys the platform font object, releasing the underlying OS font resource and any cached metrics. Class attribution is implied by the name, and the slot is unbound in this data, so exactly what is freed is unverified.", + "source": "generated" + }, + "CPlayerVisibility::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPlayerVisibility`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlayerVisibility::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPlayerVisibility`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlayerVisibility::InputSetPlayerFogDistanceMultiplier": { + "text": "Handles the `SetPlayerFogDistanceMultiplier` entity-IO input on `CPlayerVisibility`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlayerVisibility::InputSetPlayerFogMaxDensityMultiplier": { + "text": "Handles the `SetPlayerFogMaxDensityMultiplier` entity-IO input on `CPlayerVisibility`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPlayerVisibility::InputSetPlayerVisibilityStrength": { + "text": "Handles the `SetPlayerVisibilityStrength` entity-IO input on `CPlayerVisibility`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointAngularVelocitySensor::InputTest": { + "text": "Handles the `Test` entity-IO input on `CPointAngularVelocitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointAngularVelocitySensor::InputTestWithInterval": { + "text": "Handles the `TestWithInterval` entity-IO input on `CPointAngularVelocitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputChangeFOV": { + "text": "Handles the `ChangeFOV` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputDisableDOF": { + "text": "Handles the `DisableDOF` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputEnableDOF": { + "text": "Handles the `EnableDOF` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputForceActive": { + "text": "Handles the `Activate` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputForceInactive": { + "text": "Handles the `Deactivate` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFFarBlurry": { + "text": "Handles the `SetDOFFarBlurry` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFFarCrisp": { + "text": "Handles the `SetDOFFarCrisp` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFNearBlurry": { + "text": "Handles the `SetDOFNearBlurry` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFNearCrisp": { + "text": "Handles the `SetDOFNearCrisp` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetDOFTiltToGround": { + "text": "Handles the `SetDOFTiltToGround` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetOff": { + "text": "Handles the `SetOff` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetOn": { + "text": "Handles the `SetOn` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCamera::InputSetOnAndTurnOthersOff": { + "text": "Handles the `SetOnAndTurnOthersOff` entity-IO input on `CPointCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldPanel::InputAcceptUserInput": { + "text": "Handles the `AcceptUserInput` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldPanel::InputAddCSSClass": { + "text": "Handles the `AddCSSClass` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldPanel::InputIgnoreUserInput": { + "text": "Handles the `IgnoreUserInput` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldPanel::InputLocalPlayerAddCSSClass": { + "text": "Handles the `LocalPlayerAddCSSClass` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldPanel::InputLocalPlayerRemoveCSSClass": { + "text": "Handles the `LocalPlayerRemoveCSSClass` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldPanel::InputRemoveCSSClass": { + "text": "Handles the `RemoveCSSClass` entity-IO input on `CPointClientUIWorldPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldTextPanel::InputSetIntMessage": { + "text": "Handles the `SetIntMessage` entity-IO input on `CPointClientUIWorldTextPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldTextPanel::InputSetMessage": { + "text": "Handles the `SetMessage` entity-IO input on `CPointClientUIWorldTextPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointClientUIWorldTextPanel::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPointClientUIWorldTextPanel`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCommentaryNode::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointCommentaryNode`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCommentaryNode::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointCommentaryNode`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCommentaryNode::InputStartCommentary": { + "text": "Handles the `StartCommentary` entity-IO input on `CPointCommentaryNode`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointCommentaryNode::InputStartUnstoppableCommentary": { + "text": "Handles the `StartUnstoppableCommentary` entity-IO input on `CPointCommentaryNode`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointEntityFinder::InputFindEntity": { + "text": "Handles the `FindEntity` entity-IO input on `CPointEntityFinder`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointOrient::InputSetActive": { + "text": "Handles the `SetActive` entity-IO input on `CPointOrient`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointOrient::InputSetTarget": { + "text": "Handles the `SetTarget` entity-IO input on `CPointOrient`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointPush::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointPush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointPush::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointPush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointVelocitySensor::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointVelocitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointVelocitySensor::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointVelocitySensor`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputSetIntMessage": { + "text": "Handles the `SetIntMessage` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputSetMessage": { + "text": "Handles the `SetMessage` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputSetTextColor": { + "text": "Handles the `SetTextColor` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CPointWorldText::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CPointWorldText`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CProceduralGeometry::OnBeginSubmitDisplayLists": { + "text": "Handles the beginning of display-list submission for procedurally generated geometry, where such geometry readies its draw data for the frame. Read from the name and its resolution in libscenesystem; confidence is low and no prototype is derived, so the actual work is unverified.", + "source": "generated" + }, + "CQueuedTextRenderable::GetCopy": { + "text": "Produces a copy of a queued text renderable, so the queued draw item can be duplicated or outlive the original. Class attribution and behaviour are implied by the name, and the slot is unbound, so copy depth and ownership are unverified.", + "source": "generated" + }, + "CQueuedTextRenderable::Render": { + "text": "Draws the queued text item, emitting its glyphs through the renderer. Class attribution and behaviour are implied by the name, and the slot is unbound in this data, so the target surface and render state it uses are unverified.", + "source": "generated" + }, + "CQueuedTextRenderable::~CQueuedTextRenderable": { + "text": "Destroys a queued text renderable, freeing its string and any glyph or layout data. Class attribution is implied by the name, and the slot is unbound here, so the exact resources released are unverified.", + "source": "generated" + }, + "CRConClient::OnSocketAccepted": { + "text": "Handles a newly accepted RCON client socket, taking up the connection for subsequent command traffic. Class attribution and behaviour are implied by the name, and the slot is unbound in this data, so the connection state it establishes is unverified.", + "source": "generated" + }, + "CRConClient::OnSocketClosed": { + "text": "Handles closure of the RCON client socket, dropping the per-connection state held for it. Class attribution and behaviour are implied by the name, and the slot is unbound, so cleanup detail and any reconnect behaviour are unverified.", + "source": "generated" + }, + "CRConClient::ShouldAcceptSocket": { + "text": "Decides whether an incoming socket is admitted on the RCON client side, a gate for filtering connections. Class attribution and behaviour are implied by the name, and the slot is unbound in this data, so the criteria applied are unverified.", + "source": "generated" + }, + "CRConServer::OnSocketAccepted": { + "text": "Handles an accepted RCON connection on the server, registering the peer so authentication and command traffic can proceed. Class attribution and behaviour are implied by the name, and the slot is unbound here, so the per-peer state recorded is unverified.", + "source": "generated" + }, + "CRConServer::OnSocketClosed": { + "text": "Handles an RCON peer disconnecting, releasing the server-side state kept for that connection. Class attribution and behaviour are implied by the name, and the slot is unbound in this data, so cleanup detail and any session invalidation are unverified.", + "source": "generated" + }, + "CRConServer::ShouldAcceptSocket": { + "text": "Gates whether the RCON server admits an incoming connection, the natural hook for address filtering or connection limits. Class attribution and behaviour are implied by the name, and the slot is unbound, so the admission criteria are unverified.", + "source": "generated" + }, + "CRagdollMagnet::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CRagdollMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollMagnet::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CRagdollMagnet`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollManager::InputSetMaxRagdollCount": { + "text": "Handles the `SetMaxRagdollCount` entity-IO input on `CRagdollManager`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InputDisableMotion": { + "text": "Handles the `DisableMotion` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InputEnableMotion": { + "text": "Handles the `EnableMotion` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InputFadeAndRemove": { + "text": "Handles the `FadeAndRemove` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InputTurnOff": { + "text": "Handles the `Disable` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRagdollProp::InputTurnOn": { + "text": "Handles the `Enable` entity-IO input on `CRagdollProp`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRefreshRateGetter::OnDeviceCreated": { + "text": "Picks up the display refresh rate once a render device exists, giving this getter a current value to report. Class attribution and behaviour are implied by the name, and the slot is unbound in this data, so what it queries and caches is unverified.", + "source": "generated" + }, + "CRefreshRateGetter::OnDeviceLost": { + "text": "Handles loss of the render device, dropping the refresh-rate reading that is no longer valid. Class attribution and behaviour are implied by the name, and the slot is unbound here, so what it clears is unverified.", + "source": "generated" + }, + "CRefreshRateGetter::OnDeviceRestored": { + "text": "Re-establishes the refresh-rate reading once a lost render device comes back. Class attribution and behaviour are implied by the name, and the slot is unbound in this data, so whether it re-queries the display or restores a cached value is unverified.", + "source": "generated" + }, + "CRefreshRateGetter::OnModeChanged": { + "text": "Refreshes the tracked rate after a display mode change such as a resolution or fullscreen switch. Class attribution and behaviour are implied by the name, and the slot is unbound, so what it re-reads is unverified.", + "source": "generated" + }, + "CRenderDeviceBase::CreateConstantBufferInternal": { + "text": "Creates a GPU constant buffer on the base render device, the internal rather than public form of that allocation. Read from the name; it resolves in librendersystemempty, whose name suggests a null backend, and no prototype is derived, so the concrete allocation behaviour is unverified.", + "source": "generated" + }, + "CRenderDeviceBase::FindOrCreateTexture": { + "text": "Looks up an existing texture and creates one when no match is found, so callers share an instance instead of allocating duplicates. Class attribution and behaviour are implied by the name, and the slot is unbound in this data, so the lookup key and caching rules are unverified.", + "source": "generated" + }, + "CRenderUtils::BeginOcclusionQueryDrawing": { + "text": "Opens an occlusion-query drawing scope, the begin half of submitting the proxy geometry whose visible pixels a query measures. Read from the name; the CRenderUtils class is implied by the name, and which query object the scope applies to is unverified.", + "source": "generated" + }, + "CRenderUtils::Connect": { + "text": "Connects the render-utilities system to the engine's interface factory so it can resolve the other systems it needs, the standard connect step of a Source-2 app-system lifecycle. Read from the name; the CRenderUtils class is implied by the name and the connection details are unverified.", + "source": "generated" + }, + "CRenderUtils::CreateOcclusionQueryObject": { + "text": "Creates an occlusion query object that a caller can later use to measure pixel visibility. Read from the name; the CRenderUtils class is implied by the name, and the object's lifetime rules are unverified.", + "source": "generated" + }, + "CRenderUtils::DestroyOcclusionQueryObject": { + "text": "Destroys a previously created occlusion query object and releases the resources behind it. Read from the name; the CRenderUtils class is implied by the name, so the exact teardown behaviour is unverified.", + "source": "generated" + }, + "CRenderUtils::Disconnect": { + "text": "Drops the interface references the render-utilities system acquired during connection, the disconnect step of the app-system lifecycle. Read from the name; the CRenderUtils class is implied by the name and the exact state cleared is unverified.", + "source": "generated" + }, + "CRenderUtils::EndOcclusionQueryDrawing": { + "text": "Closes the occlusion-query drawing scope, ending submission of the geometry a query measures. Read from the name; the CRenderUtils class is implied by the name, and pairing rules with the begin side are unverified.", + "source": "generated" + }, + "CRenderUtils::GetBuildType": { + "text": "Reports the build flavour of the render-utilities module, the app-system query modders use to distinguish debug from release components. Read from the name; the CRenderUtils class is implied by the name and the encoding of the value is unverified.", + "source": "generated" + }, + "CRenderUtils::GetDependencies": { + "text": "Reports the set of systems the render-utilities module requires, used by the app-system framework to bring dependencies up. Read from the name; the CRenderUtils class is implied by the name, and the descriptor format is unverified.", + "source": "generated" + }, + "CRenderUtils::GetTier": { + "text": "Reports which engine tier the render-utilities module belongs to, the classification the app-system framework uses when ordering systems. Read from the name; the CRenderUtils class is implied by the name and the tier encoding is unverified.", + "source": "generated" + }, + "CRenderUtils::Init": { + "text": "Purpose is not established beyond generic initialisation of the render-utilities system. The CRenderUtils class is implied by the name, not by the data.", + "source": "generated" + }, + "CRenderUtils::IsSingleton": { + "text": "Indicates whether the render-utilities system is a single shared instance rather than one instantiated per caller. Read from the name; the CRenderUtils class is implied by the name and the meaning of the result is unverified.", + "source": "generated" + }, + "CRenderUtils::OcclusionQuery_GetNumPixelsRendered": { + "text": "Retrieves the pixel count an occlusion query recorded, the visibility figure that drives conditional rendering and visibility tests. Read from the name; the CRenderUtils class is implied by the name, and whether the result is ready or stalls is unverified.", + "source": "generated" + }, + "CRenderUtils::PreShutdown": { + "text": "Handles the pre-shutdown stage of the render-utilities lifecycle, where a system releases work it holds while other systems are still alive. Read from the name; the CRenderUtils class is implied by the name and the specific work released is unverified.", + "source": "generated" + }, + "CRenderUtils::QueryInterface": { + "text": "Hands back an interface the render-utilities module exposes, the app-system lookup used to reach a named capability on the system. Read from the name; the CRenderUtils class is implied by the name, and the naming convention it accepts is unverified.", + "source": "generated" + }, + "CRenderUtils::Reconnect": { + "text": "Re-resolves one interface the render-utilities system holds, used when a dependency is replaced without a full lifecycle restart. Read from the name; the CRenderUtils class is implied by the name and the rebinding details are unverified.", + "source": "generated" + }, + "CRenderUtils::ResetOcclusionQueryObject": { + "text": "Resets an occlusion query object back to an unused state so it can be reissued without being recreated. Read from the name; the CRenderUtils class is implied by the name, and what the reset discards is unverified.", + "source": "generated" + }, + "CRenderUtils::Shutdown": { + "text": "Tears down the render-utilities system, the final lifecycle stage that releases whatever it allocated. Read from the name; the CRenderUtils class is implied by the name, so the exact teardown work is unverified.", + "source": "generated" + }, + "CRenderingWorldSession::OnFrameBoundary": { + "text": "Notifies the rendering world session that a frame boundary has been reached, the hook where per-frame session state is rolled over. Read from the name; the CRenderingWorldSession class is implied by the name and the state it touches is unverified.", + "source": "generated" + }, + "CRenderingWorldSession::Unlock": { + "text": "Releases a lock held on the rendering world session, freeing access that was taken for exclusive or synchronised use of session data. Read from the name; the CRenderingWorldSession class is implied by the name, and what the lock protects is unverified.", + "source": "generated" + }, + "CResourceFile::CreateForFileRead": { + "text": "Constructs a resource-file object configured for reading an existing file, the entry modders would use to open a compiled resource rather than author one. Read from the name and its presence in libresourcesystem; the file handling and failure behaviour are unverified.", + "source": "generated" + }, + "CResourceManifest::GetNamedManifestResources": { + "text": "Retrieves the named resource entries recorded in a manifest, useful when enumerating what a manifest pulls in by name. Read from the name and its presence in libresourcesystem; the container returned and whether names are paths are unverified.", + "source": "generated" + }, + "CResourceStreamFixed::Commit": { + "text": "Commits the contents of a fixed-size resource stream, finalising the data written into its buffer. Read from the name; the CResourceStreamFixed class is implied by the name, and what commit makes visible is unverified.", + "source": "generated" + }, + "CResourceStreamFixed::~CResourceStreamFixed": { + "text": "Destroys a fixed-size resource stream, releasing the buffer and bookkeeping it owns. Read from the name; the CResourceStreamFixed class is implied by the name, so whether uncommitted data survives destruction is unverified.", + "source": "generated" + }, + "CResourceSystem::BlockUntilManifestLoaded": { + "text": "Stalls the caller until a resource manifest has finished loading, the synchronisation point for code that must not run against half-loaded assets. Read from the name; the CResourceSystem class is implied by the name and the wait semantics are unverified.", + "source": "generated" + }, + "CResourceSystem::FindOrCreateProceduralResource": { + "text": "Looks up a procedurally generated resource and creates it if it does not yet exist, the path for assets built at runtime instead of loaded from disk. Read from the name; the CResourceSystem class is implied by the name, and the creation inputs are unverified.", + "source": "generated" + }, + "CResourceSystem::FindOrRegisterResourceByName_Internal": { + "text": "Resolves a resource by name and registers a new entry when none is found, the internal name-to-resource lookup behind higher-level resource handles. Read from the name; the CResourceSystem class is implied by the name and the name format is unverified.", + "source": "generated" + }, + "CResourceSystem::FrameUpdate": { + "text": "Performs the resource system's per-frame servicing, the tick where pending resource work is progressed. Read from the name and its presence in libresourcesystem; what it advances each frame is unverified.", + "source": "generated" + }, + "CResourceSystem::Init": { + "text": "Purpose is not established beyond generic initialisation of the resource system. The CResourceSystem class is implied by the name, not by the data.", + "source": "generated" + }, + "CResourceSystem::InstallResourceTypeManager": { + "text": "Registers a type manager with the resource system so a particular resource type can be loaded and handled, the hook a new asset type would need. Read from the name; the CResourceSystem class is implied by the name and the registration details are unverified.", + "source": "generated" + }, + "CResourceSystem::PreShutdown": { + "text": "Handles the resource system's pre-shutdown stage, where held resources are released while dependent systems are still available. Read from the name; the CResourceSystem class is implied by the name and the specific work done is unverified.", + "source": "generated" + }, + "CResourceSystem::Shutdown": { + "text": "Tears down the resource system, releasing the resources and managers it holds. Read from the name; the CResourceSystem class is implied by the name, so the exact teardown work is unverified.", + "source": "generated" + }, + "CResourceSystem::Update_Internal": { + "text": "Runs the resource system's internal update pass, progressing whatever asynchronous or pending resource work it tracks. Read from the name and its presence in libresourcesystem; the work it advances is unverified.", + "source": "generated" + }, + "CResourceSystemImp::InstallTypeManager": { + "text": "Registers a resource type manager on the concrete resource-system implementation, the implementation-side counterpart of type registration. Read from the name and its presence in libresourcesystem; the registration inputs and replacement behaviour are unverified.", + "source": "generated" + }, + "CResponseSystem::LoadResponseSystem": { + "text": "Loads the response system's data, the rule and criteria set that drives scripted character responses. Read from the name and its presence in libscenefilecache; the file format and source location are unverified.", + "source": "generated" + }, + "CRevertSaved::InputReload": { + "text": "Handles the `Reload` entity-IO input on `CRevertSaved`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRopeKeyframe::InputBreak": { + "text": "Handles the `Break` entity-IO input on `CRopeKeyframe`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRopeKeyframe::InputSetForce": { + "text": "Handles the `SetForce` entity-IO input on `CRopeKeyframe`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRopeKeyframe::InputSetScrollSpeed": { + "text": "Handles the `SetScrollSpeed` entity-IO input on `CRopeKeyframe`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CRopeManager::PostRopeAsyncJobs": { + "text": "Posts the rope manager's asynchronous work items so rope simulation can proceed off the calling thread. Read from the name and its home in libvphysics2; no prototype is derived, so the job contents and the conditions under which they are posted are unverified.", + "source": "generated" + }, + "CSceneEntity::InputCancelAtNextInterrupt": { + "text": "Handles the `CancelAtNextInterrupt` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputCancelPlayback": { + "text": "Handles the `Cancel` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputInterjectResponse": { + "text": "Handles the `InterjectResponse` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputPauseAtNextInterrupt": { + "text": "Handles the `PauseAtNextInterrupt` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputPausePlayback": { + "text": "Handles the `Pause` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputPitchShiftPlayback": { + "text": "Handles the `PitchShift` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputResumePlayback": { + "text": "Handles the `Resume` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputScriptPlayerDeath": { + "text": "Handles the `ScriptPlayerDeath` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputSetTarget2": { + "text": "Handles the `SetTarget2` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputStartPlayback": { + "text": "Handles the `Start` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneEntity::InputStopWaitingForActor": { + "text": "Handles the `StopWaitingForActor` entity-IO input on `CSceneEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneListManager::InputShutdown": { + "text": "Handles the `Shutdown` entity-IO input on `CSceneListManager`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSceneSystem::Begin": { + "text": "Opens a scene-system frame or pass, putting the system into its active state for subsequent scene work. Read from the name, and the class is implied by the name rather than the data, so what the interval covers is unverified.", + "source": "generated" + }, + "CSceneSystem::FinishRenderingViews": { + "text": "Completes the scene system's per-view rendering work for the frame, settling the views it has been accumulating. Read from the name, and the class is implied by the name, so which views are involved and what completion entails are unverified.", + "source": "generated" + }, + "CSceneSystem::FrameUpdate": { + "text": "Advances the scene system by one frame, refreshing its per-frame state. Read from the name, and the class is implied by the name, so the scope of the update and what drives it are unverified.", + "source": "generated" + }, + "CSceneSystem::WaitForRenderingToComplete": { + "text": "Blocks until outstanding scene rendering work has finished, giving a synchronisation point for code that must not touch scene data while a render is in flight. Read from the name, and the class is implied by the name, so exactly which work is awaited is unverified.", + "source": "generated" + }, + "CSchemaSystem::ConvertOldIntrospectedResourceDataToKV3": { + "text": "Converts legacy introspected resource data into KV3 form, a migration path for older serialized payloads that predate the current representation. Read from the name, and the class is implied by the name, so the legacy formats accepted and the shape of the KV3 output are unverified.", + "source": "generated" + }, + "CSchemaSystem::VerifySchemaBindingConsistency": { + "text": "Checks registered schema bindings for consistency, which is what surfaces a mismatch when a mod or plugin registers its own types against a build whose schema has moved. Read from the name, and the class is implied by the name, so the specific checks and the failure behaviour are unverified.", + "source": "generated" + }, + "CSchemaSystemTypeScope::InsertNewClassBinding": { + "text": "Registers a new class binding inside a schema type scope, adding that class to the scope's introspection tables. Read from the name and its home in libschemasystem; no prototype is derived, so the binding payload and how duplicates are treated are unverified.", + "source": "generated" + }, + "CSchemaSystemTypeScope::InsertNewEnumBinding": { + "text": "Registers a new enum binding inside a schema type scope, adding that enumeration to the scope's introspection tables. Read from the name and its home in libschemasystem; no prototype is derived, so the binding payload and duplicate handling are unverified.", + "source": "generated" + }, + "CSchemaSystemTypeScope::PromoteUnresolvedAndGlobalTypes": { + "text": "Promotes a scope's unresolved and global type entries, turning pending or scope-external type references into resolved entries. Read from the name and its home in libschemasystem; no prototype is derived, so what promotion actually rewrites is unverified.", + "source": "generated" + }, + "CSchemaSystemTypeScope::RemoveFakeFields": { + "text": "Strips synthetic placeholder fields from a schema type scope so only genuinely declared members remain, which matters when reading field layouts programmatically. Read from the name and its home in libnetworksystem; no prototype is derived, so the criteria for a fake field are unverified.", + "source": "generated" + }, + "CScriptManager::Connect": { + "text": "Connects the script manager to the engine systems it depends on during startup. Read from the name, and the class is implied by the name, so what it acquires and retains is unverified.", + "source": "generated" + }, + "CScriptManager::CreateVM": { + "text": "Creates a scripting virtual machine instance for scripts to execute in, the handle a modder needs before running any script code. Read from the name, and the class is implied by the name, so the VM flavour and configuration options are unverified.", + "source": "generated" + }, + "CScriptManager::DestroyVM": { + "text": "Destroys a scripting virtual machine created by the manager and releases what it held. Read from the name, and the class is implied by the name, so the teardown guarantees and any reuse semantics are unverified.", + "source": "generated" + }, + "CScriptManager::Disconnect": { + "text": "Releases the script manager's connections to the engine systems it acquired at startup. Read from the name, and the class is implied by the name, so what specifically is dropped is unverified.", + "source": "generated" + }, + "CScriptManager::GetBuildType": { + "text": "Reports the build type the script manager is operating as. Read from the name, and the class is implied by the name, so the returned value's encoding and meaning are unverified.", + "source": "generated" + }, + "CScriptManager::GetDebugger": { + "text": "Hands back the script debugger the manager owns, the entry point for attaching debugging to running scripts. Read from the name, and the class is implied by the name, so what the debugger object exposes is unverified.", + "source": "generated" + }, + "CScriptManager::GetDependencies": { + "text": "Reports the other engine systems the script manager declares a dependency on. Read from the name, and the class is implied by the name, so the form of that dependency list is unverified.", + "source": "generated" + }, + "CScriptManager::GetTier": { + "text": "Reports the initialisation tier the script manager belongs to. Read from the name, and the class is implied by the name, so the tier value's meaning is unverified.", + "source": "generated" + }, + "CScriptManager::Init": { + "text": "Initialises the script manager; beyond that the purpose is not established by this data. The class is implied by the name.", + "source": "generated" + }, + "CScriptManager::IsSingleton": { + "text": "Reports whether the script manager is a singleton system, i.e. whether one shared instance is expected rather than several. Read from the name, and the class is implied by the name, so the exact condition being reported is unverified.", + "source": "generated" + }, + "CScriptManager::PreShutdown": { + "text": "Runs the script manager's pre-shutdown pass, its chance to release script state while the rest of the engine is still up. Read from the name, and the class is implied by the name, so what is torn down at this stage is unverified.", + "source": "generated" + }, + "CScriptManager::QueryInterface": { + "text": "Looks up an interface the script manager exposes, by identifier. Read from the name, and the class is implied by the name, so the accepted identifiers and lookup failure behaviour are unverified.", + "source": "generated" + }, + "CScriptManager::Reconnect": { + "text": "Re-establishes the script manager's connections to engine systems, the path taken when a dependency is replaced or reloaded. Read from the name, and the class is implied by the name, so the re-acquisition rules are unverified.", + "source": "generated" + }, + "CScriptManager::Shutdown": { + "text": "Shuts the script manager down and releases the state it holds. Read from the name, and the class is implied by the name, so what is torn down is unverified.", + "source": "generated" + }, + "CScriptedSequence::InputBeginSequence": { + "text": "Handles the `BeginSequence` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CScriptedSequence::InputCancelSequence": { + "text": "Handles the `CancelSequence` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CScriptedSequence::InputForceTarget": { + "text": "Handles the `ForceTarget` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CScriptedSequence::InputMoveToPosition": { + "text": "Handles the `MoveToPosition` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CScriptedSequence::InputScriptPlayerDeath": { + "text": "Handles the `ScriptPlayerDeath` entity-IO input on `CScriptedSequence`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSequentialPrerequisite::OnStatusFinished": { + "text": "Handles a completion notification for a sequential prerequisite, marking that step as finished so the sequence can account for it. Read from the name, and the class is implied by the name, so the status values and their effect are unverified.", + "source": "generated" + }, + "CServerSideClient::ActivatePlayer": { + "text": "Activates the player belonging to a server-side client, the step that takes a client from connected to actually playing. Read from the name, and the class is implied by the name, so the preconditions and the state it flips are unverified.", + "source": "generated" + }, + "CServerSideClientBase::Connect": { + "text": "Handles a client connecting on the base server-side client object, establishing that client's server-side session. Read from the name and its home in libengine2; no prototype is derived, so the connection data consumed and the rejection paths are unverified.", + "source": "generated" + }, + "CShaderCreateCallbacks::OnCreateBlendState": { + "text": "Callback invoked on creation of a blend state object, a hook point for observing or adjusting blend state setup. Read from the name, and the class is implied by the name, so the state description supplied to it is unverified.", + "source": "generated" + }, + "CShaderCreateCallbacks::OnCreateDepthStencilState": { + "text": "Callback invoked on creation of a depth-stencil state object, a hook point for observing or adjusting depth and stencil configuration. Read from the name, and the class is implied by the name, so the state description supplied to it is unverified.", + "source": "generated" + }, + "CShaderCreateCallbacks::OnCreateRasterizerState": { + "text": "Callback invoked on creation of a rasterizer state object, a hook point for observing or adjusting rasterizer configuration such as cull and fill setup. Read from the name, and the class is implied by the name, so the state description supplied to it is unverified.", + "source": "generated" + }, + "CShaderCreateCallbacks::OnCreateShader": { + "text": "Callback invoked on shader creation, the interception point for code that wants to see or influence shaders as they are made. Read from the name, and the class is implied by the name, so what is handed to it about the shader is unverified.", + "source": "generated" + }, + "CShaderCreateCallbacks::~CShaderCreateCallbacks": { + "text": "Destructor for the shader-creation callback object, releasing what that callback holder owns when it goes away. Its role is structural rather than behavioural, and the class is implied by the name.", + "source": "generated" + }, + "CSkyCamera::InputActivateSkybox": { + "text": "Handles the `ActivateSkybox` entity-IO input on `CSkyCamera`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSosEventInfoWithFieldData_t::~CSosEventInfoWithFieldData_t": { + "text": "Destructor for an event-info record that carries attached field data, freeing that record and its payload. Its role is structural rather than behavioural, and the class is implied by the name.", + "source": "generated" + }, + "CSosGroupStack::AddStackKV3": { + "text": "Adds an operator stack to a sound-operator-system group from a KV3 block, the format soundevent scripts are authored in. Read from the name; no prototype is derived and the match confidence is low, so what it accepts and how failures surface are unverified.", + "source": "generated" + }, + "CSosOperatorStack::ImportMembers": { + "text": "Imports member entries into an operator stack so fields defined elsewhere do not have to be re-declared on the stack itself. Read from the name; no prototype is derived, so the source of the imported members and any override rules are unverified.", + "source": "generated" + }, + "CSosOperatorStack::ParseKV": { + "text": "Parses a keyvalues block into an operator stack, building the stack's operators and their parameters from authored script text. Read from the name; no prototype is derived, so the accepted keys and the behaviour on malformed input are unverified.", + "source": "generated" + }, + "CSosSetLibraryStackFieldsInfo_t::~CSosSetLibraryStackFieldsInfo_t": { + "text": "Destroys the descriptor record used for a sound operation that sets library stack fields, releasing whatever that record owns. The class is implied by the name rather than established by the data, so the fields the record carries are unverified.", + "source": "generated" + }, + "CSosSetSoundEventFieldsInfo_t::~CSosSetSoundEventFieldsInfo_t": { + "text": "Destroys the descriptor record used for a sound-event field-set operation, freeing what it holds when the record goes out of scope. The class is implied by the name rather than established by the data, so the record's contents are unverified.", + "source": "generated" + }, + "CSosStartSoundEventQueueInfo_t::~CSosStartSoundEventQueueInfo_t": { + "text": "Destroys the queue-info record that describes starting a sound event through the operator system's queue, releasing anything it owns. The class is implied by the name and not established by the data, so what the record holds is unverified.", + "source": "generated" + }, + "CSoundAreaEntityBase::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CSoundAreaEntityBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundAreaEntityBase::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CSoundAreaEntityBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputPauseSound": { + "text": "Handles the `PauseSound` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputSetSoundName": { + "text": "Handles the `SetSoundEventName` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputSetSourceEntity": { + "text": "Handles the `SetSourceEntity` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputStartSoundOnAllClients": { + "text": "Handles the `StartSound` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputStartSoundOnSingleClient": { + "text": "Handles the `StartSoundOnSingleClient` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputStopSound": { + "text": "Handles the `StopSound` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventEntity::InputUnPauseSound": { + "text": "Handles the `UnPauseSound` entity-IO input on `CSoundEventEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventManager::AddSoundEvent": { + "text": "Registers a sound event with the manager so it can later be found and used. The owning class is implied by the name rather than established by the data, so the identifier and payload it expects are unverified.", + "source": "generated" + }, + "CSoundEventManager::GetSoundEvent": { + "text": "Looks up a sound event previously registered with the manager and yields a handle for it. The class is implied by the name rather than derived from the data, so the lookup key and the miss behaviour are unverified.", + "source": "generated" + }, + "CSoundEventParameter::InputSetEventGuid": { + "text": "Handles the `SetSoundEventGUID` entity-IO input on `CSoundEventParameter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventParameter::InputSetFloatValue": { + "text": "Handles the `SetFloatValue` entity-IO input on `CSoundEventParameter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundEventParameter::InputSetParamName": { + "text": "Handles the `SetParamName` entity-IO input on `CSoundEventParameter`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundModifier::Precache": { + "text": "Precaches the sound assets a sound modifier depends on, so playback later in the map does not stall on a load. Read from the name; no prototype is derived, so exactly which assets are pulled in and when is unverified.", + "source": "generated" + }, + "CSoundOpSystem::ProcessSoundEvent": { + "text": "Runs a sound event through the sound operator system, evaluating its operator stacks to produce the event's runtime behaviour. Read from the name; no prototype is derived and match confidence is low, so the processing performed is unverified.", + "source": "generated" + }, + "CSoundOpvarSetEntity::InputChangeOpvarValue": { + "text": "Handles the `ChangeOpvarValue` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputChangeOpvarValueAndSet": { + "text": "Handles the `ChangeOpvarValueAndSet` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetEventGuid": { + "text": "Handles the `SetSoundEventGUID` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetOperatorName": { + "text": "Handles the `SetOperatorName` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetOpvar": { + "text": "Handles the `SetOpvar` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetOpvarIndex": { + "text": "Handles the `SetOpvarIndex` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetOpvarName": { + "text": "Handles the `SetOpvarName` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetEntity::InputSetStackName": { + "text": "Handles the `SetStackName` entity-IO input on `CSoundOpvarSetEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetEventGuid": { + "text": "Handles the `SetSoundEventGUID` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetOperatorName": { + "text": "Handles the `SetOperatorName` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetOpvarIndex": { + "text": "Handles the `SetOpvarIndex` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetOpvarName": { + "text": "Handles the `SetOpvarName` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetSourceEntity": { + "text": "Handles the `SetSourceEntity` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointBase::InputSetStackName": { + "text": "Handles the `SetStackName` entity-IO input on `CSoundOpvarSetPointBase`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointEntity::InputSetDisabledValue": { + "text": "Handles the `SetDisabledValue` entity-IO input on `CSoundOpvarSetPointEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointEntity::InputSetDistanceMapMax": { + "text": "Handles the `SetDistanceMapMax` entity-IO input on `CSoundOpvarSetPointEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundOpvarSetPointEntity::InputSetDistanceMapMin": { + "text": "Handles the `SetDistanceMapMin` entity-IO input on `CSoundOpvarSetPointEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSoundService::OnFrameBoundary": { + "text": "Handles the per-frame boundary notification for an entity's sound service, the hook where sound state gets its once-per-frame update. The class is implied by the name rather than by the data, so what it updates is unverified.", + "source": "generated" + }, + "CSoundscapeSystem::Init": { + "text": "Initialises the soundscape system; beyond startup initialisation, the name does not establish a purpose.", + "source": "generated" + }, + "CSource1LegacyGameEventGameSystem::CServerSideClient_GameEventLegacyProxy::FireGameEvent": { + "text": "Handles a fired game event for a server-side client through the Source-1 legacy game-event compatibility layer, the path that keeps old-style event listeners working. Read from the name; a prototype is derived, but which events reach it and what it does with them are unverified.", + "source": "generated" + }, + "CSource2GameClients::ClientPutInServer": { + "text": "Puts a connecting client into the server \u2014 the moment the game hands that client its player entity, and a common hook point for per-player setup. The class is implied by the name rather than by the data, so the exact hand-off is unverified.", + "source": "generated" + }, + "CSource2Server::ExecGameTypeCfg": { + "text": "Executes the configuration file tied to the current game type, applying that mode's convar settings. The owning class is implied by the name rather than established by the data, so which file is chosen and under what conditions are unverified.", + "source": "generated" + }, + "CSource2Server::GameFrame": { + "text": "Advances the server's game simulation by one frame, the per-tick server entry point mods most often hook to run their own logic. The class is implied by the name; a prototype is derived, but the work done inside the frame is not described here.", + "source": "generated" + }, + "CSource2Server::GameServerSteamAPIActivated": { + "text": "Signals the server that the Steam game-server API has become available, after which Steam-backed functionality can be used. The class is implied by the name; a prototype is derived, though what the server does on activation is unverified.", + "source": "generated" + }, + "CSource2Server::GameServerSteamAPIDeactivated": { + "text": "Signals the server that the Steam game-server API is no longer available, so Steam-dependent work must stop. The class is implied by the name; a prototype is derived, but the teardown it performs is unverified.", + "source": "generated" + }, + "CSource2Server::GetLevelsFromSaveFile": { + "text": "Retrieves the level names recorded inside a save file, as needed when restoring a saved session. The class is implied by the name and no prototype is derived, so the save format it reads and how results are handed back are unverified.", + "source": "generated" + }, + "CSource2Server::WriteSignonMessages": { + "text": "Writes the signon messages a joining client receives, the initial server state delivered before gameplay starts. The class is implied by the name; a prototype is derived, but the message contents are unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::ActivateSpawnGroup": { + "text": "Activates a loaded spawn group so the world content it owns becomes live. The class is implied by the name and no prototype is derived, so the preconditions for activation are unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::CreateLoadingSpawnGroup": { + "text": "Creates a spawn group in its loading state, the handle used while a map or sub-level's content is streamed in. The class is implied by the name; no prototype is derived, so the descriptor it takes and the handle it yields are unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::ExecuteQueuedSpawnEntityCalls": { + "text": "Carries out entity-spawn calls that were queued instead of performed immediately, flushing pending spawns held by the spawn-group manager. Read from the name; no prototype is derived, so what lands in the queue and when it drains are unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::ReleaseSpawnGroup": { + "text": "Releases a spawn group, dropping the manager's hold on it so its entities and resources can be unloaded. The class is implied by the name; a prototype is derived, but the release semantics are unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::SpawnGroupInit": { + "text": "Initialises a spawn group, establishing the manager's bookkeeping for it before any of its entities exist. The class is implied by the name; a prototype is derived, though the initial state it sets up is unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::SpawnGroupShutdown": { + "text": "Shuts a spawn group down, tearing down the manager-side state kept for that group. The class is implied by the name; a prototype is derived, but what is torn down is unverified.", + "source": "generated" + }, + "CSpawnGroupMgrGameSystem::SpawnGroupSpawnEntities": { + "text": "Spawns the entities belonging to a spawn group, turning its loaded entity data into live world entities. The class is implied by the name; a prototype is derived, but the criteria governing which entities appear are unverified.", + "source": "generated" + }, + "CSplineConstraint::InputDisableLimit": { + "text": "Handles the `DisableLimit` entity-IO input on `CSplineConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSplineConstraint::InputEnableLimit": { + "text": "Handles the `EnableLimit` entity-IO input on `CSplineConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSplineConstraint::InputSetSplineEntity": { + "text": "Handles the `SetSplineEntity` entity-IO input on `CSplineConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSplineConstraint::InputSetTransitionTime": { + "text": "Handles the `SetTransitionTime` entity-IO input on `CSplineConstraint`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSplitScreenService::OnProfileStorageAvailable": { + "text": "Handles the moment a split-screen player's profile storage becomes usable, the point where that user's stored settings can be applied. The class is implied by the name and no prototype is derived, so what it reads or applies is unverified.", + "source": "generated" + }, + "CSprite::InputHideSprite": { + "text": "Handles the `HideSprite` entity-IO input on `CSprite`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSprite::InputShowSprite": { + "text": "Handles the `ShowSprite` entity-IO input on `CSprite`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CSprite::InputToggleSprite": { + "text": "Handles the `ToggleSprite` entity-IO input on `CSprite`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CStdFilesystemFile::FS_GetSectorSize": { + "text": "Reports the sector size of the storage backing a standard filesystem file, the alignment granularity unbuffered or aligned reads must respect. The class is implied by the name and no prototype is derived, so units and fallback behaviour are unverified.", + "source": "generated" + }, + "CStdioFile::FS_fclose": { + "text": "Closes the open stdio stream backing this file object and releases the handle it holds. Read from the name; the CStdioFile owner is implied by the name, so the cleanup it performs beyond closing is unverified.", + "source": "generated" + }, + "CStdioFile::FS_ferror": { + "text": "Reports whether an error flag is set on the underlying stdio stream, letting callers detect a failed read or write instead of trusting the byte count. Read from the name; the CStdioFile owner is implied by the name.", + "source": "generated" + }, + "CStdioFile::FS_fflush": { + "text": "Pushes buffered writes on the stdio stream out to the operating system so the data is not stranded in userspace. Read from the name; the CStdioFile owner is implied by the name, and the exact flush semantics are unverified.", + "source": "generated" + }, + "CStdioFile::FS_fread": { + "text": "Reads bytes out of the stdio stream into a caller-supplied buffer, advancing the stream position. Read from the name; the CStdioFile owner is implied by the name, and short-read and buffering behaviour are unverified.", + "source": "generated" + }, + "CStdioFile::FS_fseek": { + "text": "Moves the stream's read/write position to a requested offset, letting callers jump within a file rather than scan it. Read from the name at medium-high confidence; the CStdioFile owner is implied by the name.", + "source": "generated" + }, + "CStdioFile::FS_ftell": { + "text": "Reports the current read/write position within the stream, the value you save before seeking away and restore afterwards. Read from the name; the CStdioFile owner is implied by the name.", + "source": "generated" + }, + "CStdioFile::FS_fwrite": { + "text": "Writes bytes from a caller-supplied buffer into the stdio stream. Read from the name; the CStdioFile owner is implied by the name, and whether the data reaches disk without a separate flush is unverified.", + "source": "generated" + }, + "CStdioFile::FS_setbufsize": { + "text": "Sets the size of the stdio buffer used for this file, the knob for trading memory against syscall count on bulk I/O. Read from the name; the CStdioFile owner is implied by the name.", + "source": "generated" + }, + "CStdioFile::FS_setmode": { + "text": "Changes the access or translation mode of the already-open stream. Read from the name; the CStdioFile owner is implied by the name, and which modes are accepted is not established.", + "source": "generated" + }, + "CStdioFile::~CStdioFile": { + "text": "Destroys the file object and tears down whatever stream state it still holds. Purpose beyond destruction is not established; the CStdioFile owner is implied by the name.", + "source": "generated" + }, + "CSteam3Client::RunFrame": { + "text": "Advances the engine's client-side Steam integration by one frame, servicing pending Steam work and state changes. Located by signature in libengine2 and read from the name, so the specific callbacks and cadence involved are unverified.", + "source": "generated" + }, + "CTestPulseIO::InputVariantBool": { + "text": "Handles the `VariantBool` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantColor": { + "text": "Handles the `VariantColor` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantFloat": { + "text": "Handles the `VariantFloat` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantInt": { + "text": "Handles the `VariantInt` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantString": { + "text": "Handles the `VariantString` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantVector": { + "text": "Handles the `VariantVector` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTestPulseIO::InputVariantVoid": { + "text": "Handles the `VariantVoid` entity-IO input on `CTestPulseIO`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTextureBasedAnimatable::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CTextureBasedAnimatable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTextureBasedAnimatable::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CTextureBasedAnimatable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTextureBasedAnimatable::InputStart": { + "text": "Handles the `Start` entity-IO input on `CTextureBasedAnimatable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTextureBasedAnimatable::InputStop": { + "text": "Handles the `Stop` entity-IO input on `CTextureBasedAnimatable`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTextureDictionary::BindTextureToFile": { + "text": "Associates a dictionary texture entry with a texture file so the entry resolves to that asset. Read from the name; the CTextureDictionary owner is implied by the name, and whether binding also triggers a load is unverified.", + "source": "generated" + }, + "CTextureDictionary::BindTextureToMaterial": { + "text": "Points a dictionary texture entry at a material so the entry draws using that material's resources. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::BindTextureToTextureHandle": { + "text": "Attaches an existing texture handle to a dictionary entry, the route to use when the pixels come from code rather than a file on disk. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::CreateTexture": { + "text": "Allocates a new entry in the texture dictionary and yields the id used to reference it later. Read from the name; the CTextureDictionary owner is implied by the name, and the initial contents of the entry are unverified.", + "source": "generated" + }, + "CTextureDictionary::DestroyAllTextures": { + "text": "Releases the dictionary's held texture entries in bulk, clearing it for reuse or shutdown. Read from the name; the CTextureDictionary owner is implied by the name, so whether outstanding ids are invalidated immediately is unverified.", + "source": "generated" + }, + "CTextureDictionary::DestroyTexture": { + "text": "Frees one texture entry identified by its dictionary id. Read from the name; the CTextureDictionary owner is implied by the name, and whether shared underlying resources survive is unverified.", + "source": "generated" + }, + "CTextureDictionary::EnsureTextureIsLoaded": { + "text": "Makes a dictionary texture resident, loading it on demand if it is not already in memory, which is what you call before drawing to avoid a missing-texture frame. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::FindTextureIdForTextureFile": { + "text": "Looks up the dictionary id already assigned to a given texture file, letting callers reuse an entry instead of creating a duplicate. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::GetMaterialHandle": { + "text": "Retrieves the material handle associated with a dictionary texture entry, for code that needs the material rather than the texture id. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::GetMaterialSpecificRenderAttributes": { + "text": "Fetches the render attributes belonging to a texture entry's material, the draw parameters a caller needs to reproduce how the engine renders it. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::GetTexCoordOffsetAndScale": { + "text": "Reads back the texture-coordinate offset and scale stored for an entry, the values needed to map UVs onto a packed or atlased texture. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::GetTextureHandle": { + "text": "Returns the underlying texture handle for a dictionary id, for code that needs the raw resource instead of the dictionary-level id. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::GetTextureSize": { + "text": "Reports a dictionary texture's dimensions, useful when laying out or scaling anything drawn from it. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::GetTextureTexCoords": { + "text": "Retrieves the texture-coordinate rectangle recorded for a dictionary entry, which is what a caller needs to sample the correct sub-region of a packed sheet. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::IsValidId": { + "text": "Tests whether a texture id still refers to a live dictionary entry, the guard to run before using an id you have held onto. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::ProcessDeferredResourceLoading": { + "text": "Services texture loads that were queued rather than performed immediately, completing the pending resource work. Read from the name; the CTextureDictionary owner is implied by the name, and what causes a load to be deferred is unverified.", + "source": "generated" + }, + "CTextureDictionary::SetBatchingOptions": { + "text": "Configures how the dictionary batches its texture work, a tuning knob for trading draw-call count against flexibility. Read from the name; the CTextureDictionary owner is implied by the name, and the available options are not established.", + "source": "generated" + }, + "CTextureDictionary::SetSubTextureRGBA": { + "text": "Writes RGBA pixel data into a sub-rectangle of a dictionary texture, the path for partial updates to a dynamic or atlased image. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::SetTexCoordOffsetAndScale": { + "text": "Stores the texture-coordinate offset and scale for an entry so later draws sample the intended region. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CTextureDictionary::SetTextureRGBA": { + "text": "Replaces a dictionary texture's contents with caller-supplied RGBA pixel data, the route for uploading procedurally generated or runtime-composited images. Read from the name; the CTextureDictionary owner is implied by the name.", + "source": "generated" + }, + "CThreadPool::Start": { + "text": "Brings the thread pool up so its workers exist and queued jobs can begin running. Read from the name; the CThreadPool owner is implied by the name, and its exact startup behaviour is unverified.", + "source": "generated" + }, + "CThreadRWLock::Unlock": { + "text": "Releases a held reader/writer lock so other threads can acquire it. Located by signature in libengine2 at low confidence and read from the name, so which of the read and write modes it releases is unverified.", + "source": "generated" + }, + "CTier2AppSystemDict::Init": { + "text": "A generic initialiser, so its specific purpose is not established by the name. The owning CTier2AppSystemDict class is implied by the name rather than recovered from the data, so treat the ownership as unconfirmed.", + "source": "generated" + }, + "CTier2AppSystemDict::LoadStartupManifestGroup": { + "text": "Loads a named group of subsystems and resources listed in the tier2 startup manifest, bringing that group up during application startup. Read from the name, and the CTier2AppSystemDict class is implied by the name; the manifest format and the group identifiers are unverified.", + "source": "generated" + }, + "CTier2Application::LoadStartupManifestGroup": { + "text": "Loads a named startup-manifest group at the tier2 application level, the app-object-facing form of that manifest load. Read from the name, and the CTier2Application class is implied by the name; how it differs from the dictionary-side load is unverified.", + "source": "generated" + }, + "CTimerEntity::InputAddToTimer": { + "text": "Handles the `AddToTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputFireTimer": { + "text": "Handles the `FireTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputPauseTimer": { + "text": "Handles the `PauseTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputRefireTime": { + "text": "Handles the `RefireTime` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputResetTimer": { + "text": "Handles the `ResetTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputSubtractFromTimer": { + "text": "Handles the `SubtractFromTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputToggle": { + "text": "Handles the `Toggle` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTimerEntity::InputUnpauseTimer": { + "text": "Handles the `UnpauseTimer` entity-IO input on `CTimerEntity`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputSetExposureAdaptationSpeedDown": { + "text": "Handles the `SetExposureAdaptationSpeedDown` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputSetExposureAdaptationSpeedUp": { + "text": "Handles the `SetExposureAdaptationSpeedUp` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputSetMaxExposure": { + "text": "Handles the `SetMaxExposure` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTonemapController2::InputSetMinExposure": { + "text": "Handles the `SetMinExposure` entity-IO input on `CTonemapController2`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTraceAABB::GetVertByIndex": { + "text": "Returns one corner vertex of the axis-aligned box used as a trace shape, selected by index. Read from the name, with the CTraceAABB class implied by the name; the corner ordering and the coordinate space are unverified.", + "source": "generated" + }, + "CTraceAABB::Radius": { + "text": "Reports a radius for the axis-aligned box trace shape, the scalar extent used for coarse distance and culling tests against it. Read from the name, and the CTraceAABB class is implied by the name; which radius convention it uses is unverified.", + "source": "generated" + }, + "CTraceAABB::SupportMap": { + "text": "Computes the box's support point in a given direction, the support mapping convex sweep and intersection code needs to sweep an axis-aligned box against other shapes. Read from the name, with the CTraceAABB class implied by the name; the inputs and the result form are unverified.", + "source": "generated" + }, + "CTraceFilterSimple::SetPassEntity": { + "text": "Sets the entity a simple trace filter treats as pass-through, so a ray or hull sweep ignores it instead of reporting a hit. Use it when tracing outward from an entity that must not hit itself; read from the name, with the exact ignore semantics unverified.", + "source": "generated" + }, + "CTraceFilterSkipTwoEntities::SetPassEntity2": { + "text": "Sets the second of the two entities this filter skips, letting one trace ignore both an owner and one further entity. Read from the name; how it interacts with the first pass entity, and whether clearing it is supported, are unverified.", + "source": "generated" + }, + "CTriggerBrush::InputDisable": { + "text": "Handles the `Disable` entity-IO input on `CTriggerBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerBrush::InputEnable": { + "text": "Handles the `Enable` entity-IO input on `CTriggerBrush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerGameEvent::InputSetEndTouchEvent": { + "text": "Handles the `SetEndTouchEvent` entity-IO input on `CTriggerGameEvent`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerGameEvent::InputSetStartTouchEvent": { + "text": "Handles the `SetStartTouchEvent` entity-IO input on `CTriggerGameEvent`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerHurt::InputSetDamage": { + "text": "Handles the `SetDamage` entity-IO input on `CTriggerHurt`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerImpact::InputImpact": { + "text": "Handles the `Impact` entity-IO input on `CTriggerImpact`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerImpact::InputSetMagnitude": { + "text": "Handles the `SetMagnitude` entity-IO input on `CTriggerImpact`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerPhysics::InputSetLinearForcePointAt": { + "text": "Handles the `SetLinearForcePointAt` entity-IO input on `CTriggerPhysics`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerPush::InputSetPushDirection": { + "text": "Handles the `SetPushDirection` entity-IO input on `CTriggerPush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CTriggerPush::InputSetPushSpeed": { + "text": "Handles the `SetPushSpeed` entity-IO input on `CTriggerPush`. Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "CUtlBuffer::EnsureCapacity": { + "text": "Grows a CUtlBuffer's backing storage so it can hold at least a requested amount without reallocating again mid-write. Reach for it before a bulk serialisation write to avoid repeated growth; read from the name, with the growth policy unverified.", + "source": "generated" + }, + "CUtlContiguousMemory::EnsureCapacity": { + "text": "Reserves a contiguous memory block of at least the requested size, reallocating and relocating the existing contents when the current block is too small. Read from the name; whether pointers into the old block survive the grow is unverified.", + "source": "generated" + }, + "CUtlLeanVector::InsertBeforeGetPtr": { + "text": "Opens slots for new CGlobalSymbol entries before a given position in a lean vector and hands back a pointer to the opened space for in-place construction. Read from the name; the index convention and whether the slots arrive constructed are unverified.", + "source": "generated" + }, + "CUtlLeanVectorFixedGrowable::InsertBeforeGetPtr": { + "text": "Opens slots for CGlobalSymbol entries before a given position in a lean vector that starts with inline fixed storage and spills to the heap when outgrown, returning a pointer to the new space. Read from the name; the spill threshold and construction behaviour are unverified.", + "source": "generated" + }, + "CUtlLeanVectorFixedGrowable::InsertBeforeGetPtr": { + "text": "Opens slots for Vector entries before a given position in an inline-storage-first lean vector and returns a pointer to them, the shape used for small point or normal lists in physics code. Read from the name; the growth point and construction behaviour are unverified.", + "source": "generated" + }, + "CUtlLinkedList::GrowCount": { + "text": "Concerns the growth increment a CUtlLinkedList uses when its node pool runs out and must expand. Read from the name; whether it reads the increment, sets it, or performs the growth itself is unverified.", + "source": "generated" + }, + "CUtlMemoryPool::Alloc": { + "text": "Hands out one fixed-size block from a pooled allocator's preallocated chunks, expanding the pool when no free block remains. Use it as the allocation entry point for pooled objects; read from the name, with block sizing and exhaustion behaviour unverified.", + "source": "generated" + }, + "CUtlStackMachineBuilder::FinishCompile": { + "text": "Finalises a stack-machine program being assembled, closing out the builder and yielding the finished instruction stream for execution. Read from the name, and the CUtlStackMachineBuilder class is implied by the name; what the completed program is handed back as is unverified.", + "source": "generated" + }, + "CUtlVector::AddMultipleToTail": { + "text": "Appends several elements at once to the end of a CUtlVector, growing the storage once instead of per element. Read from the name; whether the appended slots are default-constructed or left raw for the caller to fill is unverified.", + "source": "generated" + }, + "CUtlVector::EnsureCapacity": { + "text": "Reserves CUtlVector storage for at least a requested element count without changing the element count itself. Use it ahead of a known-size fill to avoid repeated reallocation; read from the name, with the growth policy unverified.", + "source": "generated" + }, + "CUtlVector::InsertBeforeGetPtr": { + "text": "Opens element slots before a given index in a CUtlVector and returns a pointer to the opened space so the caller can construct in place, avoiding a temporary copy. Read from the name; the index convention and construction state of the slots are unverified.", + "source": "generated" + }, + "CUtlVector::InsertMultipleBefore": { + "text": "Inserts a run of several elements before a given index in a CUtlVector, shifting the trailing elements up to make room. Read from the name; whether the new slots are constructed and how out-of-range indices behave are unverified.", + "source": "generated" + }, + "CUtlVector::RemoveMultiple": { + "text": "Erases a contiguous run of elements from a CUtlVector, closing the gap by moving the trailing elements down. Read from the name; destructor behaviour and which held indices are invalidated are unverified.", + "source": "generated" + }, + "CUtlVector::AddMultipleToTail": { + "text": "Appends several CFieldPath entries at once to a field-path list, the batched-append form used when accumulating sets of network field paths. Read from the name; whether the appended entries arrive initialised is unverified.", + "source": "generated" + }, + "CUtlVector::InsertBeforeGetPtr": { + "text": "Opens slots for CHitBox entries before a given index in a hitbox array and returns a pointer to them for in-place construction, the shape used when building a model's hitbox set. Read from the name; the index convention and slot initialisation are unverified.", + "source": "generated" + }, + "CUtlVector::InsertBeforeGetPtr": { + "text": "Opens slots for CPiecewiseCurve entries before a given index in a curve array and returns a pointer for in-place construction, as used when assembling animation curve lists. Read from the name; the index convention and slot initialisation are unverified.", + "source": "generated" + }, + "CVProfile::CVProfile": { + "text": "Constructs the CVProfile profiler object, standing up the bookkeeping that named profiling scopes accumulate their timings into. Read from the name as a constructor; what it initialises, and whether a global instance is created this way, are unverified.", + "source": "generated" + }, + "CVScriptGameEventListener::FireGameEvent": { + "text": "Handles a fired game event delivered to a script-side listener, the callback an event subscriber implements to receive engine events; the string game_event_listener appears with it. Use it as the hook point for observing or intercepting events reaching script; the payload it reads is unverified.", + "source": "generated" + }, + "CVSoundStackScriptTypeManager::Allocate": { + "text": "Allocates a sound-stack-script instance owned by this type manager, the creation entry point for that asset type. Read from the name, and the CVSoundStackScriptTypeManager class is implied by the name; what the allocated object is initialised from is unverified.", + "source": "generated" + }, + "CVoxelVisibilityTypeManager::AllocateResource": { + "text": "Allocates a voxel-visibility resource \u2014 the baked voxel visibility data for a map \u2014 through its resource type manager. Read from the name, and the CVoxelVisibilityTypeManager class is implied by the name; the backing storage and the resource lifetime are unverified.", + "source": "generated" + }, + "CWorldRendererMgr::CreateWorld": { + "text": "Creates a world instance in the world renderer manager, the runtime object holding a loaded map's world geometry and render data. Read from the name, and the CWorldRendererMgr class is implied by the name; what identifies the world and how it is released are unverified.", + "source": "generated" + }, + "CWorldRendererMgr::LockForRead": { + "text": "Takes a read lock on world-renderer data so it can be inspected while other threads may be working on it. Read from the name, and the CWorldRendererMgr class is implied by the name; the lock's scope, its unlock counterpart, and whether it can block are unverified.", + "source": "generated" + }, + "CanBeSeenByAnyOpposingTeam": { + "text": "Tests whether an entity is currently visible to any team hostile to its own, the vision test behind fog-dependent behaviour. Read from the name; the vision data it consults and its handling of true sight are unverified.", + "source": "generated" + }, + "CanBeUsedOutOfInventory": { + "text": "Reports whether an item may be activated while not sitting in a hero's inventory, such as from stash or courier context. Read from the name; the exact contexts that count as out of inventory are not established.", + "source": "generated" + }, + "CanRepick": { + "text": "Reports whether a player is still permitted to repick their hero, the gate on the repick action during draft. Read from the name; the timing window and cost conditions it checks are unverified.", + "source": "generated" + }, + "CastAbility": { + "text": "Starts a unit casting an ability, turning a cast request into an active cast. Read from the name; the targeting inputs it takes and what validation (range, mana, cooldown, disables) it performs are not established here.", + "source": "generated" + }, + "ClearKillsMatrix": { + "text": "Resets the kills matrix, the per-player-pair table of who killed whom, back to an empty state. Read from the name; the table's owner and the conditions that warrant a reset are unverified.", + "source": "generated" + }, + "ClearLastHitMultikill": { + "text": "Clears the tracked last-hit multikill state, the short-window counter for rapid successive creep last hits. Read from the name; the window length and exactly which fields are zeroed are unverified.", + "source": "generated" + }, + "ClearLastHitStreak": { + "text": "Resets a running last-hit streak counter to zero. Read from the name; what counts as breaking the streak, and where the counter is kept, is not established by this data.", + "source": "generated" + }, + "ClearPlayer": { + "text": "Wipes a player slot's tracked state back to an empty baseline, the reset used when a slot is vacated or reinitialised. Read from the name; which fields it clears and which persist are unverified.", + "source": "generated" + }, + "ClearRawPlayerDamageMatrix": { + "text": "Zeroes the raw player-versus-player damage table, the per-pair accumulation of damage dealt before any post-processing or display filtering. Read from the name; the table's layout and what prompts the reset are not established.", + "source": "generated" + }, + "ClearStreak": { + "text": "Resets a streak counter to zero, the generic streak-clearing operation used when a streak ends. Read from the name; because the bare name carries no class qualifier, which streak it owns is not established here.", + "source": "generated" + }, + "CloseSocket": { + "text": "Closes a network socket, releasing the underlying handle and the state bound to it. Read from the name and its networking home; the socket abstraction involved and whether pending data is flushed are unverified.", + "source": "generated" + }, + "ComputeMaterialBatchableFlags": { + "text": "Computes flags describing how far a material can be batched with others when drawing, the compatibility bits used to merge draw calls. Read from the name and its material-system home; the inputs consulted and the flag layout are unverified.", + "source": "generated" + }, + "ConCommand::autosavedangerousissafe": { + "text": "Callback bound to the `autosavedangerousissafe` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::commentary_cvarsnotchanging": { + "text": "Callback bound to the `commentary_cvarsnotchanging` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::commentary_finishnode": { + "text": "Callback bound to the `commentary_finishnode` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::creditsdone": { + "text": "Callback bound to the `creditsdone` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_animation_run": { + "text": "Callback bound to the `dota_animation_run` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_bot_debug_assign_hero_roles": { + "text": "Callback bound to the `dota_bot_debug_assign_hero_roles` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_call_gg": { + "text": "Callback bound to the `dota_call_gg` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_combatlog_size_server": { + "text": "Callback bound to the `dota_combatlog_size_server` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_combatlog_summary": { + "text": "Callback bound to the `dota_combatlog_summary` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_destroy_player_effigy": { + "text": "Callback bound to the `dota_destroy_player_effigy` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_dump_server_inventory": { + "text": "Callback bound to the `dota_dump_server_inventory` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_gridnav_perf_test": { + "text": "Callback bound to the `dota_gridnav_perf_test` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_hero_muerta_add_supernatural_stack": { + "text": "Callback bound to the `dota_hero_muerta_add_supernatural_stack` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_hero_ringmaster_dark_carnival_souvenir_add_charge": { + "text": "Callback bound to the `dota_hero_ringmaster_dark_carnival_souvenir_add_charge` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_monster_hunter_lock_investigations": { + "text": "Callback bound to the `dota_monster_hunter_lock_investigations` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_monster_hunter_play_hunt_deny_effect": { + "text": "Callback bound to the `dota_monster_hunter_play_hunt_deny_effect` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_monster_hunter_reset_success_state": { + "text": "Callback bound to the `dota_monster_hunter_reset_success_state` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_monster_hunter_send_investigations_to_client": { + "text": "Callback bound to the `dota_monster_hunter_send_investigations_to_client` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_reload_event_schema": { + "text": "Callback bound to the `dota_reload_event_schema` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_send_poogie_fled_message": { + "text": "Callback bound to the `dota_send_poogie_fled_message` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_set_time": { + "text": "Callback bound to the `dota_set_time` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_test_challenge": { + "text": "Callback bound to the `dota_test_challenge` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_test_plus_challenge": { + "text": "Callback bound to the `dota_test_plus_challenge` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::dota_test_teamshowcase": { + "text": "Callback bound to the `dota_test_teamshowcase` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::firetarget": { + "text": "Callback bound to the `firetarget` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::func_mover_count": { + "text": "Callback bound to the `func_mover_count` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::func_mover_enable_debug_all": { + "text": "Callback bound to the `func_mover_enable_debug_all` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::ik_debug_fabrik_backwards_iteration_toggle": { + "text": "Callback bound to the `ik_debug_fabrik_backwards_iteration_toggle` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::ik_debug_fabrik_forwards_iteration_toggle": { + "text": "Callback bound to the `ik_debug_fabrik_forwards_iteration_toggle` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::lightbinner_precompute": { + "text": "Callback bound to the `lightbinner_precompute` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::lightbinner_test_computespheresilhouette": { + "text": "Callback bound to the `lightbinner_test_computespheresilhouette` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::lightbinner_test_computesumsilhouette": { + "text": "Callback bound to the `lightbinner_test_computesumsilhouette` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::lua_report_memory": { + "text": "Callback bound to the `lua_report_memory` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::mem_test": { + "text": "Callback bound to the `mem_test` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::nav_test_level_hull_move": { + "text": "Callback bound to the `nav_test_level_hull_move` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::progress_enable": { + "text": "Callback bound to the `progress_enable` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::save_clear_subdirectory": { + "text": "Callback bound to the `save_clear_subdirectory` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::save_finish_async": { + "text": "Callback bound to the `save_finish_async` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::save_set_subdirectory": { + "text": "Callback bound to the `save_set_subdirectory` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::send_match_metadata": { + "text": "Callback bound to the `send_match_metadata` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::sndplaydelay": { + "text": "Callback bound to the `sndplaydelay` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::splitscreen_testreadconfigconflict": { + "text": "Callback bound to the `splitscreen_testreadconfigconflict` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::stopsound": { + "text": "Callback bound to the `stopsound` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::tutorial_cleanup_post": { + "text": "Callback bound to the `tutorial_cleanup_post` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::tutorial_experience_closed": { + "text": "Callback bound to the `tutorial_experience_closed` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::tutorial_speech_end": { + "text": "Callback bound to the `tutorial_speech_end` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::tutorial_testui": { + "text": "Callback bound to the `tutorial_testui` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConCommand::tutorial_tip_dismissed": { + "text": "Callback bound to the `tutorial_tip_dismissed` console command; the engine invokes it when that command is executed.", + "source": "derived" + }, + "ConnectGameInterfaces": { + "text": "Hands the game module the engine interface pointers it needs, the interface-connection step of module bring-up. Read from the name and its host-library home; which interfaces are exchanged and how failures are reported are not established.", + "source": "generated" + }, + "CreatePendingUnits": { + "text": "Spawns units that were queued for creation, turning a pending-spawn list into live entities. Read from the name; what places units on the queue and how the pending list is stored are unverified.", + "source": "generated" + }, + "CreateVisibilityNode": { + "text": "Allocates a node in the visibility structure, the per-entity or per-region record the vision and fog system queries. Read from the name; the node's contents and the structure it joins are not established by this data.", + "source": "generated" + }, + "DecrementModifierRefCount": { + "text": "Drops a modifier's reference count by one, the release half of the refcounting that keeps a shared modifier alive while stacks or auras still need it. Read from the name; whether hitting zero destroys the modifier is unverified.", + "source": "generated" + }, + "DestroyAllSpeechBubbles": { + "text": "Tears down the currently active speech bubbles in one operation, removing the bubble entities or records behind them. Read from the name; whether the scope is one unit, one player or wider is not established here.", + "source": "generated" + }, + "DetermineFieldSerializerGroup": { + "text": "Decides which serializer group a networked field belongs to, the classification that picks how the field is encoded for the wire. Read from the name and its networking home; the grouping criteria and how a group is represented are unverified.", + "source": "generated" + }, + "EndChannel": { + "text": "Terminates an in-progress channelled ability, ending the channel state and the effects tied to it. Read from the name; whether it distinguishes interruption from a channel that ran to completion is not established.", + "source": "generated" + }, + "Engine_Startup": { + "text": "Brings the engine up, the top-level engine initialisation performed as the process starts. Read from the name and its engine2 home; what subsystems it initialises and what it does on failure are unverified.", + "source": "generated" + }, + "ExecGameTypeCfg": { + "text": "Executes the config file tied to the current game type or mode, applying the convar settings it contains. Read from the name and its engine2 home; how the game type is resolved and which file it picks are unverified.", + "source": "generated" + }, + "ForceSetFrozenCooldown": { + "text": "Forces an ability's cooldown into a frozen state, pinning the remaining time so it stops ticking down. Read from the name; the force prefix suggests it overrides the usual guards, which this data does not confirm.", + "source": "generated" + }, + "GetAbilityCount": { + "text": "Reports how many ability slots an entity carries, the natural bound when walking a hero's abilities by index. Read from the name; no prototype is derived, so the subject entity and whether hidden or innate abilities are counted stay unverified.", + "source": "generated" + }, + "GetAbilityDamageType": { + "text": "Reports the damage-type classification an ability deals, the value to branch on when applying resistances, filtering damage sources, or tagging combat log output. Read from the name; no prototype is derived, so how the type is encoded is unverified.", + "source": "generated" + }, + "GetAbilityIndex": { + "text": "Reports an ability's slot index, the value you feed back into slot-based ability lookups or store to identify an ability compactly. Read from the name; no prototype is derived, so the indexing base and coverage of non-slotted abilities are unverified.", + "source": "generated" + }, + "GetAbsAngles": { + "text": "Reports an entity's orientation in world space rather than relative to a parent, which is what you want for aiming, tracing, and placing effects. Read from the name's Abs prefix; no prototype is derived, so the fields consulted and any parent composition are unverified.", + "source": "generated" + }, + "GetAbsOrigin": { + "text": "Reports an entity's world-space position rather than a parent-relative offset, the position to use for distance checks, spawning, and traces. Read from the name's Abs prefix; no prototype is derived, so the exact source fields are unverified.", + "source": "generated" + }, + "GetAbsScale": { + "text": "Reports an entity's world-space scale factor including any inherited parent scaling, useful when sizing effects or geometry to match a resized model. Read from the name; no prototype is derived, so how parent scale is composed in is unverified.", + "source": "generated" + }, + "GetAbsVelocity": { + "text": "Reports an entity's velocity in world space rather than a local frame, useful for motion prediction, leading projectiles, and knockback math. Read from the name; no prototype is derived, so the backing fields and units are unverified.", + "source": "generated" + }, + "GetAegisPickups": { + "text": "Reports a per-player tally of Aegis pickups, the kind of statistic you would surface on a scoreboard, an end-of-game summary, or a custom rule keyed on that stat. Read from the name; no prototype is derived, so the subject and counting rules are unverified.", + "source": "generated" + }, + "GetAgilityGain": { + "text": "Reports a hero's agility growth per level, the figure to use when projecting stats at a future level or building a stat comparison display. Read from the name; no prototype is derived, so whether talents or bonuses fold into it is unverified.", + "source": "generated" + }, + "GetAnimationIgnoresModelScale": { + "text": "Reports whether an entity's animation playback is decoupled from its model scale, which is the flag to inspect when a resized unit's motion no longer matches its size. Read from the name; no prototype is derived, so where the flag lives and what it drives are unverified.", + "source": "generated" + }, + "GetAssists": { + "text": "Reports a player's assist tally, the stat to read for scoreboards, MVP logic, or custom rewards. Read from the name; no prototype is derived, so the subject entity and what qualifies as an assist are unverified.", + "source": "generated" + }, + "GetAttackAnimationPoint": { + "text": "Reports the point within an attack animation at which the attack actually lands, the timing value to align damage application or projectile release with the visible swing. Read from the name; no prototype is derived, so units and modifier handling are unverified.", + "source": "generated" + }, + "GetAttackCapability": { + "text": "Reports what kind of attacking a unit is capable of, the value to test before issuing attack orders or writing targeting logic that assumes reach. Read from the name; no prototype is derived, so how the capability is encoded is unverified.", + "source": "generated" + }, + "GetAttacker": { + "text": "Reports the entity credited as the attacker for the current damage or attack context, the handle to read for kill credit, threat tracking, or retaliation behaviour. Read from the name; no prototype is derived, so which context object owns the value is unverified.", + "source": "generated" + }, + "GetAttacksPerSecond": { + "text": "Reports a unit's effective attack rate, useful for DPS estimates and for UI or AI that reasons about attack cadence. Read from the name; no prototype is derived, so whether attack-speed bonuses and haste are already folded in is unverified.", + "source": "generated" + }, + "GetAutoCastState": { + "text": "Reports whether an ability's autocast toggle is currently engaged, the state to read or mirror when scripting ability behaviour or custom ability UI. Read from the name; no prototype is derived, so the subject and how the state is encoded are unverified.", + "source": "generated" + }, + "GetBaseAgility": { + "text": "Reports a hero's base agility before item and modifier contributions, the starting point when recomputing derived stats such as armour or attack speed yourself. Read from the name; no prototype is derived, so whether per-level growth is already applied is unverified.", + "source": "generated" + }, + "GetBaseAttackRange": { + "text": "Reports a unit's unmodified attack range, the baseline to compare against when applying range bonuses or writing custom targeting and leash checks. Read from the name; no prototype is derived, so which sources are excluded from the base value is unverified.", + "source": "generated" + }, + "GetBaseAttackTime": { + "text": "Reports the unmodified interval between a unit's attacks, the baseline figure that attack-speed modifiers scale. Read from the name; no prototype is derived, so the units and exactly which modifiers are excluded are unverified.", + "source": "generated" + }, + "GetBaseHealthBarOffset": { + "text": "Reports the default height above a unit at which its health bar is anchored, useful when a custom or rescaled model leaves the bar floating or clipping. Read from the name; no prototype is derived, so the units and coordinate frame are unverified.", + "source": "generated" + }, + "GetBaseIntellect": { + "text": "Reports a hero's base intellect before item and modifier contributions, the value to start from when recomputing mana pool, regeneration, or damage yourself. Read from the name; no prototype is derived, so whether per-level growth is already applied is unverified.", + "source": "generated" + }, + "GetBaseStrength": { + "text": "Reports a hero's base strength before item and modifier contributions, the value to start from when recomputing health pool or regeneration yourself. Read from the name; no prototype is derived, so whether per-level growth is already applied is unverified.", + "source": "generated" + }, + "GetBonusDamageFromPrimaryStat": { + "text": "Reports the portion of a unit's attack damage contributed by its primary attribute, the component to isolate when presenting or recomputing a damage breakdown. Read from the name; no prototype is derived, so the attribute-to-damage rule it applies is unverified.", + "source": "generated" + }, + "GetBroadcasterChannel": { + "text": "Reports the broadcast channel a caster is assigned to, relevant when building spectator, commentary, or tournament-observer tooling that has to group broadcasters. Read from the name; no prototype is derived, so the subject and channel numbering are unverified.", + "source": "generated" + }, + "GetBroadcasterChannelSlot": { + "text": "Reports which slot inside a broadcast channel a given broadcaster occupies, distinguishing several casters sharing one channel. Read from the name; no prototype is derived, so slot numbering and the subject entity are unverified.", + "source": "generated" + }, + "GetCastRangeBonus": { + "text": "Reports the extra cast range stacked on top of an ability's base range, the addend to include when computing effective cast range or drawing a range indicator. Read from the name; no prototype is derived, so which sources contribute is unverified.", + "source": "generated" + }, + "GetClaimedDenies": { + "text": "Reports a player's claimed deny tally, a per-player statistic for scoreboards, post-game summaries, or custom scoring. Read from the name; no prototype is derived, so the subject and how a claimed count differs from a raw one are unverified.", + "source": "generated" + }, + "GetClaimedFarm": { + "text": "Reports the farm value attributed to a player, a per-player economy statistic for scoreboards, analytics overlays, or custom reward rules. Read from the name; no prototype is derived, so the quantity being measured and its units are unverified.", + "source": "generated" + }, + "GetClaimedMisses": { + "text": "Reports a player's claimed miss tally, a per-player statistic alongside the other claimed counters for scoreboards and post-game breakdowns. Read from the name; no prototype is derived, so the subject and what registers as a miss are unverified.", + "source": "generated" + }, + "GetClassNameAsCStr": { + "text": "Reports an entity's class name in C-string form, as the name's AsCStr suffix indicates, giving a cheap identity check when filtering entities without a schema lookup. Read from the name; no prototype is derived, so the string's lifetime and where the name is sourced from are unverified.", + "source": "generated" + }, + "GetConnectionState": { + "text": "Reports the current connection state of a client, the check to make before messaging a player or treating them as fully present in the game. Read from the name; no prototype is derived, so the subject and the set of state values are unverified.", + "source": "generated" + }, + "GetCooldownReduction": { + "text": "Reports the cooldown reduction currently in effect, the factor to fold in when predicting how soon an ability becomes usable again. Read from the name; no prototype is derived, so whether it expresses a fraction or a flat amount is unverified.", + "source": "generated" + }, + "GetCooldownTime": { + "text": "Reports an ability's full cooldown duration rather than the time left on it, which is the denominator for a cooldown progress readout or an AI cast-planning heuristic. Read from the name; no prototype is derived, so units and whether reductions are applied are unverified.", + "source": "generated" + }, + "GetCooldownTimeRemaining": { + "text": "Reports how much of an ability's cooldown is still to run, the value behind progress rings, AI readiness checks, and gating custom casts; GetCooldownTime supplies the full duration to compare against. Read from the name; no prototype is derived, so the units and subject are unverified.", + "source": "generated" + }, + "GetCreationTime": { + "text": "Reports the game time at which the subject object was created, useful for age checks and for expiring things after a duration. Read from the name; no prototype is derived, so the clock it uses and what it is timing are unverified.", + "source": "generated" + }, + "GetCreepDamageTaken": { + "text": "Reports how much damage the subject has taken from creeps, the kind of per-player tally a scoreboard or post-game panel reads. Read from the name; the accumulator behind it and how damage is attributed are unverified.", + "source": "generated" + }, + "GetCurrentAbilityCharges": { + "text": "Reports how many charges an ability currently has available, which ability and UI code check before allowing another use. Read from the name; whether it reflects base charges alone or charges after modifiers is unverified.", + "source": "generated" + }, + "GetCursorPosition": { + "text": "Reports the world position of the issuing player's cursor, the point an order or ground-targeted cast was aimed at. Read from the name; the coordinate space and which cursor sample it reflects are unverified.", + "source": "generated" + }, + "GetCursorTargetingNothing": { + "text": "Indicates that the cursor was over empty ground rather than a unit or entity, letting cast handling distinguish a point cast from a targeted one. Read from the name; what counts as a valid target here is unverified.", + "source": "generated" + }, + "GetCustomBuybackCooldown": { + "text": "Reports the buyback cooldown a custom mode has set for a player, so scripts can read back the override currently in effect. Read from the name; whether it yields the raw override or an effective cooldown is unverified.", + "source": "generated" + }, + "GetCustomBuybackCost": { + "text": "Reports the buyback gold cost a custom mode has set for a player, letting scripts read back their own override. Read from the name; whether an unset override reports a sentinel or the default cost is unverified.", + "source": "generated" + }, + "GetDamage": { + "text": "Reports the damage amount carried by the subject, such as a pending damage event or an attack's damage value. The name is generic, so what it is attached to and whether the figure is pre- or post-mitigation are unverified.", + "source": "generated" + }, + "GetDamageCustom": { + "text": "Reports the custom damage tag carried by a damage event, the value abilities and custom modes stamp so they can recognise their own damage later. Read from the name; the tag's encoding and who sets it are unverified.", + "source": "generated" + }, + "GetDamageDoneToHero": { + "text": "Reports the damage the subject has dealt to a given hero, the per-matchup breakdown used by scoreboards and post-game graphs. Read from the name; how the hero is identified and whether the figure is a running total are unverified.", + "source": "generated" + }, + "GetDamageForce": { + "text": "Reports the directional force vector attached to a damage event, used to drive knockback and ragdoll motion at the point of impact. Read from the name; its units and coordinate space are unverified.", + "source": "generated" + }, + "GetDamagePosition": { + "text": "Reports the world position at which damage was applied, useful for placing hit effects, floating numbers, and directional feedback. Read from the name; the coordinate space and whether it is the impact or attacker position are unverified.", + "source": "generated" + }, + "GetDamageType": { + "text": "Reports the damage classification carried by an event, the value that resistance and reduction logic keys off when applying the hit. Read from the name; the specific enumeration and its members are unverified.", + "source": "generated" + }, + "GetDeathGoldCost": { + "text": "Reports the gold a player forfeits on death, the figure death handling deducts and the UI previews. Read from the name; whether it reports a computed cost for the current state or a stored value is unverified.", + "source": "generated" + }, + "GetDeaths": { + "text": "Reports the subject's death count, the scoreboard tally. Read from the name; what increments it and whether it is per-match or per-life-cycle are unverified.", + "source": "generated" + }, + "GetDenies": { + "text": "Reports the number of denies credited to the subject, a laning statistic shown alongside last hits. Read from the name; what qualifies as a deny for this counter is unverified.", + "source": "generated" + }, + "GetGold": { + "text": "Reports the subject's current gold, the value purchase and buyback checks compare against. Read from the name, which does not distinguish reliable from unreliable gold, so which pool it reports is unverified.", + "source": "generated" + }, + "GetGoldLostToDeath": { + "text": "Reports the cumulative gold a player has forfeited through deaths over the match, a post-game economy statistic. Read from the name; when it is accumulated and whether it includes buyback losses are unverified.", + "source": "generated" + }, + "GetGoldPerMin": { + "text": "Reports a player's gold-per-minute rate, the economy figure shown on scoreboards. Read from the name; the averaging window and whether it is instantaneous or match-long are unverified.", + "source": "generated" + }, + "GetGoldSpentOnBuybacks": { + "text": "Reports the cumulative gold a player has spent on buybacks, one of the spending breakdowns behind post-game economy panels. Read from the name; how partial or refunded costs are treated is unverified.", + "source": "generated" + }, + "GetGoldSpentOnConsumables": { + "text": "Reports the cumulative gold a player has spent on consumable items, part of the post-game spending breakdown. Read from the name; which items are classified as consumables for this tally is unverified.", + "source": "generated" + }, + "GetGoldSpentOnItems": { + "text": "Reports the cumulative gold a player has spent on items, the headline figure in a post-game spending breakdown. Read from the name; whether it nets out sales and overlaps other spending categories is unverified.", + "source": "generated" + }, + "GetGoldSpentOnSupport": { + "text": "Reports the cumulative gold a player has spent on support purchases such as wards and shared utility, used to credit support play. Read from the name; which purchases count as support here is unverified.", + "source": "generated" + }, + "GetHasteFactor": { + "text": "Reports a haste multiplier applied to the subject, the scalar that speeds up whatever rate it governs. Read from the name; which rate it scales and whether it is a multiplier or an additive factor are unverified.", + "source": "generated" + }, + "GetHealing": { + "text": "Reports a healing amount tied to the subject, either the magnitude of a pending heal or healing credited to a player. Read from the name; which of those it is, and whether overheal is included, are unverified.", + "source": "generated" + }, + "GetHeroDamageTaken": { + "text": "Reports how much damage the subject has taken from heroes, separating player-inflicted damage from creep and neutral damage in statistics. Read from the name; the attribution rules and whether it is post-mitigation are unverified.", + "source": "generated" + }, + "GetHeroFacetID": { + "text": "Reports the identifier of the hero's selected facet, the per-hero variant choice that scripts branch on to enable variant-specific behaviour. Read from the name; the identifier's numbering and what it reports when unset are unverified.", + "source": "generated" + }, + "GetHeroID": { + "text": "Reports the numeric hero identifier for the subject, the stable key used to look a hero up rather than comparing unit names. Read from the name; the numbering scheme and its value for non-heroes are unverified.", + "source": "generated" + }, + "GetIntellectGain": { + "text": "Reports the hero's intelligence gain per level, the growth figure used to compute the attribute as the hero levels. Read from the name; whether it reports the base growth or a value already altered by effects is unverified.", + "source": "generated" + }, + "GetKills": { + "text": "Reports the subject's kill count, the scoreboard tally. Read from the name; what counts as a kill for this counter is unverified.", + "source": "generated" + }, + "GetKillsDoneToHero": { + "text": "Reports how many times the subject has killed a particular hero, the per-matchup breakdown behind kill-relationship displays. Read from the name; how the hero is identified and whether assists are excluded are unverified.", + "source": "generated" + }, + "GetLastAppliedTime": { + "text": "Reports the game time at which the subject was most recently applied, letting code measure elapsed time since the last application or refresh. Read from the name; what it timestamps and its clock are unverified.", + "source": "generated" + }, + "GetLastHitMultikill": { + "text": "Reports a multikill tally for last hits, counting creep kills landed together or in quick succession rather than hero kills. Read from the name; the grouping window and what resets the tally are unverified.", + "source": "generated" + }, + "GetLastHitStreak": { + "text": "Reports the subject's current run of consecutive last hits, a laning performance measure. Read from the name; what breaks the streak and whether it reports the current or best run are unverified.", + "source": "generated" + }, + "GetLastHits": { + "text": "Reports a player's last-hit tally, the creep kills credited to them, useful for laning-phase stats, scoreboards and bot evaluation. Read from the name; the entry is located by signature only, so the exact source of the count and who it is asked about are unverified.", + "source": "generated" + }, + "GetLiveSpectatorTeam": { + "text": "Reports the team a live spectator is currently attached to or viewing from, the value a mod would branch on when deciding what a spectating client may see. Read from the name; located by signature only, so the exact subject and value encoding are unverified.", + "source": "generated" + }, + "GetLocalScale": { + "text": "Reports an entity's local scale factor, the per-entity size multiplier applied relative to its parent rather than in world space. Read from the name; located by signature only, so whether it reflects a stored field or a computed value is unverified.", + "source": "generated" + }, + "GetMisses": { + "text": "Reports a miss count, the number of attacks that failed to land, as tracked for a unit or player. Read from the name; located by signature only, so the subject of the count and what is classified as a miss are unverified.", + "source": "generated" + }, + "GetMostRecentDamageTime": { + "text": "Reports the game time at which damage was last taken, the value to test when a mod needs recently-damaged checks such as regeneration gating or out-of-combat timers. Read from the name; located by signature only, so the time base and the subject are unverified.", + "source": "generated" + }, + "GetMoveSpeedModifier": { + "text": "Reports a movement-speed modifier, the multiplier or delta applied on top of a unit's base speed by buffs, debuffs and items. Read from the name; located by signature only, so whether it is a factor or an additive amount is unverified.", + "source": "generated" + }, + "GetMultipleKillCount": { + "text": "Reports the size of a multi-kill, the number of kills grouped into one streak event, as used for double-kill and rampage style announcements. Read from the name; located by signature only, so the window that groups kills and the subject are unverified.", + "source": "generated" + }, + "GetName": { + "text": "Purpose is not established: the name indicates only that some name is fetched, and nothing in this entry says whose or in what form.", + "source": "generated" + }, + "GetNearbyCreepDeaths": { + "text": "Reports how many creeps have died near a given unit or player, the kind of proximity statistic used for experience-share and lane-presence logic. Read from the name; located by signature only, so the radius, the time window and the subject are unverified.", + "source": "generated" + }, + "GetNetWorth": { + "text": "Reports a player's net worth, the combined value of gold held and items owned that scoreboards and comeback logic key on. Read from the name; located by signature only, so exactly which holdings are summed is unverified.", + "source": "generated" + }, + "GetNthPlayerIDOnTeam": { + "text": "Looks up the player ID sitting at an index within a team's roster, the usual way to walk one team's players in order rather than scanning all slots. Read from the name; located by signature only, so index origin and handling of empty slots are unverified.", + "source": "generated" + }, + "GetNumAttackers": { + "text": "Reports how many attackers are currently engaging a unit, the sort of threat count aggro, retreat and bot-danger logic reads. Read from the name; located by signature only, so what counts as an attacker and for how long are unverified.", + "source": "generated" + }, + "GetNumConsumablesPurchased": { + "text": "Reports how many consumable items a player has bought over the match, a per-player purchase statistic for end-game summaries and economy analysis. Read from the name; located by signature only, so which items count as consumables and whether the tally survives refunds are unverified.", + "source": "generated" + }, + "GetNumCouriersForTeam": { + "text": "Reports how many couriers a team currently has, the check to make before spawning or granting another one. Read from the name; located by signature only, so whether dead or in-flight couriers are included is unverified.", + "source": "generated" + }, + "GetNumItemsInInventory": { + "text": "Reports how many items a unit is carrying in its inventory, the occupancy check to run before trying to give or move an item. Read from the name; located by signature only, so whether backpack and stash slots are included is unverified.", + "source": "generated" + }, + "GetNumItemsInStash": { + "text": "Reports how many items are sitting in a player's stash, the base-only storage separate from carried inventory. Read from the name; located by signature only, so the subject and whether stacked items count once or per unit are unverified.", + "source": "generated" + }, + "GetNumItemsPurchased": { + "text": "Reports how many items a player has bought over the match, a cumulative economy statistic for summaries and analysis. Read from the name; located by signature only, so whether consumables, recipes and refunded buys are folded in is unverified.", + "source": "generated" + }, + "GetOpposingTeamNumber": { + "text": "Maps a team to its enemy team's number, the small helper to call instead of hardcoding a Radiant/Dire flip when filtering targets or scanning rosters. Read from the name; located by signature only, so its behaviour for neutral and spectator teams is unverified.", + "source": "generated" + }, + "GetOriginalDamage": { + "text": "Reports the damage amount as originally dealt, before reductions and modifiers reshaped it, which is what damage-reflection and analytics want rather than the final applied number. Read from the name; located by signature only, so the exact stage it captures is unverified.", + "source": "generated" + }, + "GetPacket": { + "text": "Fetches a network packet from the networking layer, making it the handle a mod would reach for when inspecting traffic. This lives in libnetworksystem and is read from the name alone, so what packet is selected and how it is addressed are unverified.", + "source": "generated" + }, + "GetParticleReplacement": { + "text": "Looks up a substitute particle effect to play in place of a requested one, the mechanism behind cosmetic and item-based visual overrides. Read from the name; located by signature only, so the key used for lookup and the fallback when no replacement exists are unverified.", + "source": "generated" + }, + "GetPartyID": { + "text": "Fetches a player's party identifier, and the shipped log text \"Lobby disagreed about PartyID when fetching PartID for player %d. Lobby said %llx, player resource said %llx.\" shows the lobby and the player resource each hold a copy that can diverge. Treat the two sources as potentially inconsistent when reading party membership.", + "source": "generated" + }, + "GetPlayerCountForTeam": { + "text": "Reports how many players are on a team, the roster size to check before indexing team slots or balancing sides. Read from the name; located by signature only, so whether disconnected players and bots are included is unverified.", + "source": "generated" + }, + "GetPlayerLoadedCompletely": { + "text": "Reports whether a player has finished loading into the match, the gate to wait on before sending them state or starting logic that assumes a ready client. Read from the name; located by signature only, so what \"completely\" covers is unverified.", + "source": "generated" + }, + "GetPlayerName": { + "text": "Fetches a player's display name, the string to use for scoreboards, chat and log lines. Read from the name; located by signature only, so how the player is identified and whether the text is sanitised or localised are unverified.", + "source": "generated" + }, + "GetPrimaryStatValue": { + "text": "Reports the value of a hero's primary attribute, the strength, agility or intelligence figure that drives its main scaling. Read from the name; located by signature only, so whether bonuses from items and buffs are folded in is unverified.", + "source": "generated" + }, + "GetRawPlayerDamage": { + "text": "Reports damage attributed to a player in raw form, before mitigation and modifiers adjust it, which is the figure damage-breakdown displays and analytics want. Read from the name; located by signature only, so the accumulation window and the exact stage it captures are unverified.", + "source": "generated" + }, + "GetReliableGold": { + "text": "Reports a player's reliable gold, the portion not lost on death as opposed to unreliable gold. Read from the name; located by signature only, so the subject and whether pending awards are included are unverified.", + "source": "generated" + }, + "GetRemainingPathLength": { + "text": "Reports how much of a unit's current navigation path is still ahead of it, the distance to test for arrival checks, ETA estimates and repath decisions. Read from the name; located by signature only, so the units used and behaviour without an active path are unverified.", + "source": "generated" + }, + "GetReportedPosition": { + "text": "Reports the position a unit is recorded or broadcast as occupying, which may lag or be smoothed relative to its exact simulation origin. Read from the name; located by signature only, so which of those two the value tracks and how often it updates are unverified.", + "source": "generated" + }, + "GetRespawnSeconds": { + "text": "Reports the respawn wait in seconds for a dead hero, the number to read for respawn timers, buyback pricing and death-screen displays. Read from the name; located by signature only, so whether it is the full duration or the remaining time is unverified.", + "source": "generated" + }, + "GetRoshanKills": { + "text": "Reports how many Roshan kills are credited to a player or team, an objective statistic for scoreboards and match summaries. Read from the name; located by signature only, so the subject of the count and how shared kills are attributed are unverified.", + "source": "generated" + }, + "GetRunePickups": { + "text": "Reports how many runes a player has picked up over the match, a per-player statistic for summaries and lane-control analysis. Read from the name; located by signature only, so which rune types are counted and whether bottled runes count is unverified.", + "source": "generated" + }, + "GetSelectedHeroID": { + "text": "Reports the identifier of the hero a player picked, the value to read during and after drafting to know who they will play. Read from the name; located by signature only, so its value before a selection is made and how the player is identified are unverified.", + "source": "generated" + }, + "GetSelectedHeroName": { + "text": "Returns the hero name a given player selected, keyed by player id. The shipped string \"PR:GetSelectedHeroName called with bogus player id %d, ignoring\" shows an out-of-range id is refused and logged rather than treated as fatal, so it tolerates untrusted slot values; the owning class is not established by this data.", + "source": "generated" + }, + "GetSerialNumber": { + "text": "Returns the serial number stored on the queried object, the versioning counter that distinguishes a reused slot from its previous occupant. Read from the name; that handle-versioning role is an inference and the owning class is not established here.", + "source": "generated" + }, + "GetSharedCooldownName": { + "text": "Returns the identifier of the shared-cooldown group an ability belongs to, letting callers tell which abilities lock each other out when one of them is used. Read from the name; the owning class and how groups are keyed are unverified.", + "source": "generated" + }, + "GetSteamAccountID": { + "text": "Returns the Steam account identity of the queried player, the stable value to key persistent per-player data on across matches. Read from the name; the owning class is not established here.", + "source": "generated" + }, + "GetStreak": { + "text": "Returns the running streak tally kept for the queried subject, the counter streak announcements and bounty adjustments read. Read from the name; which streak it tracks (kill, win, or another) is not established by this data.", + "source": "generated" + }, + "GetStrengthGain": { + "text": "Returns a hero's per-level strength growth, the figure used to compute strength at an arbitrary level. Read from the name; the owning class, and whether the value is the base growth or one already altered by modifiers, are unverified.", + "source": "generated" + }, + "GetStuns": { + "text": "Returns a stun tally recorded for the queried subject, the kind of aggregate an end-of-match stat panel reports. Read from the name; whether it counts stuns inflicted or stuns suffered, and in what units, is not established.", + "source": "generated" + }, + "GetTeam": { + "text": "Returns the team affiliation of the queried entity, the value friend-or-foe checks and team filtering compare against. Read from the name; the owning class is not established here.", + "source": "generated" + }, + "GetTeamKills": { + "text": "Returns the kill total credited to a team, the aggregate scoreboards and comeback logic read. Read from the name; the owning class, and whether the team is the subject or is derived from a player, are unverified.", + "source": "generated" + }, + "GetTimeOfLastConsumablePurchase": { + "text": "Returns the timestamp of the queried player's most recent consumable purchase, letting callers measure how long since they last restocked. Read from the name; the reference clock and the owning class are unverified.", + "source": "generated" + }, + "GetTimeOfLastDeath": { + "text": "Returns the timestamp of the queried subject's most recent death, useful for respawn gating, buyback rules, and time-since-death statistics. Read from the name; the reference clock, the owning class, and the value before any death are unverified.", + "source": "generated" + }, + "GetTimeOfLastItemPurchase": { + "text": "Returns the timestamp of the queried player's most recent item purchase, a usable gate for shop-related rules and purchase-frequency statistics. Read from the name; the reference clock and the owning class are unverified.", + "source": "generated" + }, + "GetTimeUntilRespawn": { + "text": "Returns how much time remains before the queried subject respawns, the countdown a respawn timer or HUD element shows. Read from the name; the units, the owning class, and the behaviour while the subject is alive are unverified.", + "source": "generated" + }, + "GetToggleState": { + "text": "Reports the on/off state of a toggleable thing, such as whether a toggle ability is currently switched on. Read from the name; the owning class and what exactly counts as toggled are unverified.", + "source": "generated" + }, + "GetTotalEarnedGold": { + "text": "Returns the cumulative gold the queried player has earned across the match, including gold already spent, as distinct from current holdings. Read from the name; the owning class, and whether reliable and unreliable sources are combined, are unverified.", + "source": "generated" + }, + "GetTotalEarnedXP": { + "text": "Returns the cumulative experience the queried subject has earned across the match, the basis for XP-per-minute figures and end-of-match graphs. Read from the name; the owning class is not established here.", + "source": "generated" + }, + "GetTotalGoldSpent": { + "text": "Returns the running total of gold the queried player has spent, the counterpart to earnings when computing net worth or spending efficiency. Read from the name; the owning class and which purchases count toward it are unverified.", + "source": "generated" + }, + "GetTotalledDamage": { + "text": "Returns an accumulated damage total for the queried subject, the summed figure damage breakdowns and end-of-match stats report. Read from the name; whether it totals damage dealt or damage taken, and over what scope, is not established.", + "source": "generated" + }, + "GetTowerDamageTaken": { + "text": "Returns a tower-damage-taken total for the queried subject. Read from the name, which leaves open whether that means damage a tower has absorbed or the tower damage credited to a player; the owning class is not established here.", + "source": "generated" + }, + "GetTowerKills": { + "text": "Returns how many towers the queried subject is credited with destroying, a standard scoreboard and objective-progress statistic. Read from the name; the owning class, and whether assists on a tower count, are unverified.", + "source": "generated" + }, + "GetUnitLabel": { + "text": "Returns the label assigned to a unit, the short tag used to identify or group it from scripts and UI. Read from the name; the owning class and how labels get assigned are unverified.", + "source": "generated" + }, + "GetUnitShareMaskForPlayer": { + "text": "Returns the unit-sharing permission mask a given player holds over a unit, encoding which control rights (movement, abilities, items) have been shared with them. Read from the name; the owning class and which right each bit represents are unverified.", + "source": "generated" + }, + "GetUnreliableGold": { + "text": "Returns the queried player's unreliable gold, the accounting bucket held separately from reliable gold. Read from the name; the owning class, and how the two buckets are drawn down when spending, are not established here.", + "source": "generated" + }, + "GetUpgradeRecommended": { + "text": "Reports whether an upgrade is currently recommended for the queried subject, the flag that suggested-ability and suggested-item prompts read. Read from the name; the owning class and what makes a recommendation active are unverified.", + "source": "generated" + }, + "GetXPPerMin": { + "text": "Returns the queried player's experience-per-minute rate, the time-normalized figure scoreboards and performance comparisons display. Read from the name; the owning class and the averaging window are unverified.", + "source": "generated" + }, + "HasAnyActiveAbilities": { + "text": "Reports whether the queried unit holds at least one active, castable ability rather than only passive ones. Read from the name; the owning class, and whether unlearned or hidden abilities are counted, are unverified.", + "source": "generated" + }, + "HasAnyAvailableInventorySpace": { + "text": "Reports whether the queried unit has a free inventory slot, the guard to test when deciding whether an item can be granted or picked up. Read from the name; the owning class and which slot ranges are considered are unverified.", + "source": "generated" + }, + "HasAttackCapability": { + "text": "Reports whether the queried unit can attack at all, the gate separating attack-capable units from those with no attack. Read from the name; the owning class, and whether melee and ranged are distinguished here, are unverified.", + "source": "generated" + }, + "HasFlyMovementCapability": { + "text": "Reports whether the queried unit is capable of flying movement, the check behind ignoring ground pathing and terrain height. Read from the name; the owning class, and whether a temporary flight modifier registers, are unverified.", + "source": "generated" + }, + "HasFunction": { + "text": "Reports whether a particular function is present on the queried subject. The name does not indicate what kind of function is meant or what owns it, so the purpose is not established.", + "source": "generated" + }, + "HasGroundMovementCapability": { + "text": "Reports whether the queried unit moves over ground, the counterpart test to HasFlyMovementCapability when deciding which pathing rules apply. Read from the name; the owning class, and whether immobile structures are excluded, are unverified.", + "source": "generated" + }, + "HasMovementCapability": { + "text": "Reports whether the queried unit has any movement capability, separating mobile units from static ones such as buildings. Read from the name; the owning class, and whether it aggregates the ground and flying cases, are unverified.", + "source": "generated" + }, + "HasOwnerAbandoned": { + "text": "Reports whether the owner of the queried subject has abandoned the match, the state that unlocks abandon-related rules such as shared control or altered penalties. Read from the name; the owning class and the abandon criteria are unverified.", + "source": "generated" + }, + "HasRandomed": { + "text": "Reports whether the queried player took a random hero rather than picking one, the flag that random-specific bonuses key on. Read from the name; the owning class, and how repicking after a random affects it, are unverified.", + "source": "generated" + }, + "HasSelectedHero": { + "text": "Reports whether a hero pick has been locked in for the subject, the natural gate for draft-phase logic. Read from the name; the owning object and what counts as a completed selection are unverified, so confirm against your own hero-selection state before branching on it.", + "source": "generated" + }, + "HasSetNetworkedEventActionClaimCount": { + "text": "Reports whether a claim count for a networked event action has already been written, letting callers tell an unwritten value apart from a legitimately low one. Read from the name; the event-action identity and where the count is stored are unverified, so treat it as a presence check in event-claim bookkeeping.", + "source": "generated" + }, + "HaveAllPlayersJoined": { + "text": "Reports whether all expected players have finished connecting, the readiness condition for leaving a waiting state and starting play. Read from the name; how the expected roster is counted and when it is fixed are unverified, so cross-check against your own connection tracking.", + "source": "generated" + }, + "IEconItemInterface::GetExpirationDate": { + "text": "Reports the point in time at which an economy item expires, with the nearby `giftable after date` string anchor placing it among the item's date-bearing attributes. Read from the name and that anchor; use it to hide or refuse actions on expired items, though the time representation and the unset case are unverified.", + "source": "generated" + }, + "IEconItemInterface::IsCommodity": { + "text": "Tests whether an economy item is a commodity, meaning an interchangeable, fungible item rather than a unique instance. Read from the name; the attribute it consults and how commodity status is stored are unverified.", + "source": "generated" + }, + "IEconItemInterface::IsDeletable": { + "text": "Tests whether an economy item may be deleted from the owner's inventory, so UI and server code can gate destroy actions. Read from the name; the backing attribute and any exceptions are unverified.", + "source": "generated" + }, + "IEconItemInterface::IsDynamicRecipe": { + "text": "Tests whether an economy item is a dynamic recipe, a crafting item whose required inputs vary per instance. The nearby `account bound` string anchor sits with the same family of item-restriction attributes and is context rather than confirmation; the reading itself comes from the name.", + "source": "generated" + }, + "IEconItemInterface::IsGiftable": { + "text": "Tests whether an economy item may be gifted to another account. The nearby `cannot delete` string anchor belongs to the same block of item-restriction text, so treat it as neighbouring context; the reading comes from the name and the restriction it consults is unverified.", + "source": "generated" + }, + "IEconItemInterface::IsMarketable": { + "text": "Tests whether an economy item may be listed for sale on the market, letting code gate market-listing paths. Read from the name; no string anchor supports it and the attribute consulted is unverified.", + "source": "generated" + }, + "IEconItemInterface::IsPennant": { + "text": "Tests whether an economy item is a pennant, a distinct item type in the economy schema. The nearby `dynamic_recipe` string anchor is an adjacent item-type token rather than a description of this check, so the reading rests on the name.", + "source": "generated" + }, + "IEconItemInterface::IsTradable": { + "text": "Tests whether an economy item may be traded to another account, the predicate to gate trade offers on. Read from the name; the flags or trade-lock timing it consults are unverified.", + "source": "generated" + }, + "IEconItemInterface::IsUsableInCrafting": { + "text": "Tests whether an economy item may be consumed as an input to crafting. The nearby `is commodity` string anchor sits among the same item-predicate strings and is context only; the reading comes from the name and the attribute consulted is unverified.", + "source": "generated" + }, + "IEntityListener::OnEntityCreated": { + "text": "Entity-creation notification on the listener interface, letting an implementation observe a CEntityInstance coming into existence and attach its own per-entity bookkeeping. Read from the name; the timing relative to spawn and which entity state is valid at that moment are unverified.", + "source": "generated" + }, + "IEntityListener::OnEntityDeleted": { + "text": "Entity-deletion notification on the listener interface, the hook where a mod drops cached pointers or handles for a CEntityInstance going away. Read from the name; how much of the entity remains usable at that point is unverified.", + "source": "generated" + }, + "IEntityListener::OnEntityParentChanged": { + "text": "Notification that an entity's parent attachment has changed, letting a listener track the entity hierarchy as objects are attached and detached. Read from the name; whether both old and new parents are conveyed, and how detachment is signalled, are unverified.", + "source": "generated" + }, + "IGameSystem::InitAllSystems": { + "text": "Brings the registered game systems through their initialization stage, the point at which system-level state becomes available. Read from the name and its presence in libhost; what qualifies as a registered system here, and how a plugin's own system participates, are unverified.", + "source": "generated" + }, + "IGameSystem::LoopDeactivateAllSystems": { + "text": "Deactivates the registered game systems for the loop teardown stage of the game-system lifecycle, where per-session or per-map system state is released. Read from the name; the exact scope of a loop and what deactivation is expected to free are unverified.", + "source": "generated" + }, + "IKV3TransferInterface_ResourceLoad": { + "text": "Performs the resource-load step of a KV3 transfer interface, turning KV3-described data into a loaded material-system resource. Read from the name and its host module libmaterialsystem2; confidence is name-only, so which resource kinds it handles and how loading is staged are unverified.", + "source": "generated" + }, + "IncrementAssists": { + "text": "Raises a player's tracked assist tally, the bookkeeping behind the assists column on the scoreboard. Read from the name; the backing storage and whether the new value is networked are unverified, so read the count back through your usual stat accessor rather than assuming it.", + "source": "generated" + }, + "IncrementClaimedDenies": { + "text": "Raises the tally of denies counted as claimed, a total kept apart from the plain deny count. Read from the name; what qualifies a deny as claimed is unverified, so inspect it alongside IncrementDenies when auditing deny bookkeeping.", + "source": "generated" + }, + "IncrementClaimedMisses": { + "text": "Raises the tally of misses counted as claimed, a total kept apart from the plain miss count. Read from the name; the rule that promotes a miss to claimed is unverified, so inspect it alongside IncrementMisses when reconciling last-hit statistics.", + "source": "generated" + }, + "IncrementDeaths": { + "text": "Raises a player's death tally, the bookkeeping behind the deaths column on the scoreboard. Read from the name; the backing storage and any respawn or streak side effects are unverified, so do not assume it also clears streak counters.", + "source": "generated" + }, + "IncrementDenies": { + "text": "Raises the deny tally for a player, counting last hits taken on friendly units. Read from the name; the backing storage and whether the value is networked to clients are unverified, so confirm via your own stat readback.", + "source": "generated" + }, + "IncrementKills": { + "text": "Raises a player's kill tally, the bookkeeping behind the kills column on the scoreboard. Read from the name; the storage and any coupling to streak or bounty logic are unverified, so treat streak updates as separate work.", + "source": "generated" + }, + "IncrementLastHitMultikill": { + "text": "Raises the tally of last-hit multikills, last hits grouped together as one burst rather than counted individually. Read from the name; the grouping window and what closes a burst are unverified, so verify the timing rule before using this as an achievement trigger.", + "source": "generated" + }, + "IncrementLastHitStreak": { + "text": "Advances the consecutive last-hit streak counter for a player. Read from the name; where the streak resets and what breaks it are unverified, so pair this with your own reset handling rather than expecting the function to manage streak lifetime.", + "source": "generated" + }, + "IncrementLastHits": { + "text": "Raises the last-hit tally for a player, counting killing blows landed on enemy units. Read from the name; the backing storage and whether the value is networked are unverified, so read it back through your usual stat accessor.", + "source": "generated" + }, + "IncrementMisses": { + "text": "Raises the tally of missed last-hit attempts for a player. Read from the name; what the game counts as a miss and when the tally is sampled are unverified, so compare against IncrementLastHits when reconciling per-player creep statistics.", + "source": "generated" + }, + "IncrementModifierRefCount": { + "text": "Raises the reference count on a modifier so it survives while more than one owner still needs it. Read from the name; the matching release path and the lifetime rules are unverified, so keep increments balanced to avoid leaking or prematurely freeing a modifier.", + "source": "generated" + }, + "IncrementNearbyCreepDeaths": { + "text": "Raises a tally of creep deaths occurring near the subject, the counter behind proximity-based credit such as shared experience range. Read from the name; the radius and which deaths qualify are unverified, so establish the proximity rule before relying on the number.", + "source": "generated" + }, + "IncrementStreak": { + "text": "Advances a streak counter for the subject, the running tally that grows while successes continue. Read from the name; which streak it tracks and what resets it are unverified, so identify the owning stat before wiring rewards to it.", + "source": "generated" + }, + "IncrementTotalEarnedXP": { + "text": "Adds to a player's running total of earned experience, the lifetime-of-match accumulator rather than a current-level value. Read from the name; whether it also drives level-up handling is unverified, so treat leveling as separate logic.", + "source": "generated" + }, + "InitSteamLogin": { + "text": "Sets up the Steam login and authentication path for the running process. Read from the name and its host module libengine2; confidence is name-only, so the login mode, account context, and what a failed login leaves behind are unverified.", + "source": "generated" + }, + "InputAddAttribute": { + "text": "Handles the `AddAttribute` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputAddContext": { + "text": "Handles the `AddContext` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputChangeSubclass": { + "text": "Handles the `ChangeSubclass` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputClearContext": { + "text": "Handles the `ClearContext` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputClearParent": { + "text": "Handles the `ClearParent` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputDisableDamageForces": { + "text": "Handles the `DisableDamageForces` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputDisableShadow": { + "text": "Handles the `DisableShadow` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputDispatchResponse": { + "text": "Handles the `DispatchResponse` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputEnableDamageForces": { + "text": "Handles the `EnableDamageForces` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputEnableShadow": { + "text": "Handles the `EnableShadow` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputEndHint": { + "text": "Handles the `EndHint` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireEvent": { + "text": "Handles the `FireEvent` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireUser1": { + "text": "Handles the `FireUser1` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireUser2": { + "text": "Handles the `FireUser2` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireUser3": { + "text": "Handles the `FireUser3` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFireUser4": { + "text": "Handles the `FireUser4` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFollowEntity": { + "text": "Handles the `FollowEntity` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputFunctionAdapterS1Var": { + "text": "Handles the `IsTouching` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputKill": { + "text": "Handles the `Kill` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputKillConstrained": { + "text": "Handles the `KillConstrained` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputKillHierarchy": { + "text": "Handles the `KillHierarchy` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputPlatformDisable": { + "text": "Handles the `DisablePlatform` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputPlatformEnable": { + "text": "Handles the `EnablePlatform` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputPlatformFollowYaw": { + "text": "Handles the `PlatformFollowYaw` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputPlatformIgnoreYaw": { + "text": "Handles the `PlatformIgnoreYaw` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputRemoveAttribute": { + "text": "Handles the `RemoveAttribute` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputRemoveContext": { + "text": "Handles the `RemoveContext` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetDamageFilter": { + "text": "Handles the `SetDamageFilter` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetNonsolid": { + "text": "Handles the `SetNonsolid` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetParentAttachment": { + "text": "Handles the `SetParentAttachment` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetParentAttachmentMaintainOffset": { + "text": "Handles the `SetParentAttachmentMaintainOffset` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetPlaybackRateOnAllLayers": { + "text": "Handles the `SetPlaybackRateOnAllLayers` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetPosition": { + "text": "Handles the `SetPosition` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetSolid": { + "text": "Handles the `SetSolid` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetTargetPlayerToActivator": { + "text": "Handles the `SetTargetPlayerToActivator` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputSetTeam": { + "text": "Handles the `SetTeam` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputShowHint": { + "text": "Handles the `ShowHint` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputTurnOff": { + "text": "Handles the `TurnOff` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputTurnOn": { + "text": "Handles the `TurnOn` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InputUse": { + "text": "Handles the `Use` entity-IO input (the datadesc does not qualify which class owns this handler). Runs when a map's IO graph, or another entity's output, fires that input at this entity.", + "source": "derived" + }, + "InterruptMotionControllers": { + "text": "Interrupts motion controllers currently driving an entity, cutting short forced or scripted movement in progress. Read from the name; which controllers are affected and what position or state the entity is left in are unverified, so useful when handing movement control back after a forced-motion effect.", + "source": "generated" + }, + "IsActivated": { + "text": "Reports whether the subject is in its activated state. Read from the name; what activation means for the owning object is unverified, so identify whether it reflects entity lifecycle activation or an ability's active state before branching on it.", + "source": "generated" + }, + "IsActiveNeutral": { + "text": "Reports whether a neutral unit or camp counts as currently active rather than dormant or cleared. Read from the name; the activation criteria and whether the subject is a unit or a spawner are unverified, so confirm the owning object before using it in camp logic.", + "source": "generated" + }, + "IsAttacking": { + "text": "Reports whether the unit is currently carrying out an attack. Read from the name; whether it covers only the attack animation, the wind-up, or a standing attack order is unverified, so check it against observed behaviour before gating interrupt logic on it.", + "source": "generated" + }, + "IsBroadcaster": { + "text": "Reports whether a client is a broadcaster rather than a playing participant, the check for casting or observer feeds. Read from the name; how broadcaster status is assigned and which privileges accompany it are unverified, so confirm before granting spectator-only powers.", + "source": "generated" + }, + "IsBuybackDisabledByDevilsBargain": { + "text": "Reports whether buyback is currently blocked for a player specifically because of the Devil's Bargain effect. Read from the name; the effect's own trigger conditions and duration are unverified, so treat this as one narrow exception rather than a general buyback-eligibility test.", + "source": "generated" + }, + "IsCommandRestricted": { + "text": "Reports whether commands are currently restricted for the subject, a permission check before accepting input. Read from the name; whether it governs unit orders or client console and chat commands is unverified, so establish which sense applies before enforcing on it.", + "source": "generated" + }, + "IsDebuffImmune": { + "text": "Reports whether a unit currently ignores debuffs, the check that decides if a negative status effect should apply at all. Read from the name; which effect categories count as debuffs and whether existing ones are purged are unverified, so verify the classification your effects fall under.", + "source": "generated" + }, + "IsDev": { + "text": "Reports whether the subject is flagged as developer, the gate typically guarding internal tools and cheats. Read from the name; whether the flag describes an account, a build, or a server mode is unverified, so do not rely on it alone as a security boundary.", + "source": "generated" + }, + "IsDisableHelpSetForPlayerID": { + "text": "Reports whether the disable-help preference is set for a player, keyed per player ID as the name states. Read from the name; which assistance features the flag governs and where it is stored are unverified, so honour it before auto-assisting a player who opted out.", + "source": "generated" + }, + "IsFakeClient": { + "text": "Reports whether a client slot is a fake client \u2014 a bot or placeholder occupying a slot instead of a real network connection. Read from the name; how the flag is set and which bot varieties it covers are unverified, so confirm before skipping networking work for that slot.", + "source": "generated" + }, + "IsFeared": { + "text": "Reports whether a unit is currently under a fear effect. Read from the name; how fear is represented and whether it also implies loss of control are unverified, so pair it with your own movement-override checks rather than assuming behaviour.", + "source": "generated" + }, + "IsHeroSelected": { + "text": "Reports whether a hero is in the selected state during drafting. Read from the name; whether the subject is the hero or the picking player is unverified, so compare it with HasSelectedHero, whose name suggests the player-side view of the same question.", + "source": "generated" + }, + "IsHeroSharedWithPlayerID": { + "text": "Reports whether control of a hero is shared with another player, keyed per player ID as the name states. Read from the name; the grades of sharing it recognises, such as full versus partial control, are unverified, so validate against your own share state before accepting orders.", + "source": "generated" + }, + "IsHidden": { + "text": "Reports whether the entity is currently hidden. Read from the name; whether hidden means not rendered, not targetable, or excluded from queries is unverified, so confirm the sense before using it as a visibility or targeting filter.", + "source": "generated" + }, + "IsInBackpack": { + "text": "Tests whether an item is sitting in a backpack slot rather than an active inventory slot, so behaviour can be gated on where the item is carried. Read from the name; located by signature only, so which slots count as backpack is unverified.", + "source": "generated" + }, + "IsInStash": { + "text": "Tests whether an item is held in the stash rather than carried on the unit, the usual gate for suppressing an item's effects while it is stashed. Read from the name; no prototype is derived, so the exact ownership test is unverified.", + "source": "generated" + }, + "IsLowAttackPriority": { + "text": "Reports whether a unit is treated as a low-priority target by auto-attack selection, so attackers prefer other nearby targets over it. Read from the name; the criteria it consults are not established by this data.", + "source": "generated" + }, + "IsMovementImpaired": { + "text": "Reports whether a unit is currently under a movement-restricting state such as a slow or root, giving a single check before running movement logic. Read from the name; which states it counts as impairing is unverified.", + "source": "generated" + }, + "IsOpposingTeam": { + "text": "Answers whether a team or entity is hostile to the querying side, the kind of filter used for targeting, damage and vision rules. Read from the name; no prototype is derived, so what it compares is unverified.", + "source": "generated" + }, + "IsOutOfGame": { + "text": "Reports whether a player is no longer participating in the match, as distinct from being merely dead or briefly disconnected. Read from the name; the precise condition it tests is unverified.", + "source": "generated" + }, + "IsOwnersGoldEnough": { + "text": "Checks whether the owning player can afford the cost associated with the queried object, the affordability guard before a purchase or activation is allowed. Read from the name; the cost value it compares against is unverified.", + "source": "generated" + }, + "IsOwnersGoldEnoughForUpgrade": { + "text": "Checks whether the owner has enough gold to pay for an upgrade specifically, using the upgrade price rather than a base cost. Read from the name; where the upgrade price comes from is not established here.", + "source": "generated" + }, + "IsPassive": { + "text": "Reports whether the queried ability or effect is passive rather than actively cast, which decides whether it can be triggered by an order at all. Read from the name; no prototype is derived, so what it inspects is unverified.", + "source": "generated" + }, + "IsPhantomBlocker": { + "text": "Reports whether a unit is flagged as a phantom blocker, an entity that obstructs movement or pathing without behaving as an ordinary solid unit. Read from the name and its pairing with MakePhantomBlocker; the flag it reads is unverified.", + "source": "generated" + }, + "IsPhased": { + "text": "Reports whether a unit is currently phased, meaning it moves through other units instead of colliding with them. Read from the name; the state it queries is not established by this data.", + "source": "generated" + }, + "IsPositionInRange": { + "text": "Tests whether a world position falls within range of a reference point, the usual guard before applying a radius effect or accepting an order at a location. Read from the name; the reference point and radius source are unverified.", + "source": "generated" + }, + "IsRecipeGenerated": { + "text": "Reports whether an item was produced by combining a recipe rather than bought or granted directly, useful when distinguishing combined items from purchased ones. Read from the name; the flag it reads is unverified.", + "source": "generated" + }, + "IsStashEnabled": { + "text": "Reports whether stash access is currently permitted, the gate that blocks items moving to or from the stash under certain conditions. Read from the name; whose stash it refers to and which conditions apply are unverified.", + "source": "generated" + }, + "IsStolen": { + "text": "Reports whether an ability was acquired by stealing it from another unit rather than owned natively, letting callers treat borrowed abilities differently. Read from the name; what it inspects is not established here.", + "source": "generated" + }, + "IsStrongIllusion": { + "text": "Distinguishes a strong illusion from an ordinary one, so damage, targeting or reward rules can treat the two classes of copy differently. Read from the name; the property it tests is unverified.", + "source": "generated" + }, + "IsTaunted": { + "text": "Reports whether a unit is currently taunted and therefore forced onto a compelled attack target, letting normal order and targeting logic be bypassed. Read from the name; the state and forced target it consults are unverified.", + "source": "generated" + }, + "IsTempestDouble": { + "text": "Reports whether a unit is a Tempest Double style clone rather than the original hero, which callers use to vary ability, item or reward handling. Read from the name; the flag it checks is unverified.", + "source": "generated" + }, + "IsToggle": { + "text": "Reports whether an ability is a toggle that is switched on and off rather than a one-shot cast, which changes how activation should be handled. Read from the name; no prototype is derived, so what it inspects is unverified.", + "source": "generated" + }, + "IsTrained": { + "text": "Reports whether an ability has had at least one point invested in it, the usual precondition for casting it or presenting it as usable. Read from the name; the level value it reads is unverified.", + "source": "generated" + }, + "IsUnselectable": { + "text": "Reports whether an entity is excluded from player selection, as used for helper and dummy units that should stay out of click targeting and selection boxes. Read from the name; the flag it reads is unverified.", + "source": "generated" + }, + "IsValidPlayer": { + "text": "Validates that a player reference points at a real, in-game player before it is used, a defensive guard at API and script boundaries. Read from the name; what it requires for validity is unverified.", + "source": "generated" + }, + "IsValidPlayerID": { + "text": "Validates a player ID, checking that it is in range and refers to an occupied slot, before the ID is used to look a player up. Read from the name; the accepted range is not established here.", + "source": "generated" + }, + "IsValidTeamPlayer": { + "text": "Validates that a player reference is real and belongs to a playing team, excluding spectators and unassigned slots. Read from the name; which teams it accepts is unverified.", + "source": "generated" + }, + "IsValidTeamPlayerID": { + "text": "Validates a player ID and that its slot belongs to a playing team, the index-taking counterpart to the reference-based team check. Read from the name; the accepted ID range and team set are unverified.", + "source": "generated" + }, + "KeyValues::RecursiveLoadFromBuffer": { + "text": "Parses KeyValues text out of an in-memory buffer, descending into nested subkeys to build the whole tree. Read from the name and its home in libtier0; useful for loading config or script blocks a mod already holds in memory, though buffer conventions and error reporting are unverified.", + "source": "generated" + }, + "LaunchLootInitialHeight": { + "text": "Supplies the starting height used when a loot drop is launched into the air, one of the parameters shaping the toss arc. Read from the name; whether it returns a tunable, a constant or a computed value is not established here.", + "source": "generated" + }, + "LaunchLootRequiredHeight": { + "text": "Supplies the height a launched loot drop must reach in its arc, used alongside the initial height to shape the toss. Read from the name; where the value comes from is unverified.", + "source": "generated" + }, + "LoadAppSystems": { + "text": "Loads the engine's application systems, the initialisation work that brings core subsystems up for the process. Read from the name; it is located in libengine2 rather than the server library, and which systems it covers is unverified.", + "source": "generated" + }, + "MakeIllusion": { + "text": "Converts a unit into an illusion, applying the illusion state that separates it from the real hero. Read from the name; what it writes, and how the illusion is linked to its source unit, are unverified.", + "source": "generated" + }, + "MakePhantomBlocker": { + "text": "Turns a unit into a phantom blocker so it obstructs movement or pathing, the setter counterpart to IsPhantomBlocker. Read from the name; the flag it writes and whether the state expires are unverified.", + "source": "generated" + }, + "MakeVisibleToTeam": { + "text": "Grants one team visibility of an entity, the usual way to reveal a unit or ward to a single side without changing vision for everyone. Read from the name; whether the reveal is permanent or timed is not established here.", + "source": "generated" + }, + "ManageModelChanges": { + "text": "Applies pending model changes on an entity, reconciling the model it should currently be showing after transformations, form switches or cosmetic updates. Read from the name; what it compares and what it swaps are unverified.", + "source": "generated" + }, + "MergeChallengeFiles": { + "text": "Combines several challenge definition files into a single set, the kind of step used when event or quest data ships in multiple pieces. This is a name-only reading; nothing beyond the name is derived, so the file format and merge rules are unverified.", + "source": "generated" + }, + "ModifyGold": { + "text": "Adds to or subtracts from a player's gold, the operation behind rewards, purchases, denials and penalties. Read from the name; which gold pool it adjusts and how the amount is bounded are unverified.", + "source": "generated" + }, + "MountWorldVPK": { + "text": "Mounts the world's VPK archive so map and world-render assets become reachable through the filesystem. Read from the name in libworldrenderer; the mount point, packing layout and failure behaviour are unverified.", + "source": "generated" + }, + "NoHealthBar": { + "text": "Reports whether a unit should be drawn without its health bar, the flag used for wards, couriers and cosmetic units you do not want a bar over. Read from the name; the backing field and any override conditions are unverified.", + "source": "generated" + }, + "NoTeamSelect": { + "text": "Reports whether team selection is suppressed, i.e. the unit or mode does not let a player pick or change teams. Read from the name; what exactly it gates is unverified.", + "source": "generated" + }, + "NoUnitCollision": { + "text": "Reports whether a unit is exempt from unit-versus-unit collision, letting other units walk through it as phased summons and non-blocking props do. Read from the name; the movement path that honours it is unverified.", + "source": "generated" + }, + "NotOnMinimap": { + "text": "Reports whether an entity is hidden from the minimap for all viewers. Read from the name; the field it consults and whether it also affects other HUD elements are unverified.", + "source": "generated" + }, + "NotOnMinimapForEnemies": { + "text": "Reports whether an entity is hidden from the minimap only for the opposing team, while allies still see its icon. Read from the name; the visibility rules it consults are unverified.", + "source": "generated" + }, + "NumModifiersUsingAbility": { + "text": "Counts how many active modifiers on a unit were granted by a particular ability, the usual way to detect stacking of one ability's buffs. Read from the name; the modifier list it walks and whether hidden modifiers count are unverified.", + "source": "generated" + }, + "NumPlayers": { + "text": "Reports a player count for the current game or context. Read from the name; whether it counts connected, spectating or in-game players is unverified.", + "source": "generated" + }, + "NumTeamPlayers": { + "text": "Reports how many players belong to a team, useful for scaling per-team logic or validating lobby fill. Read from the name; which team states are included is unverified.", + "source": "generated" + }, + "OnChannelSelectionComplete": { + "text": "Handles the point at which a channelled selection has finished, and references the string 'selected_encounter', so the choice being resolved is an encounter pick. Beyond that anchor the stored value and the interruption behaviour are unverified.", + "source": "generated" + }, + "OnResourceManifestLoaded_SceneSystemExtraInit_RayTracing": { + "text": "Performs additional scene-system setup for ray tracing once a resource manifest has finished loading, so ray-tracing structures exist for the newly available resources. Read from the name in libscenesystem; the state it builds is unverified.", + "source": "generated" + }, + "PayGoldCost": { + "text": "Deducts the gold cost of an action from the paying player or unit. Read from the name; whether it also validates affordability or emits a spend event is unverified.", + "source": "generated" + }, + "PayGoldCostForUpgrade": { + "text": "Deducts the gold cost specific to upgrading something, such as levelling an ability or a shop upgrade, as opposed to a plain purchase. Read from the name; the upgrade kinds it covers are unverified.", + "source": "generated" + }, + "Plat_GetProcAddresses": { + "text": "Resolves exported function addresses from a loaded module, the platform-abstraction helper for binding exported engine entry points. Read from the name in libtier0; the lookup and failure semantics are unverified.", + "source": "generated" + }, + "ProcessConVar": { + "text": "Handles a console variable entry, applying or dispatching its parsed value within the engine's convar system. Read from the name in libengine2; the parsing rules and permission checks it applies are unverified.", + "source": "generated" + }, + "ProvidesVision": { + "text": "Reports whether an entity grants vision to its team, distinguishing sight-providing units and wards from blind ones. Read from the name; the vision radius fields it pairs with and the day/night handling are unverified.", + "source": "generated" + }, + "RandomFloatExp": { + "text": "Produces a random float with exponential weighting rather than a flat distribution, for rolls biased toward one end of a range. Read from the name; the exact distribution and random stream used are unverified.", + "source": "generated" + }, + "RandomInt": { + "text": "Produces a random integer within a range, the general-purpose integer roll used by gameplay code. Read from the name; whether the stream is the deterministic server one is unverified.", + "source": "generated" + }, + "RecordLastHit": { + "text": "Records that a unit was last-hit, the bookkeeping behind last-hit and deny counts shown on the scoreboard. Read from the name; the counters it touches and the denial case are unverified.", + "source": "generated" + }, + "RefCountsModifiers": { + "text": "Reports whether an ability's modifiers are reference-counted, meaning repeated applications share one instance rather than stacking separate ones. Read from the name; the modifier-application path that honours it is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for AnimParamType_t, the enum tagging which kind of value an animation-graph parameter carries. Read from the template argument and the GetFuncName name; the exact string produced and where reflection consumes it are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::AnimGraph::ParamType annotation, which tags a reflected member with the animation-graph parameter type it refers to. Read from the template argument; the emitted string and the tooling that reads it are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::AnimGraph::ReplayInputProvider annotation, marking a reflected type or member as a source of replayed graph input. Read from the template argument; the emitted string and the behavior the marker triggers are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::AnimGraph::UseReflectionEditor annotation, marking a type as edited through the generic reflection-driven editor rather than a bespoke one. Read from the template argument; the emitted string and the editor behavior are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::Color annotation, which attaches a display color to a reflected member. Read from the template argument; the emitted string and how the color is applied are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::Deprecated annotation, which flags a reflected member or type as obsolete so tools can warn about or hide it. Read from the template argument; the emitted string and the resulting tool behavior are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::Description annotation, which attaches explanatory help text to a reflected member. Read from the template argument; the emitted string and where the text surfaces are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::FriendlyName annotation, which gives a reflected member a human-readable display name distinct from its code identifier. Read from the template argument; the emitted string and its display sites are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::Group annotation, which files a reflected member under a named grouping for presentation. Read from the template argument; the emitted string and the grouping behavior are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::Icon annotation, which associates an icon with a reflected member. Read from the template argument; the emitted string and how the icon is resolved are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::IsEnabled annotation, which gates whether a reflected member is treated as active or disabled. Read from the template argument; the emitted string and the gating rule are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::MotionMatching::UsesCustomCurrentValue annotation, marking a motion-matching type as providing its own current-value computation instead of a default. Read from the template argument; the emitted string and the behavior it selects are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::MotionMatching::UsesCustomSampleInterpolation annotation, marking a motion-matching type as interpolating between samples with its own routine. Read from the template argument; the emitted string and the interpolation it selects are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::ObjectColor annotation, which attaches a color to a whole reflected object rather than to a single member. Read from the template argument; the emitted string and how the color is applied are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::ObjectGroup annotation, which files a whole reflected object under a named grouping. Read from the template argument; the emitted string and the grouping behavior are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::ObjectIcon annotation, which associates an icon with a whole reflected object. Read from the template argument; the emitted string and how the icon is resolved are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::ObjectName annotation, which gives a whole reflected object a display name of its own. Read from the template argument; the emitted string and where the name is shown are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::ObjectUserData annotation, which carries arbitrary caller-defined data on a reflected object. Read from the template argument; the emitted string and how the payload is interpreted are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::AnimGraph::EditExpression annotation, which asks the editor to present a member as an animation-graph expression field. Read from the template argument; the emitted string and the widget it selects are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::AnimGraph::EditParameterValue annotation, which asks the editor to present a member as an animation-graph parameter value field. Read from the template argument; the emitted string and the widget it selects are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::AutoExpand annotation, which asks the editor to show a member's contents expanded by default. Read from the template argument; the emitted string and the editor behavior are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::AutoRefresh annotation, which asks the editor to keep a member's displayed value refreshed as it changes. Read from the template argument; the emitted string and the refresh cadence are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::Edit annotation, which marks a reflected member as editable in the property UI. Read from the template argument; the emitted string and the widget chosen are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::EditCheckBox annotation, which asks the editor to present a member as a checkbox. Read from the template argument; the emitted string and the widget's binding are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::EditComboBox annotation, which asks the editor to present a member as a drop-down list of choices. Read from the template argument; the emitted string and where the choices come from are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::EditLabel annotation, which asks the editor to present a member as a plain text label. Read from the template argument; the emitted string and the widget's behavior are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::EditSlider annotation, which asks the editor to present a member as a slider. Read from the template argument; the emitted string and how the slider range is fixed are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::Embed annotation, which asks the editor to inline a member's own fields into the parent property list instead of nesting them. Read from the template argument; the emitted string and the layout effect are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::Font annotation, which selects the font used to display a reflected member. Read from the template argument; the emitted string and how the font is resolved are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::HideAddRemoveButtons annotation, which suppresses the add and remove controls an editor would otherwise offer for a list-valued member. Read from the template argument; the emitted string and the affected widgets are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::ReadOnly annotation, which shows a member in the editor without allowing edits. Read from the template argument; the emitted string and how strictly it is enforced are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for the Attribute::UI::SortPriority annotation, which weights where a member is placed in an editor's property list. Read from the template argument; the emitted string and the sorting rule are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for BlendKeyType, the enum selecting how a blend node interprets its key values. Read from the template argument and the GetFuncName name; the emitted string and the enum's members are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CAnimVariant, the tagged value container animation code uses to carry a parameter of one of several types. Read from the template argument; the emitted string and the variant's cases are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CBlendPoseOperation, a pose operation whose name indicates it blends between poses, so the animation type registry and editor tooling can refer to that type textually. Read from the template argument in the name; the exact text produced and where it surfaces are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CChoreoPoseOperation, a pose operation whose name points at choreography-driven posing. Useful when you are mapping reflected animation type blocks back to concrete classes; the reading comes from the template argument, and the emitted text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CCurrentRotationVelocityMetricEvaluator, a metric evaluator whose name indicates it scores the current rotational velocity when motion matching ranks candidate animations. Derived from the template argument in the name; the emitted text and its consumers are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CDifferenceBlendPoseOperation, a pose operation whose name indicates a difference or additive-style blend between poses. Read from the template argument only, so the exact string it produces is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CDistanceRemainingMetricEvaluator, a metric evaluator whose name indicates it scores the distance still remaining to a goal during motion-matching selection. Name-level reading from the template argument; the produced text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CFetchCyclePoseOperation, a pose operation whose name indicates it fetches a cycle value rather than producing a blend. Taken from the template argument in the name; the emitted text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CFutureVelocityMetricEvaluator, a metric evaluator whose name indicates it scores predicted future velocity when motion matching ranks candidates. Read from the template argument; the exact string and the code that consumes it are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CLeafUpdateNode, an animation update-graph node whose name marks it as a terminal leaf. Handy when dumping graph node types by name while reverse-engineering a graph; read from the template argument, with the produced text unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CPairedSequenceUpdateNode, an update-graph node whose name indicates it drives a paired sequence. Read from the template argument in the name; the exact text produced is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CPathMetricEvaluator, a metric evaluator whose name indicates it scores candidate animations against a path. Derived from the template argument; the emitted text and its consumers are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CPoseOperation, the base pose-operation type that the more specific pose operations in this family extend. Useful as the anchor when identifying reflected pose-operation blocks; read from the template argument, so the produced text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CRagdollComponentInstance, the runtime ragdoll component instance attached to an animating entity. Read from the template argument in the name; the exact string and where it appears are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CSequenceUpdateNode, an animation update-graph node whose name indicates it plays a sequence. Read from the template argument; the produced text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CSequenceUpdateNodeBase, the shared base of the sequence-playing update nodes. Reach for it when you need the base type name rather than a concrete node name; read from the template argument, with the emitted text unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CSingleFramePoseOperation, a pose operation whose name indicates it samples one fixed frame instead of animating over time. Read from the template argument; the exact text produced is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CStateMachineUpdateNode, the animation update-graph node whose name indicates it hosts a state machine over child states. Useful when identifying state-machine blocks in reflected graph data; read from the template argument, with the produced text unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CStepsRemainingMetricEvaluator, a metric evaluator whose name indicates it scores how many footsteps remain before a goal. Read from the template argument; the emitted text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CStopAtGoalUpdateNode, an update-graph node whose name indicates it brings motion to a stop at a goal position. Read from the template argument in the name; the produced text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CUnaryUpdateNode, an update-graph node whose name indicates it wraps a single child node. Read from the template argument; the exact string it produces is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CUtlString, Valve's heap string container, so reflected members typed as a string can be described by name. Read from the template argument in the name; the emitted text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName>": { + "text": "Supplies the reflection name for a CUtlVector of CGlobalSymbol, the container shape used where a reflected member holds a list of interned symbol names. Read from the template argument; the produced text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName>>": { + "text": "Supplies the reflection name for a CUtlVector of CSmartPtr to CAnimComponentInstance, the container shape used where a reflected member holds reference-counted animation component instances. Read from the template argument in the name; the emitted text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName>>": { + "text": "Supplies the reflection name for a CUtlVector of CSmartPtr to CAnimMotorInstance, the container shape used where a reflected member holds reference-counted animation motor instances that drive movement. Read from the template argument; the produced text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName>>": { + "text": "Supplies the reflection name for a CUtlVector of CSmartPtr to CAnimParameterInstance, the container shape used where a reflected member holds the live animation-graph parameter instances. Read from the template argument; the emitted text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName>": { + "text": "Supplies the reflection name for a CUtlVector of CWeightPreview, the container shape used where a reflected member holds a list of blend-weight preview entries. Read from the template argument in the name; the produced text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CWayPointHelperUpdateNode, an update-graph node whose name indicates it assists movement along waypoints. Read from the template argument; the exact string produced is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for CWeightPreview, the small record whose name indicates it carries a previewed blend weight for tooling display. Read from the template argument in the name; the emitted text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for DampingSpeedFunction, the enumeration whose name indicates it selects how damping speed is shaped when a value is smoothed. Read from the template argument; the produced text and its consumers are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for FacingMode, the enumeration whose name indicates it selects how a character orients its facing. Useful when decoding reflected enum members in graph data; read from the template argument, with the emitted text unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for HSequence, the handle type that identifies an animation sequence, so reflected members holding a sequence reference can be described by name. Read from the template argument; the produced text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for IAnimParameter, the interface for animation-graph parameters that gameplay code reads and writes. Read from the template argument in the name; the exact string produced is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for IAnimTag, the interface for animation tags that mark regions or events within a clip. Read from the template argument; the emitted text and its consumers are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for IEnumAnimParameter, the interface for animation-graph parameters whose value is an enumeration rather than a number or bool. Read from the template argument in the name; the produced text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Supplies the reflection name for LinearRootMotionBlendMode_t, the enumeration whose name indicates it selects how linear root motion is blended between animations. Read from the template argument; the emitted text is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name string identifying the Reflection::CAttribute type, one instantiation of the reflection system's internal per-type name helper carried in libanimationsystem. Read from the name and its template argument; no prototype is derived, so the exact string form and where it surfaces are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name string for the ResetCycleOption enumeration, so animation cycle-reset options are identifiable by type name in libanimationsystem's reflection data. Useful when tracing how such enum-valued animation settings are exposed to tooling; read from the name and template argument, with no prototype derived, so the string's exact form is unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name string for the SelectorTagBehavior_t enumeration, giving selector tag-behaviour values a readable type name in libanimationsystem's reflection data. Read from the name and its template argument; no prototype is derived, so the returned string and how it is stored are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name string for the primitive bool type, an instantiation used where boolean-typed members are described by libanimationsystem's reflection data. Read from the name and its template argument; no prototype is derived, so the exact string and how reflection consumers obtain it are unverified.", + "source": "generated" + }, + "Reflection::Internal::GetFuncName": { + "text": "Yields the reflection name string for the primitive int type, an instantiation used where integer-typed members are described by libanimationsystem's reflection data. Read from the name and its template argument; no prototype is derived, so the exact string and how reflection consumers obtain it are unverified.", + "source": "generated" + }, + "RefundHealthCost": { + "text": "Returns health spent on an ability or action back to the caster, the counterpart to a health-cost payment when the action is refunded or cancelled. Read from the name; the refund amount rules are unverified.", + "source": "generated" + }, + "RefundManaCost": { + "text": "Returns mana spent on an ability back to the caster, used when a cast is cancelled or otherwise reimbursed. Read from the name; whether it refunds the full cost or a computed portion is unverified.", + "source": "generated" + }, + "RemoveAbilityFromIndexByName": { + "text": "Removes an ability from a unit's ability slots by matching its name, and logs 'CDOTA_BaseNPC::RemoveAbilityFromIndexByName called, removing ability=%s because it matched name=%s'. The companion anchor 'AbilityDraftAbilityRemoval' ties the removal to Ability Draft; the name-matching rules are otherwise unverified.", + "source": "generated" + }, + "ResetBreakpadAppId": { + "text": "Resets the application id reported to the Breakpad crash handler, so subsequent crash dumps are filed under the default app rather than an overridden one. Read from the name in libengine2; the value it restores is unverified.", + "source": "generated" + }, + "ResetBuybackCostTime": { + "text": "Clears the time-based component of a hero's buyback cost, the timer that makes buyback price grow with match time or a recent buyback. Read from the name; the exact timestamp it zeroes is unverified.", + "source": "generated" + }, + "ResetTotalEarnedGold": { + "text": "Zeroes a player's accumulated total earned gold, the lifetime-of-match tally used for net worth and end-game stats. Read from the name; whether reliable and unreliable gold are both cleared is unverified.", + "source": "generated" + }, + "RollPercentage": { + "text": "Performs a percentage chance roll, the standard proc check for effects with a stated chance to trigger. Read from the name; whether it uses pseudo-random distribution or a plain roll is unverified.", + "source": "generated" + }, + "SV_InstallHLTVStringTableMirrors": { + "text": "Installs mirrored copies of the server's string tables for HLTV, so spectator broadcasts carry their own copies of networked string data. Read from the name in libengine2; which tables are mirrored is unverified.", + "source": "generated" + }, + "ScaleDamage": { + "text": "Applies a scaling factor to a damage value, the multiplier step by which amplification or reduction adjusts a hit. Read from the name; which damage stage it acts on is unverified.", + "source": "generated" + }, + "ScheduleAutoChannelComplete": { + "text": "Schedules a channelled action to complete automatically at its due time, rather than waiting for an explicit finish. Read from the name; the timer mechanism and whether interruption cancels it are unverified.", + "source": "generated" + }, + "SchemaStaticInit_CBoneConstraintPoseSpaceMorph::Input_t": { + "text": "Static schema registration for the Input_t type nested inside the pose-space-morph bone constraint, so the physics module's type is described to the schema system. Beyond registering that type, purpose is not established; a modder would touch it only to confirm the type is schema-visible.", + "source": "generated" + }, + "SchemaStaticInit_CVoiceContainerStaticAdditiveSynth::CHarmonic": { + "text": "Static schema registration for the CHarmonic type nested inside the static additive-synth voice container in the sound system. Beyond registering that type, purpose is not established; it matters only as evidence the harmonic type is described in the schema.", + "source": "generated" + }, + "ScriptFirstMoveChild": { + "text": "Exposes the first child in an entity's movement-parent hierarchy to VScript, the entry point for walking an attachment chain from script. Read from the name; the traversal order is unverified.", + "source": "generated" + }, + "ScriptGetAbsOrigin": { + "text": "Exposes an entity's absolute world-space origin to VScript, as opposed to any local or parent-relative position. Read from the name; whether it reflects pending movement within the current tick is unverified.", + "source": "generated" + }, + "ScriptInputKill": { + "text": "Exposes the entity Kill input to VScript, removing the entity from the world on demand. Read from the name; whether removal is immediate or deferred, and how it differs from a gameplay death, are unverified.", + "source": "generated" + }, + "ScriptNextMovePeer": { + "text": "Exposes the next sibling in an entity's movement-parent hierarchy to VScript, the companion used with the first-child accessor to enumerate an attachment tree. Read from the name; the ordering is unverified.", + "source": "generated" + }, + "ScriptSetModel": { + "text": "Swaps the entity's model to a script-supplied asset, the script-facing way to change what a spawned entity looks like at runtime. Read from the name; the accepted model form and whether collision or animation state is rebuilt with it are unverified.", + "source": "generated" + }, + "ScriptSetOrigin": { + "text": "Places an entity at a world position given from script, moving it by setting its origin outright rather than by velocity. Read from the name; the coordinate space and whether collision is re-resolved after the move are unverified.", + "source": "generated" + }, + "ScriptSetSize": { + "text": "Resizes an entity's bounding volume from script, applying new extents to the box used for collision and selection. Read from the name; how the extents are expressed and whether dependent bounds are recomputed are unverified.", + "source": "generated" + }, + "Script_AddCandyEvent": { + "text": "Credits a candy entry \u2014 the seasonal event currency \u2014 from script, the hook a custom mode would use to award candy for in-game accomplishments. Read from the name; the recipient, amount and event identity it applies to are unverified.", + "source": "generated" + }, + "Script_AddDamageType": { + "text": "Adds a damage-type classification to the damage the caller represents, letting script widen how an ability's damage is categorised before mitigation. Read from the name; the flag encoding and whether the addition persists past one damage instance are unverified.", + "source": "generated" + }, + "Script_AddNeutralItemToStash": { + "text": "Puts a neutral item into a team's stash from script, giving custom modes a way to grant neutral drops directly. Read from the name; how the item and team are specified, and what happens when the stash is full, are unverified.", + "source": "generated" + }, + "Script_AlertNearbyUnits": { + "text": "Alerts units in the vicinity from script, notifying nearby AI that something worth reacting to has happened. Read from the name; the alert radius, which units qualify and what reaction it triggers are unverified.", + "source": "generated" + }, + "Script_CanParentBeAutoAttacked": { + "text": "Reports to script whether the caller's parent entity \u2014 typically a modifier's owner \u2014 is a legal auto-attack target, the check custom modifiers use to make a unit unattackable. Read from the name; the conditions folded into the answer are unverified.", + "source": "generated" + }, + "Script_EnableAbilityChargesOnTalentUpgrade": { + "text": "Turns on charge-based use for an ability when a talent upgrade grants it charges, from script. Read from the name; where the charge count and replenish timing come from, and whether the change can be undone, are unverified.", + "source": "generated" + }, + "Script_GetAdditionalOwnedUnits": { + "text": "Reports the extra units under an owner beyond its primary unit \u2014 summons, illusions and similar controlled entities \u2014 so script can act on a player's whole retinue. Read from the name; how ownership is decided and the collection form are unverified.", + "source": "generated" + }, + "Script_GetAmmoType": { + "text": "Reports the ammo type associated with the queried entity, for script that varies behaviour by ammunition kind. Read from the name; how the type is encoded and which entities carry a meaningful value are unverified.", + "source": "generated" + }, + "Script_GetAttackTarget": { + "text": "Reports the unit the queried entity is currently attacking, letting script react to what a unit has chosen to hit. Read from the name; whether it reflects a queued order or an attack already in progress is unverified.", + "source": "generated" + }, + "Script_GetAttacker": { + "text": "Reports the entity credited as the attacker in the damage or event record being inspected \u2014 the source unit rather than the ability. Read from the name; whether ownership is resolved through summons to a controlling hero is unverified.", + "source": "generated" + }, + "Script_GetAuraOwner": { + "text": "Reports the entity whose aura granted the modifier being inspected, letting script attribute aura effects back to their source. Read from the name; the result for modifiers that were not granted by an aura is unverified.", + "source": "generated" + }, + "Script_GetCastRangeBonus": { + "text": "Reports the cast-range bonus applied on top of an ability's base range, for script that needs the effective reach. Read from the name; the units, and whether bonuses from several sources are combined into one figure, are unverified.", + "source": "generated" + }, + "Script_GetCloneSource": { + "text": "Reports the original entity a clone was copied from, so script can tell a clone apart from the unit it duplicates. Read from the name; the result for entities that are not clones is unverified.", + "source": "generated" + }, + "Script_GetCreationTime": { + "text": "Reports the game time at which the entity came into existence, useful in script for age, lifetime and expiry checks. Read from the name; which clock it samples and how it behaves across saves or restarts are unverified.", + "source": "generated" + }, + "Script_GetCursorCastTarget": { + "text": "Reports the entity targeted by the cast currently being processed, the value a script ability reads to learn what it was aimed at. Read from the name; what it yields for point-targeted or no-target casts is unverified.", + "source": "generated" + }, + "Script_GetCursorTarget": { + "text": "Reports the entity under the targeting cursor for the caller, for script logic that branches on what is being aimed at. Read from the name; how it relates to Script_GetCursorCastTarget, and its value when the cursor is over ground, are unverified.", + "source": "generated" + }, + "Script_GetEvasion": { + "text": "Reports the queried unit's evasion \u2014 its chance to avoid an incoming attack \u2014 for script that inspects defensive stats. Read from the name; the scale used and whether contributions from several sources are combined are unverified.", + "source": "generated" + }, + "Script_GetEventPointsForPlayerID": { + "text": "Reports the seasonal-event point total held by a given player ID, for script gating on event progress. Read from the name; which event the total belongs to and how the player ID is supplied are unverified.", + "source": "generated" + }, + "Script_GetEventPremiumPoints": { + "text": "Reports a player's premium event points, the paid-tier counterpart to ordinary event points, for script that checks entitlement. Read from the name; the subject it is queried against and the event it refers to are unverified.", + "source": "generated" + }, + "Script_GetEventRanks": { + "text": "Reports the event rank standing reached, letting script gate rank-locked rewards and content. Read from the name; the rank encoding, whether several ranks come back together, and the subject queried are unverified.", + "source": "generated" + }, + "Script_GetForceAttackTarget": { + "text": "Reports the unit an entity has been forced to attack, overriding its normal target choice \u2014 the value script reads to see whether a forced target is in effect. Read from the name; the result when nothing is forced is unverified.", + "source": "generated" + }, + "Script_GetInflictor": { + "text": "Reports the ability or item credited with causing the damage or event being inspected, as distinct from the attacking unit. Read from the name; what it yields for damage dealt without an inflictor is unverified.", + "source": "generated" + }, + "Script_GetItemSlot": { + "text": "Reports which inventory slot an item occupies, for script that rearranges, swaps or inspects a unit's inventory. Read from the name; slot numbering and the value returned for items held outside the inventory are unverified.", + "source": "generated" + }, + "Script_GetLastAttackTime": { + "text": "Reports the game time of the unit's most recent attack, usable in script for attack-cadence, idle and out-of-combat checks. Read from the name; whether it records the swing start or the moment damage landed is unverified.", + "source": "generated" + }, + "Script_GetLevelSpecialValueFor": { + "text": "Looks up an ability's special value for a named key at a specified level, the script path for reading tuned per-level ability data such as damage or duration. Read from the name; the key form and the fallback for missing keys are unverified.", + "source": "generated" + }, + "Script_GetLevelSpecialValueNoOverride": { + "text": "Looks up an ability's per-level special value while ignoring overrides layered on the base data, giving script the untouched tuning number. Read from the name; which override sources are skipped, and how a level is chosen, are unverified.", + "source": "generated" + }, + "Script_GetNthCourierForTeam": { + "text": "Fetches the courier at a given index for a team, letting script walk a team's couriers rather than assume a single one. Read from the name; the index base and the result past the last courier are unverified.", + "source": "generated" + }, + "Script_GetPlayer": { + "text": "Reports the player associated with the queried entity, the script bridge from a hero or unit to the person controlling it. Read from the name; the result for neutral or unowned entities is unverified.", + "source": "generated" + }, + "Script_GetPreferredCourierForPlayer": { + "text": "Reports the courier a given player is set to use, so script issuing courier orders acts on the right one. Read from the name; how the preference is chosen and what comes back when the player has no courier are unverified.", + "source": "generated" + }, + "Script_GetProjectileSpeed": { + "text": "Reports the travel speed of the projectile involved, for script doing flight-time, lead and interception calculations. Read from the name; the units, and whether it describes an attack projectile or an ability-spawned one, are unverified.", + "source": "generated" + }, + "Script_GetRangeToUnit": { + "text": "Reports the distance from the queried entity to another unit, the script-side range check for proximity and cast-range logic. Read from the name; whether collision radii are subtracted and how height difference is handled are unverified.", + "source": "generated" + }, + "Script_GetRangedProjectileName": { + "text": "Reports the ranged-attack projectile name configured for a unit, the identifier a script reads when matching or overriding projectile visuals and behaviour. Script-exposed accessor read from the name; located by signature in libserver with no prototype derived, so the backing field is unverified.", + "source": "generated" + }, + "Script_GetReplicatingOtherHero": { + "text": "Reports the other hero that the subject is replicating, the link a script follows for illusions, clones and hero-copy effects. Read from the name; located by signature in libserver only, so what counts as replication here and how the link is stored are unverified.", + "source": "generated" + }, + "Script_GetSelectedHeroEntity": { + "text": "Reports the hero entity currently selected for a player, giving script a handle to the unit that player controls. Read from the name; located by signature in libserver with no prototype derived, so the selection source and behaviour before a hero is picked are unverified.", + "source": "generated" + }, + "Script_GetSpellAmplification": { + "text": "Reports a unit's spell amplification, the multiplier that scales its ability damage. Useful to script when previewing or replicating damage math; read from the name and located by signature only, so whether it reflects base stats, items or both is unverified.", + "source": "generated" + }, + "Script_GetStatusResistance": { + "text": "Reports a unit's status resistance, the factor that shortens the effective duration of debuffs applied to it. Read from the name and located by signature in libserver; whether the value is a fraction, a percentage, or already combined across sources is unverified.", + "source": "generated" + }, + "Script_HasDamageType": { + "text": "Tests whether a given damage type is set on the subject, letting script branch on physical, magical or pure classification. Read from the name; located by signature in libserver with no prototype derived, so the accepted encoding of the damage-type argument is unverified.", + "source": "generated" + }, + "Script_InterruptChannel": { + "text": "Interrupts an ability channel in progress, ending the channelled effect early as a script-driven stop or silence would. Read from the name; located by signature in libserver only, so whether it also triggers the ability's interrupt handling is unverified.", + "source": "generated" + }, + "Script_IsAttackingEntity": { + "text": "Tests whether the unit is currently attacking a specified entity, a check script uses for aggro, threat and retaliation logic. Read from the name; located by signature in libserver, so whether it covers wind-up, in-flight projectiles or only an active order is unverified.", + "source": "generated" + }, + "Script_IsCurrentlyHorizontalMotionControlled": { + "text": "Reports whether the unit's horizontal movement is presently driven by a motion controller rather than normal movement, so script can avoid fighting an active forced-movement effect. Read from the name; located by signature in libserver with no prototype derived, so priority handling is unverified.", + "source": "generated" + }, + "Script_IsCurrentlyVerticalMotionControlled": { + "text": "Reports whether the unit's vertical movement is presently driven by a motion controller, the check script uses before applying its own lift, toss or knock-up. Read from the name; located by signature in libserver only, so the interaction between competing controllers is unverified.", + "source": "generated" + }, + "Script_IsDeniable": { + "text": "Reports whether the subject can currently be denied, that is finished off by its own side instead of the enemy. Read from the name; located by signature in libserver with no prototype derived, so the health thresholds and unit rules it consults are unverified.", + "source": "generated" + }, + "Script_IsPermanent": { + "text": "Reports whether the subject is permanent rather than expiring on a timer, the distinction script uses when deciding to refresh or clear it. Read from the name; located by signature in libserver only, so which duration field it inspects is unverified.", + "source": "generated" + }, + "Script_IsUntargetableFrom": { + "text": "Reports whether the unit cannot be targeted from a given source, letting script skip candidates that targeting rules would reject. Read from the name; located by signature in libserver with no prototype derived, so the source argument's meaning and the rules consulted are unverified.", + "source": "generated" + }, + "Script_LaunchLoot": { + "text": "Launches a loot drop from the subject into the world, the spawn-and-throw step script triggers for item or bounty drops. Read from the name; located by signature in libserver only, so the drop contents, arc and landing rules are unverified.", + "source": "generated" + }, + "Script_OnAbilityUpgrade": { + "text": "Handles the ability-upgrade event so script can react when an ability gains a level, for instance rescaling values or granting linked modifiers. Read from the name; located by signature in libserver with no prototype derived, so the event payload and conditions are unverified.", + "source": "generated" + }, + "Script_OtherAbilitiesAlwaysInterruptChanneling": { + "text": "Reports the channel-behaviour flag asking whether starting another ability breaks this channel unconditionally, which script consults when authoring channelled abilities. Read from the name; located by signature in libserver with no prototype derived, so where the flag is stored and defaulted is unverified.", + "source": "generated" + }, + "Script_PassivesDisabled": { + "text": "Reports whether the unit's passive abilities are currently suppressed, a state script checks before relying on passive effects. Read from the name; located by signature in libserver with no prototype derived, so which suppression sources it accounts for is unverified.", + "source": "generated" + }, + "Script_PayHealthCost": { + "text": "Deducts an ability's health cost from the caster, the payment step script performs when driving a cast by hand. Read from the name; located by signature in libserver only, so whether it validates affordability or can reduce the caster below survivable health is unverified.", + "source": "generated" + }, + "Script_PayManaCost": { + "text": "Deducts an ability's mana cost from the caster, the payment step script performs when driving a cast manually. Read from the name; located by signature in libserver with no prototype derived, so whether it checks affordability first or applies cost reductions is unverified.", + "source": "generated" + }, + "Script_RecordEventActionGrant": { + "text": "Records that an event action was granted, the bookkeeping script performs for seasonal event and reward progression. Read from the name; located by signature in libserver with no prototype derived, so the action identifiers and the storage it writes are unverified.", + "source": "generated" + }, + "Script_RecordEventActionGrantForPrimaryEvent": { + "text": "Records an event action grant scoped to the primary event rather than a named one, so script can log progression without selecting the event explicitly. Read from the name; located by signature in libserver only, so how the primary event is resolved is unverified.", + "source": "generated" + }, + "Script_RemoveHorizontalMotionController": { + "text": "Removes a horizontal motion controller from the unit, releasing scripted control of its lateral movement and returning it to normal movement. Read from the name; located by signature in libserver with no prototype derived, so which controller is removed when several exist is unverified.", + "source": "generated" + }, + "Script_RemoveVerticalMotionController": { + "text": "Removes a vertical motion controller from the unit, ending scripted control of its height and letting it settle back to the ground. Read from the name; located by signature in libserver only, so the removal's effect on an in-flight unit is unverified.", + "source": "generated" + }, + "Script_SetAmmoType": { + "text": "Sets the ammunition type used by the subject, the knob script turns to change what a weapon or unit fires. Read from the name; located by signature in libserver with no prototype derived, so the accepted type encoding and its effects are unverified.", + "source": "generated" + }, + "Script_SetAngularVelocity": { + "text": "Sets the entity's angular velocity, the spin rate script assigns to physics-driven or rotating objects. Read from the name; located by signature in libserver with no prototype derived, so the axis convention, units and whether it works on non-physics entities are unverified.", + "source": "generated" + }, + "Script_SetAttacker": { + "text": "Sets the entity credited as attacker for the subject, the attribution script adjusts so kills and damage are assigned to the intended source. Read from the name; located by signature in libserver only, so how long the attribution persists is unverified.", + "source": "generated" + }, + "Script_SetAttacking": { + "text": "Sets the unit's attacking state, the flag script toggles to mark it as engaged in an attack. Read from the name; located by signature in libserver with no prototype derived, so whether it drives animation, order state or only a stored flag is unverified.", + "source": "generated" + }, + "Script_SetCursorCastTarget": { + "text": "Sets the cursor target for a cast, telling an ability which entity the caster aimed at when script drives casting itself. Read from the name; located by signature in libserver with no prototype derived, so its interaction with cursor position and direction is unverified.", + "source": "generated" + }, + "Script_SetDamageType": { + "text": "Sets the damage type carried by the subject, letting script switch an ability or damage instance between physical, magical and pure classification. Read from the name; located by signature in libserver only, so the encoding it expects and when the change takes effect are unverified.", + "source": "generated" + }, + "Script_SetForceAttackTarget": { + "text": "Forces the unit to attack a specified target, overriding its normal target acquisition until the override is cleared. Read from the name; located by signature in libserver with no prototype derived, so how the override is cleared and how it ranks against orders are unverified.", + "source": "generated" + }, + "Script_SetForceAttackTargetAlly": { + "text": "Forces the unit to attack a specified allied target, the separate override script uses for friendly-fire cases that normal targeting refuses. Read from the name; located by signature in libserver with no prototype derived, so its precedence and clearing rules are unverified.", + "source": "generated" + }, + "Script_SetHasCustomTransmitterData": { + "text": "Sets the flag marking the entity as carrying custom transmitter data, which script raises when it supplies its own network transmit information. Read from the name; located by signature in libserver with no prototype derived, so what the flag changes at transmit time is unverified.", + "source": "generated" + }, + "Script_SetOtherBlocker": { + "text": "Assigns another entity as the subject's blocker, recording what is obstructing it for movement or pathing purposes. Read from the name, which is vague about the relationship's use; located by signature in libserver with no prototype derived, so the semantics are unverified.", + "source": "generated" + }, + "Script_SetTimeUntilRespawn": { + "text": "Sets the remaining time before the subject respawns, the dial script turns to shorten, extend or reset a death timer. Read from the name; located by signature in libserver with no prototype derived, so the time base and whether zero forces an immediate respawn are unverified.", + "source": "generated" + }, + "Script_SetVelocity": { + "text": "Sets an entity's velocity from script, the Script_ prefix marking it as a script-facing binding rather than an internal-only path. Read from the name; whether the vector replaces or adds to existing motion, and which movement systems honour it, are unverified.", + "source": "generated" + }, + "Script_TriggerModifierDodge": { + "text": "Fires the modifier-dodge event on a unit \u2014 the evasion path that makes an incoming attack or projectile miss \u2014 exposed to script by the Script_ prefix. Use it to drive an evade proc from custom game code; the reading comes from the name, so the affected target and trigger conditions are unverified.", + "source": "generated" + }, + "Script_TriggerSpellAbsorb": { + "text": "Fires spell-absorb handling on a unit, the shield behaviour that soaks an incoming targeted spell, exposed to script by the Script_ prefix. Read from the name; which unit absorbs, and whether a charge or cooldown is consumed, are unverified.", + "source": "generated" + }, + "Script_UseResources": { + "text": "Spends a unit's resources for an action \u2014 costs such as mana, gold or health \u2014 from script. Read from the name; which pools are debited and how insufficient resources are reported are unverified.", + "source": "generated" + }, + "SelectSpawnType": { + "text": "Chooses which spawn type or category to use when something is spawned. Read from the name; the inputs that drive the choice and the range of types it can pick are unverified.", + "source": "generated" + }, + "SendBuffRefreshToClients": { + "text": "Pushes a refreshed buff/modifier state out to clients so UI, icons and client-side effects reflect changed modifier data. Reach for it after mutating a modifier server-side; read from the name, so which buff is refreshed and which clients receive it are unverified.", + "source": "generated" + }, + "SetAbilityIndex": { + "text": "Sets the index an ability occupies, its slot position on the owning unit. Read from the name; whether it rearranges anything else or is a plain field write is unverified.", + "source": "generated" + }, + "SetAbsOrigin": { + "text": "Sets an entity's absolute world-space position rather than a position relative to a parent. Use it to teleport or place an entity precisely; read from the name, so side effects such as collision, parenting or interpolation updates are unverified.", + "source": "generated" + }, + "SetAbsScale": { + "text": "Sets an entity's absolute world-space scale rather than a scale relative to a parent. Read from the name; whether it resizes collision bounds or only visual size is unverified.", + "source": "generated" + }, + "SetAbsVelocity": { + "text": "Sets an entity's absolute world-space velocity, replacing any parent-relative value. Read from the name; whether it applies to physics-driven and animation-driven motion alike is unverified.", + "source": "generated" + }, + "SetAcquisitionRange": { + "text": "Sets the radius within which a unit automatically acquires attack targets, so raising it makes a unit engage from further out. Read from the name; the units of the value and any clamping are unverified.", + "source": "generated" + }, + "SetActivated": { + "text": "Sets an activated/deactivated flag on the subject, toggling whether it is currently live. Read from the name alone, so what being activated actually gates here is unverified.", + "source": "generated" + }, + "SetAttackCapability": { + "text": "Sets a unit's attack capability, the melee/ranged/no-attack classification governing how it can attack at all. Read from the name; the accepted values and whether projectile behaviour retunes with it are unverified.", + "source": "generated" + }, + "SetBaseAgility": { + "text": "Sets a hero's base agility attribute, the pre-item, pre-modifier value that growth and bonuses build on. Read from the name; whether armour, attack speed and other derived stats recompute immediately is unverified.", + "source": "generated" + }, + "SetBaseAttackTime": { + "text": "Sets a unit's base attack time, the interval between attacks before attack-speed modifiers are applied. Read from the name; whether an attack already underway adopts the new value is unverified.", + "source": "generated" + }, + "SetBaseHealthRegen": { + "text": "Sets a unit's base health regeneration rate, the value items and modifiers add on top of. Read from the name; the units of the value and when the change takes effect are unverified.", + "source": "generated" + }, + "SetBaseIntellect": { + "text": "Sets a hero's base intelligence attribute, the pre-item, pre-modifier value underlying mana and related derived stats. Read from the name; whether dependent stats refresh immediately is unverified.", + "source": "generated" + }, + "SetBaseManaRegen": { + "text": "Sets a unit's base mana regeneration rate, the value items and modifiers add on top of. Read from the name; the units of the value and when it takes effect are unverified.", + "source": "generated" + }, + "SetBaseMoveSpeed": { + "text": "Sets a unit's base movement speed, before bonuses, slows and percentage modifiers are applied. Read from the name; clamping against minimum and maximum speed limits is unverified.", + "source": "generated" + }, + "SetBaseStrength": { + "text": "Sets a hero's base strength attribute, the pre-item, pre-modifier value that health and related derived stats build on. Read from the name; whether the health pool rescales immediately is unverified.", + "source": "generated" + }, + "SetBotDifficulty": { + "text": "Sets the difficulty level driving a bot's behaviour, useful for scripting mixed-skill bot matches. Read from the name; the scale it expects and which bot systems respond to it are unverified.", + "source": "generated" + }, + "SetBuyBackDisabledByDevilsBargain": { + "text": "Marks buyback as disabled for a player specifically because of the Devil's Bargain effect, blocking the paid instant respawn. Read from the name; whether it is a simple flag with a separate clear path, and how it interacts with other buyback locks, are unverified.", + "source": "generated" + }, + "SetBuybackCooldownTime": { + "text": "Sets the cooldown time before a player may buy back again after respawning by gold. Read from the name; whether the value is an absolute game time or a remaining duration is unverified.", + "source": "generated" + }, + "SetBuybackGoldLimitTime": { + "text": "Sets the time governing the post-buyback gold penalty window, during which a player's earned gold is restricted. Read from the name; the exact penalty it bounds and the time base used are unverified.", + "source": "generated" + }, + "SetCanBeUsedOutOfInventory": { + "text": "Sets whether an item may be used while it is not in an active inventory slot, such as from a backpack or stash. Read from the name; which containers count as out of inventory is unverified.", + "source": "generated" + }, + "SetCanRepick": { + "text": "Sets whether a player is permitted to repick their hero. Read from the name; whether it also governs repick cost or the window in which repicking is allowed is unverified.", + "source": "generated" + }, + "SetCastOnPickup": { + "text": "Sets whether an item casts or consumes itself as soon as a unit picks it up, the behaviour of drop-and-grab consumables. Read from the name; which pickup paths honour the flag is unverified.", + "source": "generated" + }, + "SetChanneling": { + "text": "Sets an ability's channeling state, marking it as currently being channelled. Read from the name; whether it also drives the channel bar and interrupt handling or only records a flag is unverified.", + "source": "generated" + }, + "SetCombineLocked": { + "text": "Sets an item's combine lock, the flag that stops it from being automatically consumed into a recipe. Read from the name; whether the lock applies per item or per stack is unverified.", + "source": "generated" + }, + "SetCursorPosition": { + "text": "Stores the world position the player's cursor indicated for the current order or cast, giving ability code a ground point to work from. Read from the name; whether the value is a raw trace hit or a projected point is unverified.", + "source": "generated" + }, + "SetCursorTargetingNothing": { + "text": "Records that the cursor targeted nothing \u2014 bare ground rather than a unit or other entity \u2014 for the current order or cast. Read from the name; how consumers tell a fresh value from a stale one is unverified.", + "source": "generated" + }, + "SetCustomHealthLabel": { + "text": "Sets a custom text label drawn on a unit's health bar, handy for custom-game counters, gauges and boss phases. Read from the name; whether colour and visibility are carried alongside the text is unverified.", + "source": "generated" + }, + "SetCustomIntParam": { + "text": "Sets a named custom integer parameter on the subject, a general-purpose slot for custom-game data attached to an entity or modifier. Read from the name; where the value is stored and whether it is networked to clients are unverified.", + "source": "generated" + }, + "SetDamage": { + "text": "Sets a damage value on the subject. Read from the name; whether it writes an attack/weapon damage field or an amount on a pending damage record is unverified.", + "source": "generated" + }, + "SetDamageCustom": { + "text": "Stamps a custom damage identifier onto a damage record, so a mod can tag damage with its own type value and branch on that tag later. Read from the name; only a byte signature is derived, so the accepted value range and any side effects are unverified.", + "source": "generated" + }, + "SetDamageForce": { + "text": "Sets the force vector carried by a damage event, the direction and magnitude used to shove the victim. Read from the name; with only a byte signature derived, the coordinate space and any clamping are unverified.", + "source": "generated" + }, + "SetDamagePosition": { + "text": "Sets the world-space point at which a damage event is treated as having landed, which positional effects and directional reactions can key off. Name-level reading; only a byte signature is derived, so the coordinate space and whether it also influences damage direction are unverified.", + "source": "generated" + }, + "SetDroppable": { + "text": "Sets whether an item may be dropped by its owner, the toggle behind items locked to a hero. Read from the name; only a byte signature is derived, so the exact flag and whether it reaches clients are unverified.", + "source": "generated" + }, + "SetFollowRange": { + "text": "Sets the distance a unit tries to keep from the target it is following, useful for tuning escort, courier, or pet spacing. Read from the name; only a byte signature is derived, so units and clamping are unverified.", + "source": "generated" + }, + "SetFrozenCooldown": { + "text": "Freezes or unfreezes a cooldown so it holds at its current remaining time instead of ticking down, the mechanism behind cooldown-pause effects. Read from the name; only a byte signature is derived, so what is held frozen and how it resumes are unverified.", + "source": "generated" + }, + "SetGold": { + "text": "Sets a player's gold total, the direct economy write behind custom rewards and mode-specific starting funds. Read from the name; only a byte signature is derived, so which gold total it writes, and whether it replaces or adjusts, are unverified.", + "source": "generated" + }, + "SetHasRandomed": { + "text": "Sets the flag recording that a player took a random hero rather than picking one, the state that random-related bonus rules consult. Read from the name; only a byte signature is derived, so the flag's owner and lifetime are unverified.", + "source": "generated" + }, + "SetHealthBarOffsetOverride": { + "text": "Overrides the height at which a unit's health bar is drawn, letting a mod raise or lower it for oversized or unusual models. Read from the name; only a byte signature is derived, so the units involved and how the override is cleared are unverified.", + "source": "generated" + }, + "SetHidden": { + "text": "Sets whether an entity is hidden from view, useful for temporarily removing something from the world without deleting it. Read from the name; only a byte signature is derived, so whether it also suppresses collision, targeting, or networking is unverified.", + "source": "generated" + }, + "SetIdleAcquire": { + "text": "Sets whether a unit automatically acquires attack targets while idle, the control behind passive or hold-position behaviour. Read from the name; only a byte signature is derived, so the acquisition range it interacts with is unverified.", + "source": "generated" + }, + "SetInAbilityPhase": { + "text": "Sets the flag marking that an ability is in its cast phase, the window between the cast beginning and the effect firing. Read from the name; only a byte signature is derived, so what the flag gates and when it clears are unverified.", + "source": "generated" + }, + "SetLastBuybackTime": { + "text": "Records the game time of a player's most recent buyback, the stored value that buyback cooldown checks compare against. Read from the name; only a byte signature is derived, so the clock used and whether cooldown length derives from it are unverified.", + "source": "generated" + }, + "SetLocalScale": { + "text": "Sets an entity's local scale, the size multiplier behind growth, shrink, and oversized-boss effects. Read from the name; only a byte signature is derived, so whether hitboxes and collision scale along with the model is unverified.", + "source": "generated" + }, + "SetLuaGameMode": { + "text": "Assigns the Lua-side game mode for the match, the hook a custom mode uses to install its own rules object. Read from the name; only a byte signature is derived, so what it accepts and whether it can be changed mid-match are unverified.", + "source": "generated" + }, + "SetMaterialGroup": { + "text": "Selects which material group a renderable uses, switching a model between its shipped skin or material variants. Read from the name; only a byte signature is derived, so which variants are valid and whether the change reaches clients are unverified.", + "source": "generated" + }, + "SetMoveCapability": { + "text": "Sets a unit's movement capability, the class of locomotion it is permitted, such as ground or flying versus none at all. Read from the name; only a byte signature is derived, so the available capability values are unverified.", + "source": "generated" + }, + "SetNetworkStateChangedRouter": { + "text": "Installs the router an entity uses to report changes to its networked state, presumably the plumbing that flags changed fields for replication. This is a name-only reading with just a byte signature derived, so what gets installed and which entities carry a router are unverified.", + "source": "generated" + }, + "SetOnlyPlayerHeroPickup": { + "text": "Restricts an item so only a player-controlled hero may pick it up, keeping couriers, summons, or other units from collecting it. Read from the name; only a byte signature is derived, so which unit categories are excluded is unverified.", + "source": "generated" + }, + "SetOriginalDamage": { + "text": "Stores the pre-mitigation damage amount on a damage record, preserving the value before reductions and modifiers alter it. Read from the name; only a byte signature is derived, so exactly which stage's value it holds is unverified.", + "source": "generated" + }, + "SetOverheadEffectOffset": { + "text": "Sets the offset applied to the effect drawn above a unit, letting a mod reposition overhead art for unusual model heights. Read from the name; only a byte signature is derived, so the axes involved and their units are unverified.", + "source": "generated" + }, + "SetOverrideCastPoint": { + "text": "Overrides an ability's cast point, the delay between the cast beginning and the effect firing, which is handy for animation-timing tweaks. Read from the name; only a byte signature is derived, so how the override is cleared and whether it survives level changes are unverified.", + "source": "generated" + }, + "SetParticleAlwaysSimulate": { + "text": "Marks a particle system to keep simulating even when it would otherwise be skipped, for instance while off-screen or culled. Read from the name; only a byte signature is derived, so the exact culling it bypasses and the cost of doing so are unverified.", + "source": "generated" + }, + "SetParticleControlEnt": { + "text": "Binds a particle system's control point to an entity so the effect tracks that entity as it moves. Read from the name; only a byte signature is derived, so which attachment and fallback behaviours are supported is unverified.", + "source": "generated" + }, + "SetPlayerID": { + "text": "Assigns the player ID an entity belongs to, the link between a unit or item and its owning player slot. Read from the name; only a byte signature is derived, so what else changes as a result is unverified.", + "source": "generated" + }, + "SetRangedProjectileName": { + "text": "Sets which projectile a unit's ranged attack uses, letting a mod swap attack visuals and travel behaviour per unit. Read from the name; only a byte signature is derived, so how the projectile resource is resolved is unverified.", + "source": "generated" + }, + "SetRefCountsModifiers": { + "text": "Sets whether modifiers are reference-counted, so repeated applications accumulate a count rather than simply replacing or refreshing an existing one. Read from the name; only a byte signature is derived, so what removal does at each count is unverified.", + "source": "generated" + }, + "SetReportedPosition": { + "text": "Sets the position reported for a unit rather than its true origin, for cases where the communicated or displayed location should differ. Read from the name; only a byte signature is derived, so who consumes the reported position is unverified.", + "source": "generated" + }, + "SetRespawnPosition": { + "text": "Sets the world location an entity will respawn at, letting a mod send heroes or units to a custom point on death. Read from the name; only a byte signature is derived, so whether it persists across repeated deaths is unverified.", + "source": "generated" + }, + "SetSellable": { + "text": "Sets whether an item can be sold, the toggle behind unsellable quest, event, or mode-specific items. Read from the name; only a byte signature is derived, so whether it also affects sell-back value or timing is unverified.", + "source": "generated" + }, + "SetShareability": { + "text": "Sets an item's shareability level, controlling whether and how allies may take or use it. Read from the name; only a byte signature is derived, so the available levels and their exact meanings are unverified.", + "source": "generated" + }, + "SetShouldComputeRemainingPathLength": { + "text": "Toggles whether a unit's remaining path length is computed during navigation, a per-unit switch trading a little pathing work for having that distance available. Read from the name; only a byte signature is derived, so where the computed length ends up is unverified.", + "source": "generated" + }, + "SetShouldDoFlyHeightVisual": { + "text": "Toggles the visual height adjustment applied to flying units, letting a mod keep a model at ground level while the unit still moves as a flier, or the reverse. Read from the name; only a byte signature is derived, so the height applied is unverified.", + "source": "generated" + }, + "SetStacksWithOtherOwners": { + "text": "Sets whether a modifier stacks with instances applied by other owners instead of one owner's instance superseding another's. Read from the name; only a byte signature is derived, so how conflicting instances are resolved when disabled is unverified.", + "source": "generated" + }, + "SetStashEnabled": { + "text": "Enables or disables stash access for its owner, flipping the flag that governs whether items can be moved into or out of the stash. Read from the name; the owning class and the exact effect on stash retrieval are not derived here.", + "source": "generated" + }, + "SetStealable": { + "text": "Marks whether something \u2014 most plausibly an ability or item \u2014 may be stolen. Read from the name alone; what the flag is set on, and which steal paths honour it, are unverified.", + "source": "generated" + }, + "SetStolen": { + "text": "Records that an ability or item is in a stolen state, setting the flag that steal-related logic reads. Read from the name; the owning class and any side effects beyond the flag are not derived.", + "source": "generated" + }, + "SetStolenScepter": { + "text": "Sets stolen-scepter state, distinguishing a scepter-granted ability obtained by stealing from one the owner holds outright. Read from the name; the owner and how the flag changes ability behaviour are unverified.", + "source": "generated" + }, + "SetUnitCanRespawn": { + "text": "Sets whether a unit is permitted to respawn, useful for units that should remain dead once killed. Read from the name; the owning class and any interaction with respawn timers are not derived.", + "source": "generated" + }, + "SetUnitName": { + "text": "Assigns a unit's name string, the identifier used for display and lookup. Read from the name; whether it changes a networked field or only server-side state is unverified.", + "source": "generated" + }, + "SetUnitShareMaskForPlayer": { + "text": "Sets a per-player share mask on a unit, a bitmask describing which control and sharing rights a given player has over it. Read from the name; the bit layout and where the mask is enforced are not derived here.", + "source": "generated" + }, + "SetUpgradeRecommended": { + "text": "Marks an ability or item as a recommended next upgrade, a flag suitable for highlighting a suggested level-up in UI. Read from the name; what consumes the flag is unverified.", + "source": "generated" + }, + "ShouldGiveFreeTPOnDeath": { + "text": "Reports whether a dying unit should be granted a free teleport scroll, a predicate behind free-TP-on-death handling. Read from the name; the conditions it weighs are not derived here.", + "source": "generated" + }, + "ShouldIdleAcquire": { + "text": "Reports whether an idle unit should acquire a target on its own, gating auto-acquisition while the unit has no orders. Read from the name; the exact idle criteria are unverified.", + "source": "generated" + }, + "Source2PreInit": { + "text": "Performs an early engine pre-initialization stage in libengine2, before the main startup work. Beyond that staging role the name gives no specifics, so which subsystems it prepares is not established.", + "source": "generated" + }, + "SpawnNextBatch": { + "text": "Spawns the next batch of units in a staged spawn sequence; the nearby string `Failed to Create Stack Buff on unit=%s, isalive=%s` indicates it also applies a stacking buff to spawned units and logs when that application fails. Name-plus-anchor reading; batch size and scheduling are not derived.", + "source": "generated" + }, + "SpeakAbilityConcept": { + "text": "Triggers a spoken response line for an ability-related speech concept, giving heroes voice lines tied to ability events. Read from the name; the concept identifiers and the rules for choosing a line are not derived here.", + "source": "generated" + }, + "SpendCharge": { + "text": "Consumes one charge from a charged item or ability; the nearby `DelayRemoveItem` string indicates that removal of a depleted item is deferred rather than immediate. Name-plus-anchor reading; the charge fields and the exact removal condition are unverified.", + "source": "generated" + }, + "SpendGold": { + "text": "Deducts gold from a player's balance, a debit path for purchases and other gold costs. Read from the name; whether it distinguishes reliable from unreliable gold, or reports failure on insufficient funds, is not derived.", + "source": "generated" + }, + "StacksWithOtherOwners": { + "text": "Reports whether a modifier or aura stacks when applied by different owners instead of collapsing to a single instance. Read from the name; the stacking rule it consults is unverified.", + "source": "generated" + }, + "StopFacing": { + "text": "Clears a unit's active facing order so it stops turning toward a commanded direction or target. Read from the name; which facing state it resets is not derived here.", + "source": "generated" + }, + "TItemSocket::ConvertToByteStream": { + "text": "Serializes an asset-modifier socket's contents into a byte stream, the compact form used to persist or transmit it. Read from the name; it is the write side matching TItemSocket::ParseFromByteStream, though the encoding and buffer ownership are unverified.", + "source": "generated" + }, + "TItemSocket::ConvertToString": { + "text": "Renders an asset-modifier socket's contents as text, the form suited to display, logging, or debug output. Read from the name; the formatting and whether it round-trips are unverified.", + "source": "generated" + }, + "TItemSocket::GetGemDefIndex": { + "text": "Reads the item-definition index of the gem currently occupying the socket, identifying which gem fills it. Read from the name; pair it with TItemSocket::SetGemDefIndex for writes, though the value used for an unfilled socket is unverified.", + "source": "generated" + }, + "TItemSocket::GetRequiredHeroID": { + "text": "Reads the hero ID a gem must match for this socket to accept it, expressing the socket's hero restriction. Read from the name; how an unrestricted socket is represented is unverified.", + "source": "generated" + }, + "TItemSocket::GetRequiredType": { + "text": "Reads the gem type this socket demands, constraining which asset-modifier gems may be inserted. Read from the name; the type enumeration behind the value is unverified.", + "source": "generated" + }, + "TItemSocket::GetSocketType": { + "text": "Reads the socket's own kind on the item, as distinct from what it accepts. Read from the name; contrast it with TItemSocket::GetRequiredType, which concerns the gem restriction rather than the socket's classification, and note both readings rest on the names.", + "source": "generated" + }, + "TItemSocket::IsEmpty": { + "text": "Reports whether the socket currently holds no gem, distinguishing an unfilled socket from a populated one. Read from the name; what internal value counts as empty is unverified.", + "source": "generated" + }, + "TItemSocket::IsTradable": { + "text": "Reports whether the socketed asset-modifier may be traded, a per-socket restriction distinct from the containing item's own tradability. Read from the name; pair it with TItemSocket::SetTradable, though the stored representation is unverified.", + "source": "generated" + }, + "TItemSocket::ParseFromByteStream": { + "text": "Reconstructs an asset-modifier socket's contents from a serialized byte stream, the read side of the socket's persistence format. Read from the name; it expects data in the same encoding produced by TItemSocket::ConvertToByteStream, and its failure behaviour on malformed input is unverified.", + "source": "generated" + }, + "TItemSocket::SetGemDefIndex": { + "text": "Writes the item-definition index of the gem occupying the socket, filling or replacing its contents. Read from the name; whether it validates the gem against the socket's required type or hero restriction is unverified.", + "source": "generated" + }, + "TItemSocket::SetTradable": { + "text": "Sets the socket's tradable flag, marking the socketed asset-modifier as tradable or not. Read from the name; whether it enforces any economy rule or merely records the flag is unverified.", + "source": "generated" + }, + "TItemSocket::ConvertToByteStream": { + "text": "Serializes the autograph socket's contents into a compact byte-stream form suitable for storage or transmission. Read from the name; the buffer layout and what happens on failure are not established here.", + "source": "generated" + }, + "TItemSocket::ConvertToString": { + "text": "Renders the autograph socket's contents as text, the human-readable counterpart to its byte-stream form, useful for logging or inspecting socket state. Read from the name; the exact text format is not established here.", + "source": "generated" + }, + "TItemSocket::CopyItemSocket": { + "text": "Copies another item socket's contents into this autograph socket, duplicating the socketed data rather than aliasing it. Read from the name; what happens when the source holds a differently typed payload is not established here.", + "source": "generated" + }, + "TItemSocket::GetGemDefIndex": { + "text": "Returns the item-definition index of the gem installed in the autograph socket, identifying which gem definition the socket currently records. Read from the name; the value reported for an unfilled socket is not established here.", + "source": "generated" + }, + "TItemSocket::GetImage": { + "text": "Returns the image associated with the autograph socket, the artwork or icon shown when the socket's contents are displayed. Read from the name; which asset path or size variant is selected is not established here.", + "source": "generated" + }, + "TItemSocket::GetItemType": { + "text": "Returns the item-type identifier describing what the autograph socket holds, letting callers classify the socketed content. Read from the name; the type enumeration and its values are not established here.", + "source": "generated" + }, + "TItemSocket::GetRequiredHeroID": { + "text": "Returns the hero ID the socket's contents are restricted to, the constraint tying an autograph to a specific hero. Read from the name; the value used when no hero restriction applies is not established here.", + "source": "generated" + }, + "TItemSocket::GetRequiredItemLoadoutSlot": { + "text": "Returns the loadout slot an item must occupy for this autograph socket's contents to apply. It carries the string anchor MAlternateSemanticName, indicating the backing field is also exposed under an alternate schema name; the slot encoding itself is not established here.", + "source": "generated" + }, + "TItemSocket::GetRequiredType": { + "text": "Returns the required-type constraint recorded on the autograph socket, describing what kind of content the socket will accept. Read from the name; the set of type values is not established here.", + "source": "generated" + }, + "TItemSocket::GetSocketType": { + "text": "Returns the socket-type identifier for this autograph socket, letting callers tell it apart from other socket specializations when handling sockets generically. Read from the name; the type constants are not established here.", + "source": "generated" + }, + "TItemSocket::HasUnremovableGem": { + "text": "Reports whether the socket holds a gem that cannot be taken out; the literal string gem not removable sits in the function and matches that reading. Use it before offering to clear or re-gem a socket; the precise condition that marks a gem unremovable is not established here.", + "source": "generated" + }, + "TItemSocket::IsEmpty": { + "text": "Reports whether the autograph socket currently holds nothing, distinguishing an unfilled socket from a filled one. Read from the name; what counts as empty for a partially populated payload is not established here.", + "source": "generated" + }, + "TItemSocket::IsTradable": { + "text": "Reports whether the autograph socket's contents are tradable, the flag governing whether the socketed data restricts trading. Read from the name; the value assumed when tradability was never explicitly set is not established here.", + "source": "generated" + }, + "TItemSocket::ParseFromByteStream": { + "text": "Populates the autograph socket by decoding a serialized byte stream, the read side of its binary form. Read from the name; behaviour on truncated or malformed input is not established here.", + "source": "generated" + }, + "TItemSocket::ParseFromString": { + "text": "Populates the autograph socket by parsing a text representation of its contents, the read side of its string form. Read from the name; the accepted grammar and error reporting are not established here.", + "source": "generated" + }, + "TItemSocket::Precache": { + "text": "Requests up-front loading of the assets the autograph socket's contents reference, so they are resident before the socket is displayed or used. Read from the name; no prototype is derived, so which resources are precached and when is unverified.", + "source": "generated" + }, + "TItemSocket::SetGemDefIndex": { + "text": "Stores a gem definition index on the autograph socket, installing or replacing which gem definition it records. Read from the name; whether the index is validated against known definitions is not established here.", + "source": "generated" + }, + "TItemSocket::SetRequiredHeroID": { + "text": "Sets the hero-ID restriction carried by the autograph socket. The libstdc++ anchor basic_string::_S_construct null not valid shows a std::string is built from the supplied value, so passing a null character pointer is invalid rather than a way to clear the restriction.", + "source": "generated" + }, + "TItemSocket::SetRequiredItemLoadoutSlot": { + "text": "Sets which loadout slot the autograph socket's contents require. The libstdc++ anchor basic_string::_S_construct null not valid shows a std::string is constructed from the supplied value, so a null character pointer is not a valid way to clear the requirement.", + "source": "generated" + }, + "TItemSocket::SetRequiredType": { + "text": "Sets the required-type constraint on the autograph socket, defining what content the socket will accept. Read from the name; whether out-of-range types are rejected is not established here.", + "source": "generated" + }, + "TItemSocket::SetTradable": { + "text": "Sets the tradable flag on the autograph socket's contents, marking them as tradable or not. Read from the name; whether the flag also affects the host item is not established here.", + "source": "generated" + }, + "TItemSocket::ConvertToByteStream": { + "text": "Serializes the color socket's contents into a compact byte-stream form for storage or transmission. Read from the name; the buffer layout and failure behaviour are not established here.", + "source": "generated" + }, + "TItemSocket::ConvertToString": { + "text": "Renders the color socket's contents as text, the human-readable counterpart to its byte-stream form and handy for logging socket state. Read from the name; the exact text format is not established here.", + "source": "generated" + }, + "TItemSocket::GetGemDefIndex": { + "text": "Returns the item-definition index of the gem installed in the color socket, identifying which gem definition it currently records. Read from the name; the value reported for an unfilled socket is not established here.", + "source": "generated" + }, + "TItemSocket::GetRequiredType": { + "text": "Returns the required-type constraint recorded on the color socket, describing what kind of content it will accept. Read from the name; the set of type values is not established here.", + "source": "generated" + }, + "TItemSocket::GetSocketType": { + "text": "Returns the socket-type identifier for this color socket, letting callers distinguish it from other socket specializations when handling sockets generically. Read from the name; the type constants are not established here.", + "source": "generated" + }, + "TItemSocket::IsEmpty": { + "text": "Reports whether the color socket currently holds nothing, distinguishing an unfilled socket from a filled one. Read from the name; what counts as empty for a partially populated payload is not established here.", + "source": "generated" + }, + "TItemSocket::IsTradable": { + "text": "Reports whether the color socket's contents are tradable, the flag governing whether the socketed data restricts trading. Read from the name; the value assumed when tradability was never explicitly set is not established here.", + "source": "generated" + }, + "TItemSocket::ParseFromByteStream": { + "text": "Populates the color socket by decoding a serialized byte stream, the read side of its binary form. Read from the name; behaviour on truncated or malformed input is not established here.", + "source": "generated" + }, + "TItemSocket::ParseFromString": { + "text": "Populates the color socket by parsing a text representation of its contents, the read side of its string form. Read from the name; the accepted grammar and error reporting are not established here.", + "source": "generated" + }, + "TItemSocket::Precache": { + "text": "Requests up-front loading of the assets the color socket's contents reference, so they are resident before the socket is displayed or used. Read from the name; no prototype is derived, so which resources are precached and when is unverified.", + "source": "generated" + }, + "TItemSocket::SetGemDefIndex": { + "text": "Stores a gem definition index on the color socket, installing or replacing which gem definition it records. Read from the name; whether the index is validated against known definitions is not established here.", + "source": "generated" + }, + "TItemSocket::SetRequiredType": { + "text": "Sets the required-type constraint on the color socket, defining what content it will accept. Read from the name; whether out-of-range types are rejected is not established here.", + "source": "generated" + }, + "TItemSocket::SetTradable": { + "text": "Sets the tradable flag on the color socket's contents, marking them as tradable or not. Read from the name; whether the flag also affects the host item is not established here.", + "source": "generated" + }, + "TItemSocket::ConvertToByteStream": { + "text": "Serializes this effect socket into a byte-stream representation for storage or transfer. Read from the name; the exact encoding and where the bytes are written are not established by this data.", + "source": "generated" + }, + "TItemSocket::ConvertToString": { + "text": "Produces a text representation of the effect socket, suitable for logging or text-based item records. Read from the name; the output format is not established here.", + "source": "generated" + }, + "TItemSocket::GetGemDefIndex": { + "text": "Reads the definition index of the gem socketed into this effect socket, identifying which gem item occupies it. Read from the name; the storage location and the value reported for an unoccupied socket are unverified.", + "source": "generated" + }, + "TItemSocket::GetRequiredType": { + "text": "Reports the required type of this socket, meaning the category of gem it will accept. Read from the name; the enumeration behind the value is not established.", + "source": "generated" + }, + "TItemSocket::GetSocketType": { + "text": "Reports which kind of socket this record is, distinguishing the effect specialization from other socket variants. Read from the name; the type enumeration is not established by this data.", + "source": "generated" + }, + "TItemSocket::IsEmpty": { + "text": "Tests whether the effect socket currently holds no gem, the usual guard before offering or performing an insert. Read from the name; what exactly counts as empty is not established.", + "source": "generated" + }, + "TItemSocket::IsTradable": { + "text": "Reports whether this effect socket permits trading, useful for gating economy actions on an item. Read from the name; whether the flag describes the socket or the gem within it is unverified.", + "source": "generated" + }, + "TItemSocket::ParseFromByteStream": { + "text": "Populates the effect socket by decoding a serialized byte-stream representation. Read from the name; the stream layout and the behaviour on malformed input are unverified.", + "source": "generated" + }, + "TItemSocket::ParseFromString": { + "text": "Populates the effect socket by parsing a text representation of its state. Read from the name; the accepted format and error handling are not established.", + "source": "generated" + }, + "TItemSocket::SetGemDefIndex": { + "text": "Assigns the definition index of the gem occupying this effect socket, changing which gem the socket holds. Read from the name; whether the index is validated against the socket's required type is unverified.", + "source": "generated" + }, + "TItemSocket::SetRequiredType": { + "text": "Sets the category of gem this effect socket will accept. Read from the name; whether it rejects a value incompatible with an already-socketed gem is not established.", + "source": "generated" + }, + "TItemSocket::SetTradable": { + "text": "Sets the tradable flag on this effect socket. Read from the name; whether the change propagates to the owning item is not established by this data.", + "source": "generated" + }, + "TItemSocket::ConvertToByteStream": { + "text": "Serializes this empty-socket record into a byte-stream representation for storage or transfer. Read from the name; the encoding is not established by this data.", + "source": "generated" + }, + "TItemSocket::ConvertToString": { + "text": "Produces a text representation of the empty-socket record, suitable for logging or text-based item records. Read from the name; the output format is unverified.", + "source": "generated" + }, + "TItemSocket::CopyItemSocket": { + "text": "Copies socket state from another item socket into this one, the operation you want when duplicating an item or transferring its socket layout. Read from the name; which fields are copied, and whether the source must be the same specialization, are not established.", + "source": "generated" + }, + "TItemSocket::GetDescription": { + "text": "Resolves the socket's description through the localization token `Econ_Socket_%s_Desc`, so the displayed text lives in the localization files rather than in the socket record. What fills the substitution is not established by this data.", + "source": "generated" + }, + "TItemSocket::GetGemDefIndex": { + "text": "Reads the gem definition index recorded for this socket entry. Read from the name; on the empty specialization the reported value plausibly denotes no gem, which this data does not confirm.", + "source": "generated" + }, + "TItemSocket::GetItemType": { + "text": "Reports the item type recorded for this socket entry. Read from the name; the enumeration used and how it relates to the socket's required type are not established.", + "source": "generated" + }, + "TItemSocket::GetName": { + "text": "Resolves the socket's display name through the localization token `Econ_Socket_%s_Name`, so names come from the localization files rather than from the socket record. What fills the substitution is not established by this data.", + "source": "generated" + }, + "TItemSocket::GetRequiredHeroID": { + "text": "Reports the hero ID this socket entry is restricted to, letting callers gate socket use to a single hero. Read from the name; the value used when there is no restriction is unverified.", + "source": "generated" + }, + "TItemSocket::GetRequiredItemLoadoutSlot": { + "text": "Reports the loadout slot this socket requires, resolved against the item definitions in `scripts/items/unencrypted/items_master.txt`. Read from that anchor plus the name; how the slot is looked up in the file is not established.", + "source": "generated" + }, + "TItemSocket::GetRequiredType": { + "text": "Reports the required type of this socket entry, meaning the category of gem it accepts. Read from the name; the enumeration behind the value is not established.", + "source": "generated" + }, + "TItemSocket::GetSocketType": { + "text": "Reports which socket specialization this record is. Read from the name; the type enumeration is not established by this data.", + "source": "generated" + }, + "TItemSocket::IsTradable": { + "text": "Reports whether this socket entry permits trading, useful for gating economy actions on the owning item. Read from the name; the backing flag is not established.", + "source": "generated" + }, + "TItemSocket::ParseFromByteStream": { + "text": "Populates this socket record by decoding a serialized byte-stream representation. Read from the name; the stream layout and the behaviour on malformed input are unverified.", + "source": "generated" + }, + "TItemSocket::ParseFromString": { + "text": "Populates this socket record by parsing a text representation of its state. Read from the name; the accepted format and error handling are not established.", + "source": "generated" + }, + "TItemSocket::Precache": { + "text": "Precaches the resources a socket entry needs so they are resident before the item is used in a match. Read from the name; no prototype is derived for this entry, so what it precaches and when is unverified.", + "source": "generated" + }, + "TItemSocket::SetGemDefIndex": { + "text": "Assigns the gem definition index recorded on this socket entry. Read from the name; whether the value is validated, and what happens on the empty specialization, are not established.", + "source": "generated" + }, + "TItemSocket::SetTradable": { + "text": "Sets the tradable flag on this socket entry. Read from the name; whether the change propagates to the owning item is not established by this data.", + "source": "generated" + }, + "TItemSocket::ConvertToByteStream": { + "text": "Serializes the spectator socket's contents into a compact byte-stream form, the counterpart of TItemSocket::ParseFromByteStream. Use it when persisting or transmitting socket state; the reading comes from the name, so the exact encoding and buffer handling are unverified.", + "source": "generated" + }, + "TItemSocket::ConvertToString": { + "text": "Renders the spectator socket's contents as text, pairing with TItemSocket::ParseFromString for a human-readable round trip. Handy for logging or text-backed storage; read from the name, so the produced format is unverified.", + "source": "generated" + }, + "TItemSocket::CopyItemSocket": { + "text": "Copies socket contents from another item socket into this one, so a spectator socket can be duplicated rather than rebuilt field by field. Read from the name; whether the copy replaces existing contents wholesale is unverified.", + "source": "generated" + }, + "TItemSocket::GetGemDefIndex": { + "text": "Reports the item-definition index of the gem sitting in the socket, the value written by TItemSocket::SetGemDefIndex. Use it to identify what a spectator socket holds; read from the name, so the value used for an empty socket is unverified.", + "source": "generated" + }, + "TItemSocket::GetImage": { + "text": "Fetches the image asset associated with the socket's current gem, for presenting the socket in UI. Read from the name; the asset form and how a variant is chosen are unverified.", + "source": "generated" + }, + "TItemSocket::GetRequiredType": { + "text": "Reports the gem type this socket will accept, i.e. the constraint on what can be inserted. Read from the name; how that requirement is encoded, and what an unconstrained socket reports, are unverified.", + "source": "generated" + }, + "TItemSocket::GetSocketType": { + "text": "Reports the socket's own type category, which for this instantiation is the spectator flavour of item socket. Read from the name, so the enumeration behind the value is unverified.", + "source": "generated" + }, + "TItemSocket::IsEmpty": { + "text": "Reports whether the socket currently holds no gem, the natural check before attempting an insertion or when deciding what to draw. Read from the name; what counts as empty for a partially initialised socket is unverified.", + "source": "generated" + }, + "TItemSocket::IsTradable": { + "text": "Reports whether the socket's contents are tradable, reading back the flag that TItemSocket::SetTradable writes. Read from the name; whether the answer also depends on the contained gem is unverified.", + "source": "generated" + }, + "TItemSocket::ParseFromByteStream": { + "text": "Populates the socket from a serialized byte stream, the inverse direction of TItemSocket::ConvertToByteStream. Use it when restoring socket state from storage or the wire; read from the name, so behaviour on malformed input is unverified.", + "source": "generated" + }, + "TItemSocket::ParseFromString": { + "text": "Populates the socket from its text representation, the inverse direction of TItemSocket::ConvertToString. Read from the name; the accepted syntax and how parse failures are reported are unverified.", + "source": "generated" + }, + "TItemSocket::Precache": { + "text": "Preloads the resources a spectator socket needs, such as the gem image, so they are resident before the socket is displayed or used. Read from the name and no prototype is derived, so exactly what is precached, and when, is unverified.", + "source": "generated" + }, + "TItemSocket::SetGemDefIndex": { + "text": "Sets which gem definition occupies the socket, the value later read back by TItemSocket::GetGemDefIndex. Read from the name; whether it validates the index against TItemSocket::GetRequiredType is unverified.", + "source": "generated" + }, + "TItemSocket::SetTradable": { + "text": "Sets the socket's tradable flag, the state reported by TItemSocket::IsTradable. Read from the name; whether it merely stores the flag or enforces any economy rule is unverified.", + "source": "generated" + }, + "TItemSocket::ConvertToByteStream": { + "text": "Serializes the strange socket's contents into a byte-stream form, the counterpart of TItemSocket::ParseFromByteStream. Use it when persisting or transmitting socket state; read from the name, so the encoding and buffer handling are unverified.", + "source": "generated" + }, + "TItemSocket::ConvertToString": { + "text": "Renders the strange socket's contents as text, pairing with TItemSocket::ParseFromString. Useful for logs or text-backed storage; the reading comes from the name, so the produced format is unverified.", + "source": "generated" + }, + "TItemSocket::CopyItemSocket": { + "text": "Copies socket contents from another item socket into this strange socket, letting you clone socket state instead of setting each value. Read from the name; whether existing contents are fully replaced is unverified.", + "source": "generated" + }, + "TItemSocket::GetGemDefIndex": { + "text": "Reports the item-definition index of the gem in this strange socket, the value written by TItemSocket::SetGemDefIndex. Read from the name, so what is reported for an unoccupied socket is unverified.", + "source": "generated" + }, + "TItemSocket::GetImage": { + "text": "Fetches the image asset tied to the socket's current gem, for showing the socket in UI. Read from the name; the asset form and variant selection are unverified.", + "source": "generated" + }, + "TItemSocket::GetItemType": { + "text": "Reports the item type recorded for this strange socket, a separate notion from the socket's own category given by TItemSocket::GetSocketType. Read from the name, so the encoding of the type value is unverified.", + "source": "generated" + }, + "TItemSocket::GetRequiredHeroID": { + "text": "Reports the hero ID an item must match for this strange socket's requirement to be met, useful when filtering which items a socket applies to. Read from the name; the sentinel used when no hero is required is unverified.", + "source": "generated" + }, + "TItemSocket::GetRequiredItemLoadoutSlot": { + "text": "Reports the loadout slot an item must occupy to satisfy this socket, and the MAlternateSemanticName anchor marks the value as also exposed under a second semantic name, so it may surface in schema-driven tooling under a different identifier. The slot encoding itself is read from the name and unverified.", + "source": "generated" + }, + "TItemSocket::GetRequiredType": { + "text": "Reports the type this strange socket requires of what goes into it. Read from the name; how the requirement is encoded, and what an unconstrained socket reports, are unverified.", + "source": "generated" + }, + "TItemSocket::GetSocketType": { + "text": "Reports the socket's own type category, here the strange flavour of item socket. Read from the name, so the enumeration behind the value is unverified.", + "source": "generated" + }, + "TItemSocket::IsTradable": { + "text": "Reports whether the strange socket's contents are tradable, reading back what TItemSocket::SetTradable writes. Read from the name; whether the contained gem also influences the answer is unverified.", + "source": "generated" + }, + "TItemSocket::ParseFromByteStream": { + "text": "Populates the strange socket from a serialized byte stream, the inverse direction of TItemSocket::ConvertToByteStream. Use it when restoring socket state; read from the name, so behaviour on malformed input is unverified.", + "source": "generated" + }, + "TItemSocket::ParseFromString": { + "text": "Populates the strange socket from its text representation, the inverse direction of TItemSocket::ConvertToString. Read from the name; the accepted syntax and how failures are signalled are unverified.", + "source": "generated" + }, + "TItemSocket::Precache": { + "text": "Preloads the resources a strange socket needs, such as its gem image, so they are ready before the socket is shown or used. Read from the name and no prototype is derived, so what it precaches and when is unverified.", + "source": "generated" + }, + "TItemSocket::SetGemDefIndex": { + "text": "Sets which gem definition occupies this strange socket, the value read back by TItemSocket::GetGemDefIndex. Read from the name; whether it checks the index against TItemSocket::GetRequiredType is unverified.", + "source": "generated" + }, + "TItemSocket::SetTradable": { + "text": "Sets the strange socket's tradable flag, the state reported by TItemSocket::IsTradable. Read from the name; whether it simply stores the flag or applies any rule is unverified.", + "source": "generated" + }, + "TSListTests::CListOps::IsEmpty": { + "text": "Reports whether the list this test harness exercises currently holds no elements. Read from the name; the owning class is implied by the name rather than established by the data, so the exact container and what counts as empty under concurrent access are unverified.", + "source": "generated" + }, + "TSListTests::CListOps::Pop": { + "text": "Removes an element from the list the test harness drives and hands it back to the caller. Read from the name; the owning class is implied by the name, so the removal end and the behaviour on an empty list are unverified.", + "source": "generated" + }, + "TSListTests::CListOps::Push": { + "text": "Adds an element to the list the test harness drives. Read from the name; the owning class is implied by the name, so where the element lands and what thread-safety it assumes are unverified.", + "source": "generated" + }, + "TSListTests::CListOps::Validate": { + "text": "Checks the list's internal structure for consistency, the kind of invariant assertion a test harness runs after a burst of pushes and pops. Read from the name; the owning class is implied by the name, so what it inspects and how a failure surfaces are unverified.", + "source": "generated" + }, + "TSListTests::CQueueOps::IsEmpty": { + "text": "Reports whether the queue this test harness exercises currently holds no entries. Read from the name; the owning class is implied by the name, so the exact container and what counts as empty under concurrent access are unverified.", + "source": "generated" + }, + "TSListTests::CQueueOps::Pop": { + "text": "Takes an entry off the queue the test harness drives and returns it, in the first-in-first-out sense the queue naming implies. Read from the name; the owning class is implied by the name, so the behaviour when the queue is empty is unverified.", + "source": "generated" + }, + "TSListTests::CQueueOps::Push": { + "text": "Enqueues an element into the queue the test harness drives. Read from the name; the owning class is implied by the name, so where the element lands and what thread-safety it assumes are unverified.", + "source": "generated" + }, + "TSListTests::CQueueOps::Validate": { + "text": "Checks the queue's internal consistency, the invariant assertion a test harness runs after a burst of enqueue and dequeue traffic. Read from the name; the owning class is implied by the name, so what it inspects and how a failure surfaces are unverified.", + "source": "generated" + }, + "TimeUntilNextAttack": { + "text": "Reports how much time remains before a unit may attack again, the attack-cooldown remainder useful for pacing and prediction logic. Read from the name; the time units and the cooldown source are not derived.", + "source": "generated" + }, + "UnmountWorldVPK": { + "text": "Unmounts a world VPK archive in libworldrenderer, dropping filesystem access to that world's packed content. Read from the name; what triggers the unmount and its effect on already-loaded resources are unverified.", + "source": "generated" + }, + "UpdateTeamSlot": { + "text": "Assigns or moves a player into a team slot; the warning string `CDOTA_PlayerResource::UpdateTeamSlot desired slot %d for player %d on team %d was already taken!` shows a requested slot is refused when occupied and the collision is logged. Anchored to that string; the fallback slot choice is not derived.", + "source": "generated" + }, + "UpgradeAbility": { + "text": "Applies a level-up to an ability, the server-side path for spending a skill point on it. Read from the name; validation such as point availability and level caps is not derived here.", + "source": "generated" + }, + "ValidateStringFormatSpecifiers": { + "text": "Checks a format string's specifiers for validity, a tier0 guard against malformed or mismatched printf-style formatting. Read from the name; the checks performed and the behaviour on failure are unverified.", + "source": "generated" + }, + "VerifySingleChunk": { + "text": "Verifies one chunk of file data in the stdio filesystem, a per-chunk integrity check for packed or streamed content. Read from the name; the checksum scheme and failure handling are not derived.", + "source": "generated" + }, + "VfxInit": { + "text": "Initializes VFX handling inside libmaterialsystem2, preparing the material system's effect and shader-effect machinery for use. Read from the name; the specific resources it sets up are not established here.", + "source": "generated" + }, + "WasKilledPassively": { + "text": "Reports whether a unit's death came from a passive source rather than an active attack or ability, useful when attributing kills or gating on-kill effects. Read from the name; the rule that classifies a death as passive is not derived.", + "source": "generated" + }, + "WhoSelectedHero": { + "text": "Identifies which player picked a given hero, a lookup for hero-to-player attribution during draft and spawn. Read from the name; the identifier form and how an unpicked hero is reported are unverified.", + "source": "generated" + }, + "WillReincarnate": { + "text": "Reports whether a dying unit is going to revive itself instead of staying dead, a predicate for reincarnation-style effects. Read from the name; the conditions it checks are not derived here.", + "source": "generated" + }, + "google::protobuf::DynamicMessageFactory::GetPrototype": { + "text": "Hands back the shared default instance for a message type assembled at runtime from a descriptor, the object you copy from when building messages whose C++ class was never compiled in. The owning class is implied by the name, so the lookup and caching behaviour behind it are unverified.", + "source": "generated" + }, + "google::protobuf::DynamicMessageFactory::~DynamicMessageFactory": { + "text": "Destroys the factory and releases the runtime-built prototypes it owns, so dynamic messages made from it must not outlive it. The class is implied by the name, and the ownership rules beyond destruction are unverified.", + "source": "generated" + }, + "google::protobuf::FatalException::what": { + "text": "Supplies the human-readable message text carried by a fatal protobuf exception, which is the string you log when catching one at a mod boundary. The class is implied by the name, and the wording and lifetime of that text are unverified.", + "source": "generated" + }, + "google::protobuf::FatalException::~FatalException": { + "text": "Destroys a fatal protobuf exception object and frees the message storage it holds. The class is implied by the name, and beyond destruction no further purpose is indicated.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintBool": { + "text": "Emits the text-format rendering of a boolean field value into protobuf's human-readable output, and is the hook to override when you want custom text for booleans. The class is implied by the name, so the exact output spelling is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintBytes": { + "text": "Emits the text-format rendering of a bytes field, escaping non-printable octets so binary payloads survive a human-readable dump. The class is implied by the name, and the exact escaping scheme is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintDouble": { + "text": "Emits the text-format rendering of a double-precision field value, deciding how much precision reaches the dump. The class is implied by the name, so the formatting and rounding choices are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintEnum": { + "text": "Emits the text-format rendering of an enum field, normally the symbolic value name rather than the raw number. The class is implied by the name, and the fallback used for values outside the enum is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintFieldName": { + "text": "Emits the field label that precedes a value in text-format output, the override point when you want fields renamed or decorated in a dump. The class is implied by the name, and the separators it writes around the label are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintFloat": { + "text": "Emits the text-format rendering of a single-precision float field value. The class is implied by the name, so precision and formatting choices are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintInt32": { + "text": "Emits the text-format rendering of a signed 32-bit integer field value into the human-readable dump. The class is implied by the name, and formatting details are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintInt64": { + "text": "Emits the text-format rendering of a signed 64-bit integer field value into the human-readable dump. The class is implied by the name, and formatting details are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintMessageEnd": { + "text": "Writes the closing delimiter that ends a nested submessage in text-format output, the counterpart to google::protobuf::TextFormat::FieldValuePrinter::PrintMessageStart. The class is implied by the name, and the exact characters and indentation it emits are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintMessageStart": { + "text": "Writes the opening delimiter that introduces a nested submessage in text-format output, giving you control over how nesting looks in a dump. The class is implied by the name, and the exact characters and indentation it emits are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintString": { + "text": "Emits the text-format rendering of a string field, quoted and escaped for the human-readable dump. The class is implied by the name, and the exact quoting and escaping rules are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintUInt32": { + "text": "Emits the text-format rendering of an unsigned 32-bit integer field value into the human-readable dump. The class is implied by the name, and formatting details are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::PrintUInt64": { + "text": "Emits the text-format rendering of an unsigned 64-bit integer field value into the human-readable dump. The class is implied by the name, and formatting details are unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::FieldValuePrinter::~FieldValuePrinter": { + "text": "Destroys a text-format value printer, releasing whatever state a custom subclass added on top of the base printer. The class is implied by the name, and beyond destruction no further purpose is indicated.", + "source": "generated" + }, + "google::protobuf::TextFormat::Parser::ParserImpl::ParserErrorCollector::AddError": { + "text": "Records a parse failure raised while reading protobuf text format, carrying the location and message so a caller learns where the input went wrong. The class is implied by the name, and how the diagnostics are stored or surfaced is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::Parser::ParserImpl::ParserErrorCollector::AddWarning": { + "text": "Records a non-fatal complaint about text-format input, something accepted but suspect, together with its location. The class is implied by the name, and how warnings are stored or surfaced is unverified.", + "source": "generated" + }, + "google::protobuf::TextFormat::Parser::ParserImpl::ParserErrorCollector::~ParserErrorCollector": { + "text": "Destroys the text-format parser's diagnostic collector and releases the accumulated error and warning entries. The class is implied by the name, and beyond destruction no further purpose is indicated.", + "source": "generated" + }, + "google::protobuf::internal::ExtensionSet::flat_begin": { + "text": "Marks the start of the flat array of extension entries held by google::protobuf::internal::ExtensionSet, the point you iterate from when walking extensions attached to a message. Read from the name and matched by byte signature in libanimationsystem at low confidence, so treat both the reading and the address as provisional.", + "source": "generated" + }, + "google::protobuf::internal::ExtensionSet::flat_end": { + "text": "Marks the end of that flat extension-entry array, the stop condition paired with google::protobuf::internal::ExtensionSet::flat_begin when iterating extensions. Read from the name and matched by byte signature in libanimationsystem at low confidence, so verify it against the current build before relying on it.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::BackUp": { + "text": "Pushes back the tail of the chunk just handed out so those bytes are read again next time, letting a parser un-consume what it over-read. The class is implied by the name, and limits on how far you may back up are unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::ByteCount": { + "text": "Reports how many bytes of the backing array have been consumed so far, the position you use for offsets and progress checks. The class is implied by the name, and whether backed-up bytes are excluded from the tally is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::Next": { + "text": "Hands the reader the next contiguous span of the backing array so decoding proceeds without copying the buffer. The class is implied by the name, and chunk sizing plus the behaviour at exhaustion are unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::Skip": { + "text": "Advances the read cursor past a run of bytes without handing them to the caller, useful for jumping over fields you do not decode. The class is implied by the name, and the behaviour when the request runs past the array is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayInputStream::~ArrayInputStream": { + "text": "Tears down the zero-copy reader wrapping a fixed byte array. The class is implied by the name, and whether the underlying array is also released is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayOutputStream::BackUp": { + "text": "Returns the unwritten tail of the span just handed out, so the recorded output length counts only bytes actually produced. The class is implied by the name, and the permitted amount is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayOutputStream::ByteCount": { + "text": "Reports how many bytes have been written into the fixed output array so far, which is how you learn the serialized length. The class is implied by the name, and its interaction with backed-up bytes is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayOutputStream::Next": { + "text": "Hands out the next writable span of the fixed output array so a serializer writes straight into it with no intermediate copy. The class is implied by the name, and what happens once the array fills is unverified.", + "source": "generated" + }, + "google::protobuf::io::ArrayOutputStream::~ArrayOutputStream": { + "text": "Tears down the zero-copy writer over a caller-supplied byte array. The class is implied by the name, and beyond destruction no further purpose is indicated.", + "source": "generated" + }, + "google::protobuf::io::StringOutputStream::BackUp": { + "text": "Returns the unwritten tail of the span just handed out so the target string ends up trimmed to what was really written. The class is implied by the name, and how the string is resized is unverified.", + "source": "generated" + }, + "google::protobuf::io::StringOutputStream::ByteCount": { + "text": "Reports how many bytes have been appended to the target string so far, giving you the serialized length while writing. The class is implied by the name, and the baseline it counts from is unverified.", + "source": "generated" + }, + "google::protobuf::io::StringOutputStream::Next": { + "text": "Supplies the next writable block of the stream's destination string buffer so protobuf serialization can write directly into it without an intermediate copy. The StringOutputStream class is implied by the name and not established by this data, so buffer sizing and growth behaviour are unverified.", + "source": "generated" + }, + "google::protobuf::io::StringOutputStream::~StringOutputStream": { + "text": "Tears down a string-backed output stream, releasing the wrapper's own state once serialization into the target string is finished. The StringOutputStream class is implied by the name; as a destructor, any behaviour beyond cleanup is not established here.", + "source": "generated" + }, + "google::protobuf::io::ZeroCopyOutputStream::AllowsAliasing": { + "text": "Reports whether the output stream accepts aliased writes, where a caller-owned buffer is referenced rather than copied into the stream. The ZeroCopyOutputStream class is implied by the name and the reading is name-level, so treat it as a capability query paired with google::protobuf::io::ZeroCopyOutputStream::WriteAliasedRaw rather than a verified contract.", + "source": "generated" + }, + "google::protobuf::io::ZeroCopyOutputStream::WriteAliasedRaw": { + "text": "Emits raw bytes into the stream by reference where aliasing is permitted, letting a caller-owned buffer be used directly instead of copied. The ZeroCopyOutputStream class is implied by the name, and the lifetime requirement that such a buffer stays valid is a name-level reading, not established here.", + "source": "generated" + }, + "snappy::ByteArraySource::Available": { + "text": "Reports how many bytes remain unread in a byte-array input source wrapped for the Snappy compression code, letting a caller tell when the input is exhausted. Read from the name and backed by a derived prototype in libserver; useful when feeding your own buffers through Snappy rather than a file or stream.", + "source": "generated" + }, + "snappy::ByteArraySource::Peek": { + "text": "Exposes the bytes currently readable from the byte-array source without consuming them, so the Snappy codec can inspect input in place instead of copying it. Read from the name and backed by a derived prototype in libserver; how much the call makes visible at once is not established here.", + "source": "generated" + }, + "snappy::ByteArraySource::Skip": { + "text": "Advances the byte-array source past a run of bytes, consuming them without handing them to the caller. Read from the name and backed by a derived prototype in libserver; what happens when asked to skip beyond the end of the array is not established here.", + "source": "generated" + }, + "snappy::ByteArraySource::~ByteArraySource": { + "text": "Destructor for a byte-array input source, tearing the wrapper down once a Snappy pass is finished with it. The owning class is implied by the name, and the data does not establish whether it releases the underlying buffer or merely the wrapper.", + "source": "generated" + } + } +} \ No newline at end of file diff --git a/src/abi.rs b/src/abi.rs index ca67059..fe71d5b 100644 --- a/src/abi.rs +++ b/src/abi.rs @@ -24,10 +24,12 @@ //! Known limits (all bias toward UNDER-counting = a missed flag, never a false one): a pure forwarding //! thunk (`jmp Helper`) reads no arg register of its own, so it shapes as `(0,0)`; an argument used //! only inside a jump-table (indirect-branch) case isn't followed, so it can be missed. Both stay -//! stable across builds (a thunk stays a thunk), so they don't manufacture false transitions — the -//! diff's `int==0` low-confidence bucket also absorbs the thunk case. `int_args` is the OBSERVABLE -//! footprint = a lower bound on the declared prototype (a constant-returner reads nothing → `int=0`); -//! that too is stable per function, so the cross-build diff still works. +//! stable across builds (a thunk stays a thunk), so they don't manufacture false transitions. `int_args` +//! is the OBSERVABLE footprint = a lower bound on the declared prototype (a constant-returner reads +//! nothing → `int=0`); that too is stable per function, which is what lets a shape measured in one build +//! be compared against the model's consensus in the next — see `pipeline::AbiSig::differs`, which treats an +//! `Unknown` return class as "no disagreement" for exactly this reason, and the derive-time +//! `FlagReason::AbiDrift` check that reports the survivors. //! //! The lower-bound property is MEASURED, not assumed: Valve's entity-IO datadesc declares hundreds of //! independent handlers to one fixed `void(CEntityInstance*, InputData_t&)` prototype, and every one of @@ -594,10 +596,205 @@ pub fn abi_shape(img: &CodeImage, entry: u64) -> Option { }) } +/// The 16 general-purpose registers as a slot index, sub-registers folded to their 64-bit parent. +/// +/// `pub(crate)` because it is a fixed SysV fact, not per-pass tuning: `concmd` and `vscript` index +/// `[_; 16]` arrays by exactly this mapping and each carried its own copy of it. (Unlike `MAX_NAME`, or +/// the two `V` lattices, which differ between those readers deliberately.) +pub(crate) fn gp_slot(r: Register) -> Option { + let full = r.full_register(); + (full.is_gpr64() && full != Register::RIP).then(|| full as usize - Register::RAX as usize) +} + +/// Registers a `call` destroys — every caller-saved GPR. A pointer that SURVIVES a call is in a +/// callee-saved register, which is exactly how a real `this` is kept across one. +/// +/// ONE list, and every shape of it is derived from this array: [`caller_saved_mask`]'s bitmask, the slot +/// indices [`caller_saved_slots`] hands the `concmd` and `vscript` value trackers, and `pulse`'s two +/// invalidation loops, which read it directly. Nothing transcribes it, because a register present in one +/// copy and missing from another is a tracker that forgets a value the machine kept, or keeps one the +/// machine destroyed — and a fork retargeting this (Windows/MSVC makes RSI and RDI callee-saved) has to +/// change exactly one place. +pub(crate) const CALLER_SAVED: [Register; 9] = [ + Register::RAX, + Register::RCX, + Register::RDX, + Register::RSI, + Register::RDI, + Register::R8, + Register::R9, + Register::R10, + Register::R11, +]; + +fn caller_saved_mask() -> u32 { + CALLER_SAVED + .iter() + .filter_map(|&r| gp_slot(r)) + .fold(0u32, |m, s| m | (1 << s)) +} + +/// [`CALLER_SAVED`] as the `[_; 16]` slot indices the instruction readers clear after a call — the shape +/// `concmd` and `vscript` need, derived once here instead of transcribed into each. +pub(crate) fn caller_saved_slots() -> [usize; 9] { + let mut out = [0usize; 9]; + for (i, &r) in CALLER_SAVED.iter().enumerate() { + out[i] = gp_slot(r).expect("every caller-saved register is a GPR"); + } + out +} + +/// The largest displacement the function reaches through the pointer it was handed in RDI — for a +/// member function, how far into `this` it touches. +/// +/// **What it is for.** Every other check in this project verifies that a locator RESOLVES; none verifies +/// that it resolves to the RIGHT function. This one can, against a fact the SchemaSystem already states +/// offline: a `CFoo::` method reaches its own object through `this`, so every `this + N` it touches must +/// satisfy `N < sizeof(CFoo)`. Reaching past the end means the pointer is not a `CFoo`. +/// +/// **Deliberately conservative, in the same direction as `abi_shape`.** A register stops holding `this` +/// on any write that is not a move from another register already holding it, every caller-saved register +/// is dropped across a `call`, and a path merge keeps only what holds on BOTH paths. So `this` is followed +/// only where it is provably still `this`, and the error direction is a reach that is too SMALL — a missed +/// contradiction rather than a false accusation against a correct entry. +/// +/// Indexed memory operands (`(%rax,%rcx,8)`) are skipped: there the displacement is an array base rather +/// than a field offset, so its magnitude says nothing about the object's size. +pub fn this_reach(img: &CodeImage, entry: u64) -> Option { + const MAX_SPAN: usize = 16 * 1024; + const MAX_STEPS: usize = 6000; + let code = img.code_at(entry)?; + let cap = code.len().min(MAX_SPAN); + let in_span = |t: u64| t >= entry && ((t - entry) as usize) < cap; + let clobber = caller_saved_mask(); + + let mut factory = InstructionInfoFactory::new(); + let mut seen: HashMap = HashMap::new(); + let rdi = 1u32 << gp_slot(Register::RDI)?; + let mut work = vec![(entry, rdi)]; + let mut best: Option = None; + let mut steps = 0usize; + let mut insn = Instruction::default(); + + while let Some((ip, incoming)) = work.pop() { + if !in_span(ip) { + continue; + } + steps += 1; + if steps > MAX_STEPS { + break; + } + // Path merge is INTERSECTION: a register holds `this` here only if it did on every path in. + let held = match seen.get(&ip) { + Some(&prev) => { + let merged = prev & incoming; + if merged == prev { + continue; // nothing new to propagate + } + merged + } + None => incoming, + }; + seen.insert(ip, held); + + let off = (ip - entry) as usize; + let mut dec = Decoder::with_ip(64, &code[off..], ip, DecoderOptions::NONE); + if !dec.can_decode() { + continue; + } + dec.decode_out(&mut insn); + if insn.is_invalid() || insn.len() == 0 { + continue; + } + + // Record every field access made through a register that still holds `this`. + if insn.memory_index() == Register::None + && let Some(slot) = gp_slot(insn.memory_base()) + && held & (1 << slot) != 0 + && (0..insn.op_count()).any(|i| insn.op_kind(i) == OpKind::Memory) + { + let d = insn.memory_displacement64(); + if d < MAX_SPAN as u64 { + best = Some(best.map_or(d, |b: u64| b.max(d))); + } + } + + // Propagate. A plain 64-bit register-to-register move carries `this`; anything else that writes + // a register destroys whatever it held. + let mut next = held; + let is_reg_move = insn.mnemonic() == Mnemonic::Mov + && insn.op_count() == 2 + && insn.op0_kind() == OpKind::Register + && insn.op1_kind() == OpKind::Register + && insn.op0_register().is_gpr64(); + let carried = is_reg_move + .then(|| gp_slot(insn.op1_register())) + .flatten() + .filter(|&s| held & (1 << s) != 0) + .and_then(|_| gp_slot(insn.op0_register())); + for used in factory.info(&insn).used_registers() { + if matches!( + used.access(), + OpAccess::Write | OpAccess::ReadWrite | OpAccess::CondWrite + ) && let Some(s) = gp_slot(used.register()) + { + next &= !(1 << s); + } + } + if let Some(s) = carried { + next |= 1 << s; + } + if insn.flow_control() == FlowControl::Call + || insn.flow_control() == FlowControl::IndirectCall + { + next &= !clobber; + } + + let after = ip + insn.len() as u64; + match insn.flow_control() { + FlowControl::Return + | FlowControl::IndirectBranch + | FlowControl::Exception + | FlowControl::Interrupt => {} + FlowControl::UnconditionalBranch => { + let t = insn.near_branch_target(); + if in_span(t) { + work.push((t, next)); + } + } + FlowControl::ConditionalBranch => { + work.push((after, next)); + let t = insn.near_branch_target(); + if in_span(t) { + work.push((t, next)); + } + } + _ => work.push((after, next)), + } + } + best +} + #[cfg(test)] mod tests { use super::*; + #[test] + fn every_shape_of_the_caller_saved_list_agrees_with_the_array() { + // The invariant `CALLER_SAVED` documents, checked rather than asserted. Both derived shapes are + // computed from the array here, so this can only fail if someone reintroduces a hand-written + // copy — which is exactly the drift that put a raw index list in `vscript` and a second register + // array in `pulse`. + let mask = caller_saved_mask(); + let slots = caller_saved_slots(); + assert_eq!(mask.count_ones() as usize, CALLER_SAVED.len()); + assert_eq!(slots.len(), CALLER_SAVED.len()); + for (&r, &s) in CALLER_SAVED.iter().zip(slots.iter()) { + assert_eq!(gp_slot(r), Some(s), "{r:?} lost its slot index"); + assert_ne!(mask & (1 << s), 0, "{r:?} is missing from the bitmask"); + } + } + // Decode a tiny hand-assembled straight-line function and recover its shape through the REAL // per-instruction helper (`insn_effect`) + the real liveness formula — so a test can't pass while // the production path is wrong. (A single-successor chain; the fixpoint isn't exercised here.) @@ -803,4 +1000,79 @@ mod tests { // ret — no result register written before returning. assert_eq!(shape_of(&[0xC3]).ret_class, RetClass::Void); } + + // ---- this_reach: the identity check's measurement half. Every case here is one the FIELD-tracking + // has to get right for the check to be usable as a rejection rather than a hint. ---- + + fn reach_of(bytes: &[u8]) -> Option { + this_reach(&CodeImage::for_test(0x1000, bytes), 0x1000) + } + + #[test] + fn this_reach_follows_a_move_into_a_callee_saved_register() { + // mov %rdi,%r13 ; cmpb $0,0x7bc(%r13) ; ret + // The shape that matters in practice: the prologue stashes `this` and every field access is + // through the copy, so a tracker that only watches RDI measures nothing. + assert_eq!( + reach_of(&[ + 0x49, 0x89, 0xFD, 0x41, 0x80, 0xBD, 0xBC, 0x07, 0x00, 0x00, 0x00, 0xC3 + ]), + Some(0x7bc) + ); + } + + #[test] + fn this_reach_stops_at_a_reloaded_register() { + // mov 0x10(%rdi),%rdi ; mov 0x110(%rdi),%rax ; ret + // RDI is REDEFINED from memory, so 0x110 is an offset into a different object. Crediting it to + // `this` is exactly the false positive that made an earlier prototype of this check unusable. + assert_eq!( + reach_of(&[ + 0x48, 0x8B, 0x7F, 0x10, 0x48, 0x8B, 0x87, 0x10, 0x01, 0x00, 0x00, 0xC3 + ]), + Some(0x10) + ); + } + + #[test] + fn this_reach_drops_caller_saved_registers_across_a_call() { + // call +0 ; mov 0x200(%rdi),%rax ; ret + // RDI is caller-saved, so after a call it holds whatever the callee left. A read through it is + // not a read of `this`. + assert_eq!( + reach_of(&[ + 0xE8, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x87, 0x00, 0x02, 0x00, 0x00, 0xC3 + ]), + None + ); + } + + #[test] + fn this_reach_keeps_callee_saved_copies_across_a_call() { + // mov %rdi,%rbx ; call +0 ; mov 0x200(%rbx),%rax ; ret + // The counterpart: RBX is callee-saved, so the copy survives and the access IS through `this`. + assert_eq!( + reach_of(&[ + 0x48, 0x89, 0xFB, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x83, 0x00, 0x02, 0x00, + 0x00, 0xC3 + ]), + Some(0x200) + ); + } + + #[test] + fn this_reach_ignores_indexed_operands() { + // mov 0x900(%rdi,%rcx,8),%rax ; ret — an array walk; the displacement is a base, not a field + // offset, so its magnitude says nothing about the object's size. + assert_eq!( + reach_of(&[0x48, 0x8B, 0x84, 0xCF, 0x00, 0x09, 0x00, 0x00, 0xC3]), + None + ); + } + + #[test] + fn this_reach_is_none_when_this_is_never_dereferenced() { + // xor %eax,%eax ; ret — a constant returner touches no object at all. + assert_eq!(reach_of(&[0x31, 0xC0, 0xC3]), None); + } } diff --git a/src/concmd.rs b/src/concmd.rs index 810d9a2..bcf4083 100644 --- a/src/concmd.rs +++ b/src/concmd.rs @@ -29,6 +29,33 @@ //! (it opens by writing the invalid-handle sentinel), a handler is accepted only if it lands in //! executable code, and a name only if it resolves to a plausible string. A layout change yields //! FEWER commands, never wrong ones. +//! +//! # ConVars, the other half of the same surface +//! +//! Convars register the same way and are read by the same pass, which is why they live here rather than in +//! a module of their own — and, more importantly, they share the FCVAR flag space, so [`flag_names`] decodes +//! both. A registration looks like: +//! +//! ```text +//! lea r14, [rip+object] ; the ConVar itself — in .bss, so zero on disk +//! lea rsi, [rip+"mp_maxrounds"] ; the name +//! mov ecx, 0x282100 ; flags (bit 13 replicated, bit 19 release) +//! lea r8, [rip+"max number of rounds…"] ; the help text +//! call +//! ``` +//! +//! **The object is in `.bss`**, so the scan-a-static-record route every other reader here uses is not +//! available: on disk a ConVar is 344 zero bytes, and its name, flags and help exist only as arguments to +//! the constructor call. Reading the call site is not a shortcut, it is the only offline route. +//! +//! The registrar is identified differently from the command one, and the difference is deliberate. A +//! ConVar constructor has no equivalent of the invalid-handle sentinel to recognise it by, so the test is +//! on the CALL SITE's argument shape — a convar-shaped name, prose-or-absent help, a flags word — and then +//! on AGREEMENT: only a call target that presents that shape at `MIN_CONVAR_SITES` or more sites is +//! accepted as a registrar. The doc on `inits_invalid_handle` warns that ranking call targets is wrong, +//! and it is, for the shape it was warning about: "an argument that lands in executable code" fits far too +//! much. Two strings with different character profiles plus a flags word plus a `.bss` pointer, repeated +//! across dozens of sites, is a different order of evidence. use crate::elf::CodeImage; use iced_x86::{ @@ -44,11 +71,6 @@ const RSI: usize = 6; const RDI: usize = 7; const R8: usize = 8; const R9: usize = 9; -/// Caller-saved under SysV: a call destroys any constant we were tracking in these. The `this` a -/// constructor threads through its registrations is callee-saved (rbx, r12-r15), so it survives — which -/// is what makes the member-callback form readable at all. -const CLOBBER: [usize; 9] = [0, RCX, RDX, RSI, RDI, R8, R9, 10, 11]; - /// Longest string accepted as a command name. Names are identifiers; anything longer is not one, so the /// cap doubles as a validity gate. const MAX_NAME: usize = 64; @@ -124,6 +146,39 @@ const FLAG_BITS: [(u32, &str); 12] = [ (28, "clientcmd_can_execute"), ]; +/// CONVAR flag bits. A SEPARATE table from [`FLAG_BITS`], and the separation is not cosmetic. +/// +/// The tempting assumption is that FCVAR is one flag space, so the command table decodes convars too. It +/// does not, and shipping on that assumption mislabelled bit 0 as `linked_concommand` on 185 Dota and 56 CS2 +/// convars — a name that Valve's own dump gives to NONE of them. Whatever transforms the word on the way in +/// (the registrar visibly masks a bit of it), the convar encoding is its own and has to be measured as its +/// own. +/// +/// Derived against Valve's published dumps for BOTH games — `GameTracking-{CS2,Dota2}/DumpSource2/ +/// convars.txt`, 1,939 convars pooled — keeping only bits whose flag holds at 100% precision. Bits 0, 1 and +/// 2 are set often and match nothing cleanly; they stay unnamed and survive in `flags_raw`, which is what +/// that field is for. +const CONVAR_FLAG_BITS: [(u32, &str); 9] = [ + (4, "hidden"), + (7, "archive"), + (8, "notify"), + (13, "replicated"), + (14, "cheat"), + (15, "per_user"), + (17, "dontrecord"), + (19, "release"), + (21, "commandline_enforced"), +]; + +/// The names of the bits set in a CONVAR's flags word that have a measured meaning. +pub fn convar_flag_names(flags: u64) -> Vec<&'static str> { + CONVAR_FLAG_BITS + .iter() + .filter(|(b, _)| flags & (1u64 << b) != 0) + .map(|&(_, n)| n) + .collect() +} + /// The names of the bits set in `flags` that have a measured meaning. Bits without one are omitted here /// and preserved in [`ConsoleCommand::flags`]. pub fn flag_names(flags: u64) -> Vec<&'static str> { @@ -135,10 +190,10 @@ pub fn flag_names(flags: u64) -> Vec<&'static str> { } /// Index 0-15 of a GPR, after widening an 8/16/32-bit name to its 64-bit parent. +/// The 64-bit parent register as a slot index. Thin wrapper over [`crate::abi::gp_slot`] — the mapping is a +/// fixed SysV fact, and this file only narrows it to the `u8` its `[_; 16]` arrays index by. fn gpr(r: Register) -> Option { - let f = r.full_register(); - f.is_gpr64() - .then(|| (f as usize - Register::RAX as usize) as u8) + crate::abi::gp_slot(r).map(|s| s as u8) } /// What a register provably holds. `Sym` is an offset from a value we never learned — a constructor's @@ -173,12 +228,27 @@ impl V { } } +/// End a register's current life, because something has overwritten it. +/// +/// Called by EVERY arm that assigns to a register, not only the catch-all — which is the correction that +/// matters. `mov`, `lea` and `xor` re-point a register just as surely as an unmodelled instruction does, +/// so leaving their epoch alone let a base register be aimed at a second object while stores made against +/// the FIRST still keyed to the same `(register, epoch)` pair — and a `lea rdx,[rbx+0x1c8]` for object B +/// could then match a `mov [rbx+0x1e8],rax` that belonged to object A, attributing one constructor's +/// handler to another's registration. +fn end_life(epoch: &mut [u32; 16], d: u8) { + epoch[d as usize] = epoch[d as usize].saturating_add(1); +} + /// Address of a `this`-relative slot: base register, that register's epoch, displacement. type Slot = (u8, u32, i64); /// One call to a registrar, with what its argument registers held and the `this`-relative constants its /// enclosing function stored. struct Site { + /// The call target — which registrar this site went to. Convar registrars are identified by agreement + /// across their sites, so the target has to survive collection. + target: u64, args: [V; 16], stores: std::sync::Arc>, } @@ -222,25 +292,50 @@ fn inits_invalid_handle(img: &CodeImage, f: u64) -> bool { } /// A plausible console-command name: short, printable, no spaces or quoting. -fn cmd_name(img: &CodeImage, va: u64) -> Option { - let s = img.read_c_string(va)?; - let ok = !s.is_empty() +/// Whether `s` is shaped like a console COMMAND name. +/// +/// Split from the read so a test can call the rule instead of restating it — restating it is how the +/// convar test came to assert this rule while claiming to pin the other one, and would have passed with +/// the two gates swapped. +/// +/// Deliberately looser than [`is_convar_name`]: a command name may lead with punctuation, because the +/// `+bugvoice` / `-bugvoice` on/off pairs are real commands and a convar can never be spelled that way. +fn is_cmd_name(s: &str) -> bool { + !s.is_empty() && s.len() <= MAX_NAME && s.bytes() - .all(|c| c.is_ascii_graphic() && c != b'"' && c != b'%'); - ok.then_some(s) + .all(|c| c.is_ascii_graphic() && c != b'"' && c != b'%') +} + +fn cmd_name(img: &CodeImage, va: u64) -> Option { + let s = img.read_c_string(va)?; + is_cmd_name(&s).then_some(s) } /// Every console command `img` registers. pub fn console_commands(img: &CodeImage) -> Vec { - let mut entries = crate::locate::candidate_entries(img); - entries.extend(img.eh_frame_functions().into_iter().map(|(s, _)| s)); - entries.sort_unstable(); - entries.dedup(); - // Memoised so the prologue test runs once per distinct call target rather than once per call, and so // only registrar calls are ever materialised as a Site. let mut is_reg: HashMap = HashMap::new(); + let sites = collect_sites(img, |img, t, _| { + *is_reg + .entry(t) + .or_insert_with(|| inits_invalid_handle(img, t)) + }); + interpret_commands(img, &sites) +} + +/// Walk every function, constant-propagate the argument registers, and keep the call sites `accept` wants. +/// +/// Single-sourced deliberately: this pass is subtle — the epoch counter, the write-only invalidation, the +/// straight-line reset per function — and two copies of it would drift. The command and convar readers differ +/// only in which calls they keep and how they read the arguments, so that is all `accept` decides. +fn collect_sites( + img: &CodeImage, + mut accept: impl FnMut(&CodeImage, u64, &[V; 16]) -> bool, +) -> Vec { + let entries = crate::locate::function_entries(img); + let mut sites: Vec = Vec::new(); let mut factory = InstructionInfoFactory::new(); @@ -255,7 +350,7 @@ pub fn console_commands(img: &CodeImage) -> Vec { let mut val = [V::Unknown; 16]; let mut epoch = [0u32; 16]; let mut stores: HashMap = HashMap::new(); - let mut found: Vec<[V; 16]> = Vec::new(); + let mut found: Vec<(u64, [V; 16])> = Vec::new(); let mut insn = Instruction::default(); let mut dec = Decoder::with_ip(64, code, start, DecoderOptions::NONE); while dec.can_decode() { @@ -268,13 +363,20 @@ pub fn console_commands(img: &CodeImage) -> Vec { ) { let t = insn.near_branch_target(); - if *is_reg - .entry(t) - .or_insert_with(|| inits_invalid_handle(img, t)) - { - found.push(val); + if accept(img, t, &val) { + found.push((t, val)); } - for c in CLOBBER { + // A call assigns to NINE registers at once, so it ends nine lives — the arm that most + // needs the epoch bump and the one that was missing it. The Lea arm below mints a fresh + // symbolic base for any unknown-valued register, and the store arm keys that base as + // `(reg, epoch, disp)`: without the bump, `rax` after two successive calls is ONE key + // space shared by two objects, where same-displacement stores overwrite each other. + // + // Only the caller-saved nine. The `this` a constructor threads through its registrations + // is callee-saved (rbx, r12-r15) and SURVIVES, which is what makes the member-callback + // form readable at all — so the list comes from `abi`, never from a local transcription. + for c in crate::abi::caller_saved_slots() { + end_life(&mut epoch, c as u8); val[c] = V::Unknown; } continue; @@ -308,6 +410,7 @@ pub fn console_commands(img: &CodeImage) -> Vec { // `lea r,[rip+d]` is a string/global/function address; `lea r,[base+d]` walks to a member. Mnemonic::Lea => { if let Some(d) = gpr(insn.op0_register()) { + end_life(&mut epoch, d); val[d as usize] = if insn.is_ip_rel_memory_operand() { V::Const(insn.ip_rel_memory_address()) } else if insn.memory_index() == Register::None { @@ -324,6 +427,7 @@ pub fn console_commands(img: &CodeImage) -> Vec { } Mnemonic::Mov => { if let Some(d) = gpr(insn.op0_register()) { + end_life(&mut epoch, d); val[d as usize] = match insn.op1_kind() { OpKind::Immediate8to64 | OpKind::Immediate32to64 @@ -342,6 +446,7 @@ pub fn console_commands(img: &CodeImage) -> Vec { Mnemonic::Xor => { if let (Some(d), Some(s)) = (gpr(insn.op0_register()), gpr(insn.op1_register())) { + end_life(&mut epoch, d); val[d as usize] = if d == s { V::Const(0) } else { V::Unknown }; } } @@ -355,8 +460,8 @@ pub fn console_commands(img: &CodeImage) -> Vec { OpAccess::Write | OpAccess::ReadWrite | OpAccess::CondWrite ) && let Some(d) = gpr(ur.register()) { + end_life(&mut epoch, d); val[d as usize] = V::Unknown; - epoch[d as usize] = epoch[d as usize].saturating_add(1); } } } @@ -364,15 +469,20 @@ pub fn console_commands(img: &CodeImage) -> Vec { } if !found.is_empty() { let stores = std::sync::Arc::new(stores); - sites.extend(found.into_iter().map(|args| Site { + sites.extend(found.into_iter().map(|(target, args)| Site { + target, args, stores: stores.clone(), })); } } + sites +} +/// Read command registrations out of collected sites. +fn interpret_commands(img: &CodeImage, sites: &[Site]) -> Vec { let mut out: Vec = Vec::new(); - for s in &sites { + for s in sites { let Some(name) = s.args[RSI].konst().and_then(|v| cmd_name(img, v)) else { continue; }; @@ -426,10 +536,301 @@ pub fn console_commands(img: &CodeImage) -> Vec { out } +/// How many call sites must present the convar argument shape before a target counts as a registrar. +/// +/// This is the whole safety margin for identifying convar registration by shape rather than by a semantic +/// sentinel. A coincidental `(object, name-ish string, int, prose string)` call happens; forty of them to the +/// same target does not. Measured on CS2 libserver the real registrars carry hundreds of sites each, so the +/// bar sits far below the signal and far above the noise. +const MIN_CONVAR_SITES: usize = 12; + +/// A ConVar the module registers, as its registration states it. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ConVar { + /// The console-facing name, e.g. `mp_maxrounds`. + pub name: String, + pub library: String, + /// Valve's own help text; absent when the registration passes none. + pub description: String, + /// Flag bits with a measured meaning, decoded by [`convar_flag_names`] — NOT the command table, whose + /// bit 0 name applies to no convar in either game's published dump. + pub flags: Vec, + /// The raw flags word, kept beside the decoding so a build that repurposes a bit can be re-read rather + /// than silently mis-labelled. Convars set bits commands never do (8 and 21 on CS2), and those have no + /// name yet — this is where they survive. + pub flags_raw: String, + /// Address of the ConVar OBJECT. In `.bss`, so it holds nothing on disk; it is the anchor a runtime + /// walks to reach the live value, and it is what distinguishes two registrations of the same name. + pub addr: String, +} + +/// A plausible convar name: an identifier, lowercase by convention but not required, no spaces or prose. +/// +/// Stricter than [`cmd_name`], which admits any printable run because commands like `+bugvoice` exist. +/// A convar name is always an identifier, and the tighter gate is what keeps prose out of the name slot +/// when the shape test is the only thing standing between a call site and a record. +/// Whether `s` is shaped like a CONVAR name — stricter than [`is_cmd_name`] in both directions: it must +/// LEAD with a letter or underscore, and its body admits only `[A-Za-z0-9_.]`. +/// +/// This gate is the only shape check between a call site and an emitted ConVar record, so it is what keeps +/// prose out of the name slot. +fn is_convar_name(s: &str) -> bool { + !s.is_empty() + && s.len() <= MAX_NAME + && s.chars() + .next() + .is_some_and(|c| c.is_ascii_alphabetic() || c == '_') + && s.bytes() + .all(|c| c.is_ascii_alphanumeric() || c == b'_' || c == b'.') +} + +fn convar_name(img: &CodeImage, va: u64) -> Option { + let s = img.read_c_string(va)?; + is_convar_name(&s).then_some(s) +} + +/// Help text: prose, or nothing. Deliberately permissive about content and strict about being a real +/// string — the point is to separate "this argument is a description" from "this argument is something else +/// that happens to be a pointer". +fn help_text(img: &CodeImage, va: u64) -> Option { + let s = img.read_c_string(va)?; + (!s.is_empty() && s.len() <= 512 && s.is_ascii()).then_some(s) +} + +/// Does this call site look like a ConVar registration? +/// +/// `rsi` a convar-shaped name, `rdi` a non-code address (the object), `rcx` a plausible flags word, and `r8` +/// either help text or absent. Nothing here is sufficient alone; the caller additionally requires agreement +/// across [`MIN_CONVAR_SITES`] sites to the same target. +fn looks_like_convar_site(img: &CodeImage, args: &[V; 16]) -> bool { + let Some(name) = args[RSI].konst() else { + return false; + }; + if convar_name(img, name).is_none() { + return false; + } + // The object: a real address that is NOT code. A ConVar lives in writable data. + match args[RDI].konst() { + Some(o) if o != 0 && !img.is_code(o) => {} + _ => return false, + } + // Flags: a 32-bit word. A pointer-sized value here means this is not the flags argument. + match args[RCX].konst() { + Some(f) if f <= u64::from(u32::MAX) => {} + _ => return false, + } + // Help: present and prose, or genuinely absent. A non-zero value that is not a readable string means + // the fifth argument is something else and this is not the registration shape. + match args[R8] { + V::Const(0) | V::Unknown => true, + V::Const(p) => help_text(img, p).is_some(), + V::Sym(..) => false, + } +} + +/// Functions `f` delegates to — direct calls AND tail jumps. +/// +/// The tail jumps are the point. A convar registrar is a thin wrapper that arranges arguments and then +/// `jmp`s to the core rather than calling it, so a collector that only counts `call` sees a wrapper +/// delegate to nothing and the convergence that identifies the family disappears. Only branches LEAVING the +/// scanned span count as delegation; a jump within it is ordinary control flow. +fn callees(img: &CodeImage, f: u64) -> Vec { + const SPAN: u64 = 0x400; + let end = f.saturating_add(SPAN); + let Some(code) = img.code_range(f, end) else { + return Vec::new(); + }; + let mut out = Vec::new(); + let mut insn = Instruction::default(); + let mut dec = Decoder::with_ip(64, code, f, DecoderOptions::NONE); + while dec.can_decode() { + dec.decode_out(&mut insn); + if !matches!( + insn.op0_kind(), + OpKind::NearBranch16 | OpKind::NearBranch32 | OpKind::NearBranch64 + ) { + continue; + } + let t = insn.near_branch_target(); + let delegates = match insn.flow_control() { + FlowControl::Call => true, + FlowControl::UnconditionalBranch => !(f..end).contains(&t), + _ => false, + }; + if delegates && img.is_code(t) { + out.push(t); + } + } + out.sort_unstable(); + out.dedup(); + out +} + +/// Which of the shape-matching targets are REAL convar registrars. +/// +/// The argument shape alone is not enough, and this is the measurement that says so: on CS2 libserver it +/// matches eleven targets, of which five register convars and six register something else with an +/// identical footprint — animation events, mostly, which are also `(static object, identifier, int, prose)`. +/// Checked against Valve's published convar dump the split is absolute: every one of those eleven targets is +/// either 100% real convars or 0%. So the families ARE separable; the shape just is not what separates them. +/// +/// What separates them is that the real registrars CONVERGE. Four of the five are wrappers that delegate to +/// the fifth, which is itself a registrar — the cvar core. The false family shares no callee with them. So +/// the core identifies itself: it is the candidate called by the most OTHER candidates. Accept it and its +/// callers, reject everything else. On CS2 that yields exactly the five real registrars and 1,159 convars, +/// with zero names absent from Valve's dump. +/// +/// Deliberately NOT keyed off an address, a name, or Valve's dump: all three are per-build inputs this tool +/// exists to avoid. The convergence is a property of the code in front of it. +fn convar_registrars(img: &CodeImage, per_target: &HashMap) -> Vec { + let cands: Vec = per_target + .iter() + .filter(|&(_, &n)| n >= MIN_CONVAR_SITES) + .map(|(&t, _)| t) + .collect(); + let calls: HashMap> = cands.iter().map(|&c| (c, callees(img, c))).collect(); + // How many candidates delegate to each function. The core does NOT have to be a candidate itself: on + // CS2 it happens to take 28 registrations directly, but on Dota the shared core takes none, and + // requiring it to be a candidate found nothing there at all. + let mut inbound: HashMap = HashMap::new(); + for (&from, tos) in &calls { + for t in tos { + if *t != from { + *inbound.entry(*t).or_default() += 1; + } + } + } + // Ties broken by site count then address, so the choice cannot depend on hash order — this feeds a + // byte-reproducible artifact. + let Some((&core, &votes)) = inbound.iter().max_by_key(|&(t, n)| { + ( + *n, + per_target.get(t).copied().unwrap_or(0), + std::cmp::Reverse(*t), + ) + }) else { + return Vec::new(); + }; + // One wrapper proves nothing; a family of them is the signal. Below this the convergence is noise and + // reporting NOTHING is the honest outcome — the profile floor then fails the release loudly. + if votes < 2 { + return Vec::new(); + } + let mut keep: Vec = Vec::new(); + if cands.contains(&core) { + keep.push(core); + } + keep.extend( + cands + .iter() + .copied() + .filter(|c| calls.get(c).is_some_and(|t| t.contains(&core))), + ); + keep.sort_unstable(); + keep.dedup(); + keep +} + +/// Which argument slot holds the FLAGS, for one registrar. +/// +/// It is not the same slot for every registrar, and assuming it was is what first produced convars whose +/// "flags" were `0x99dc60` — a `.rodata` pointer sitting in the slot a different overload uses for +/// something else. The name slot is stable across all of them; nothing else is. +/// +/// Found statistically, because flags REPEAT and pointers do not: across a registrar's sites the flags slot +/// takes a small set of recurring words (`0x4000` alone appears 188 times on CS2), while a slot holding a +/// string or an object address is very nearly unique per site. So the flags slot is the integer-shaped one +/// with the lowest distinct-value ratio — and if nothing is clearly repetitive, this returns `None` and the +/// registrar's convars ship with no decoded flags rather than with invented ones. +fn flags_slot(sites: &[&Site]) -> Option { + const CANDIDATES: [usize; 4] = [RDX, RCX, R8, R9]; + let mut best: Option<(usize, f64)> = None; + for slot in CANDIDATES { + let vals: Vec = sites.iter().filter_map(|s| s.args[slot].konst()).collect(); + // Every value must fit a 32-bit flags word, and the slot must be present on nearly every site. + if vals.len() * 4 < sites.len() * 3 || vals.iter().any(|&v| v > u64::from(u32::MAX)) { + continue; + } + let mut d = vals.clone(); + d.sort_unstable(); + d.dedup(); + let ratio = d.len() as f64 / vals.len() as f64; + if best.is_none_or(|(_, b)| ratio < b) { + best = Some((slot, ratio)); + } + } + // A genuine flags slot repeats heavily. Anything above this is as unique as a pointer, which is what a + // pointer is, and naming its bits would be fabrication. + best.filter(|&(_, r)| r < 0.5).map(|(s, _)| s) +} + +/// Every ConVar `img` registers. +pub fn convars(img: &CodeImage, library: &str) -> Vec { + let sites = collect_sites(img, |img, _, args| looks_like_convar_site(img, args)); + let mut per_target: HashMap = HashMap::new(); + for s in &sites { + *per_target.entry(s.target).or_default() += 1; + } + let registrars = convar_registrars(img, &per_target); + // Resolve the flags slot once per registrar, from all of that registrar's sites. + let flag_of: HashMap> = registrars + .iter() + .map(|&r| { + let mine: Vec<&Site> = sites.iter().filter(|s| s.target == r).collect(); + (r, flags_slot(&mine)) + }) + .collect(); + let mut out: Vec = Vec::new(); + for s in &sites { + if !registrars.contains(&s.target) { + continue; + } + let (Some(name), Some(obj)) = ( + s.args[RSI].konst().and_then(|v| convar_name(img, v)), + s.args[RDI].konst(), + ) else { + continue; + }; + // Absent when this registrar has no identifiable flags slot: no decoded names, and a raw word of + // zero that is honestly empty rather than a guess. + let flags = flag_of + .get(&s.target) + .copied() + .flatten() + .and_then(|slot| s.args[slot].konst()); + out.push(ConVar { + name, + library: library.to_string(), + description: s.args[R8] + .konst() + .filter(|&p| p != 0) + .and_then(|p| help_text(img, p)) + .unwrap_or_default(), + flags: flags + .map(|f| { + convar_flag_names(f) + .into_iter() + .map(str::to_string) + .collect() + }) + .unwrap_or_default(), + flags_raw: flags.map(|f| format!("{f:#x}")).unwrap_or_default(), + addr: format!("{obj:#x}"), + }); + } + // One row per (name, object): the same convar is registered once, but a name can legitimately appear + // twice across libraries and the object is what tells those apart. + out.sort_by(|a, b| a.name.cmp(&b.name).then_with(|| a.addr.cmp(&b.addr))); + out.dedup_by(|a, b| a.name == b.name && a.addr == b.addr); + out +} + #[cfg(test)] mod tests { use super::*; + // ---- command reader ---- + #[test] fn only_measured_flag_bits_are_named() { // bot_add ships 0x80004 = bits 2 and 19. Bit 19 is `release`; bit 2 stays unnamed because no @@ -463,21 +864,70 @@ mod tests { assert_eq!(V::Sym(3, 0, 7).konst(), None); } + #[test] + fn every_arm_that_clobbers_a_register_ends_its_life() { + // The invariant `end_life` documents, checked against the arm that breaks it most cheaply. A + // CALL assigns to nine caller-saved registers at once; leaving their epochs alone made `rax` + // after two successive calls one key space shared by two objects, so a store to `[rax+0x18]` + // made through the FIRST could be read back as a slot of the SECOND — and the member-callback + // recovery ships whatever executable pointer that merged window holds. + let mut epoch = [0u32; 16]; + let clobber = crate::abi::caller_saved_slots(); + let before: Vec = clobber.iter().map(|&c| epoch[c]).collect(); + for c in clobber { + end_life(&mut epoch, c as u8); + } + for (i, &c) in clobber.iter().enumerate() { + assert_eq!( + epoch[c], + before[i] + 1, + "register {c} kept its epoch across a call" + ); + // …and the two runs are therefore distinguishable keys, which is the point. + assert_ne!( + V::Sym(c as u8, before[i], 0x18), + V::Sym(c as u8, epoch[c], 0x18) + ); + } + // A callee-saved register is NOT clobbered: the registration `this` a constructor threads + // through survives the call, which is what the epoch widening was for in the first place. + for saved in [3u8 /* rbx */, 12, 13, 14, 15] { + assert!( + !clobber.contains(&(saved as usize)), + "r{saved} is callee-saved and must survive a call" + ); + } + } + #[test] fn a_command_name_is_an_identifier_not_prose() { - // The gate is applied to a resolved string, so exercise it through the same predicate the - // reader uses by checking the shape rules it encodes. - let ok = |s: &str| { - !s.is_empty() - && s.len() <= MAX_NAME - && s.bytes() - .all(|c| c.is_ascii_graphic() && c != b'"' && c != b'%') - }; - assert!(ok("bot_add")); - assert!(ok("+bugvoice")); // an on/off pair is a real command name - assert!(!ok("")); // an empty string is not a name - assert!(!ok("Adds a bot matching the given criteria.")); // a description - assert!(!ok("%s: no varname specified\n")); // a format string - assert!(!ok(&"x".repeat(MAX_NAME + 1))); + // Calls the shipped rule, for the same reason as the convar test below it. + assert!(is_cmd_name("bot_add")); + assert!(is_cmd_name("+bugvoice")); // an on/off pair is a real command name + assert!(!is_cmd_name("")); // an empty string is not a name + assert!(!is_cmd_name("Adds a bot matching the given criteria.")); // a description (spaces) + assert!(!is_cmd_name("%s: no varname specified\n")); // a format string + assert!(!is_cmd_name(&"x".repeat(MAX_NAME + 1))); + } + + // ---- convar reader ---- + + #[test] + fn a_convar_name_is_stricter_than_a_command_name() { + // CALLS the gate rather than restating it. The previous version of this test re-implemented the + // COMMAND rule and asserted only inputs both rules agree on, so it would have passed with the two + // gates swapped — the exact regression it is named for. + assert!(is_convar_name("sv_cheats")); + assert!(is_convar_name("mp_roundtime_defuse")); + assert!(is_convar_name("_internal.thing")); // leading underscore and a dot are both legal + assert!(!is_convar_name("")); + assert!(!is_convar_name("Set to 1 to enable cheats")); // help text, not a name + assert!(!is_convar_name(&"x".repeat(MAX_NAME + 1))); + + // The DISCRIMINATING cases — the ones that fail if the two gates are confused. A command may lead + // with punctuation (the `+`/`-` on/off pairs); a convar may not, and admits no other punctuation. + assert!(is_cmd_name("+bugvoice") && !is_convar_name("+bugvoice")); + assert!(is_cmd_name("1st_arg") && !is_convar_name("1st_arg")); // digit-led + assert!(is_cmd_name("say/all") && !is_convar_name("say/all")); } } diff --git a/src/elf.rs b/src/elf.rs index 7c63e6b..82e82cf 100644 --- a/src/elf.rs +++ b/src/elf.rs @@ -109,6 +109,21 @@ fn kind_tag_of(sym: &str) -> Option { const PT_GNU_EH_FRAME: u32 = 0x6474_e550; impl CodeImage { + /// A bare image wrapping one executable span — enough for a decoder test to run the REAL analysis + /// over hand-assembled bytes instead of a parallel mock of it. + #[cfg(test)] + pub fn for_test(vaddr: u64, code: &[u8]) -> Self { + Self { + data: code.to_vec(), + exec: vec![(0, vaddr, code.len())], + secs: Vec::new(), + sym_addr: HashMap::new(), + reloc: HashMap::new(), + reloc_by_val: HashMap::new(), + kind_at: HashMap::new(), + } + } + pub fn load(path: &Path) -> Result { let data = std::fs::read(path).with_context(|| format!("read {}", path.display()))?; Self::from_bytes(data) @@ -406,6 +421,16 @@ impl CodeImage { self.data_at(vaddr, 8).map(|b| u64le(b, 0)) } + /// Does a relocation land ON this slot — i.e. is the qword here a POINTER the linker resolved, + /// rather than a compile-time literal? + /// + /// The distinction is what separates two records that are otherwise byte-compatible: a table of + /// `{ name, integer }` pairs and a table of `{ name, pointer }` pairs read identically until you ask + /// whether the second word was relocated. + pub fn is_reloc_slot(&self, vaddr: u64) -> bool { + self.reloc.contains_key(&vaddr) + } + /// Slot vaddrs whose (relocated) pointer value equals `target`. pub fn ptrs_to(&self, target: u64) -> &[u64] { self.reloc_by_val.get(&target).map_or(&[], |v| v.as_slice()) diff --git a/src/lib.rs b/src/lib.rs index 9dc1685..82f07c7 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,11 +5,16 @@ //! out and scraping stdout. //! //! # Supported API surface -//! A fork or embedder calls into these. Every engine entry point takes an explicit `&profile::GameProfile` -//! (there is NO process-global — CS2 and Dota can be derived in the same process): +//! A fork or embedder calls into these. Every engine entry point that needs game-specific knowledge takes +//! an explicit `&profile::GameProfile` — there is NO process-global, so CS2 and Dota can be derived in the +//! same process. (`classify_change_cmd` is the one exception, and takes none because it needs none: it +//! compares two builds of one named library and reads nothing game-specific.) //! - [`pipeline`] — the pure OFFLINE derivation engine (nothing here attaches to a running server): -//! `corpus_model_cmd` (distill the corpus model), `fold_model_cmd` (roll model N → N+1), `backfill_cmd` -//! (cross-build name/offset timelines), plus the `ClassScope` / `CorpusSource` inputs. +//! `corpus_model_cmd` (distill the corpus model, taking a [`pipeline::ClassScope`]), `fold_model_cmd` +//! (roll model N → N+1, over a [`pipeline::CorpusModel`] that [`pipeline::load_model`] reads off disk — +//! the only way to build its first argument), `backfill_cmd` (cross-build name/offset timelines). The +//! derive that consumes a corpus source is reached through `produce::produce_cmd`, which builds one +//! internally from its `--corpus` / `--corpus-model` arguments — `CorpusSource` itself is crate-private. //! - [`produce`] — CI orchestration + the LIVE half (everything that drives a running server): `produce_cmd` //! (the whole per-game build — boots its own bots server for validate-live + typed netvars when a game is //! given), `integration_test_cmd` (the standalone live oracle), `classify_change_cmd` / `filter_corpus_cmd` @@ -20,8 +25,10 @@ //! //! # Low-level engine (implementation detail) //! The modules below are the building blocks the API composes (ELF/RTTI/SchemaSystem readers, the fingerprint -//! metric, the sig/abi machinery, the data-parallel primitive, the name taxonomy). They stay `pub` for the fuzz -//! harness and advanced embedders, but carry NO stability promise — treat them as internal. +//! metric, the sig/abi machinery, the data-parallel primitive). They stay `pub` for the fuzz harness and +//! advanced embedders, but carry NO stability promise — treat them as internal. The name taxonomy is NOT +//! among them: it is crate-private, because the knob a fork retunes is the `GameProfile` vocabulary block +//! those predicates read, not the predicates. // ---- supported API ---- pub mod pipeline; @@ -42,10 +49,15 @@ pub mod pulse; pub mod rtti; pub mod schema; pub mod sig; -pub mod taxonomy; pub mod valvetab; +pub mod vscript; pub mod xref; +// ---- crate-private ---- +// The name taxonomy: every item is `pub(crate)`, so publishing the module published an empty page. The +// per-game vocabulary it reads is the fork-retunable part, and that is already `pub` on `GameProfile`. +mod taxonomy; + // The canonical model + emitters live in the deriver-free `source2rosetta-core` crate; re-export them so // existing `source2rosetta::{model, render}` paths keep resolving. pub use source2rosetta_core::{model, render}; diff --git a/src/live.rs b/src/live.rs index 5c135c3..0bfc685 100644 --- a/src/live.rs +++ b/src/live.rs @@ -1,6 +1,15 @@ -//! Read-only window into a *running* CS2 server's memory — the runtime oracle that verifies the -//! offline derivations against ground truth. No injection, no debugger: just `/proc//mem` (needs -//! ptrace access — same-user with `yama/ptrace_scope=0`, or `CAP_SYS_PTRACE`). +//! Window into a *running* CS2 server — the runtime oracle that verifies the offline derivations against +//! ground truth. Needs ptrace access (same-user with `yama/ptrace_scope=0`, or `CAP_SYS_PTRACE`). +//! +//! **Mostly reading, but not only reading, and the difference is worth stating plainly.** The bulk of this +//! module reads `/proc//mem`. Two things go further: `poke_bytes` writes bytes in with +//! `PTRACE_POKEDATA`, and [`call_remote`] ATTACHES, saves the main thread's registers, builds a call frame +//! and executes a function in the live process before restoring the thread exactly. Both exist because +//! some claims cannot be checked any other way — a lazy-init singleton is zeroed until something calls its +//! accessor — and both are used only against the narrow set of functions the derivation has already +//! measured as safe to call (nullary, `this`-only, no game state). Nothing is injected and nothing +//! persists: the process is left as it was found, and a faulting call is caught and the thread restored +//! rather than allowed to kill the server. //! //! Offline we resolve `.rela.dyn` by hand to recover as-loaded pointer values; the running process is //! the authority on what those values actually are. So reading the same structures live and comparing @@ -37,6 +46,19 @@ fn maps_path(line: &str) -> &str { rest.trim_start() } +/// The scheduler state character from `/proc//stat` (`R`/`S`/`D`/`Z`/`T`/…), or `None` if the process +/// is gone entirely. Parsed from AFTER the final `)`, because the comm field is parenthesised and may itself +/// contain spaces and brackets — splitting the line on whitespace from the left gets this wrong for any +/// process whose name has a space in it. +fn proc_state(pid: u32) -> Option { + let stat = std::fs::read_to_string(format!("/proc/{pid}/stat")).ok()?; + stat[stat.rfind(')')? + 1..] + .split_whitespace() + .next()? + .chars() + .next() +} + impl LiveProcess { pub fn attach(pid: u32) -> Result { let maps = std::fs::read_to_string(format!("/proc/{pid}/maps")) @@ -80,10 +102,30 @@ impl LiveProcess { } } executable.sort_unstable(); + // Distinguish the two ways this fails, because they call for opposite responses and the kernel + // reports BOTH as EACCES. If the process is gone, `/proc/` is gone with it — so check that + // first: a server that CRASHED mid-derive otherwise reads as a permissions problem, and the + // operator goes off tuning `ptrace_scope` for a fault that had nothing to do with it. (Seen: a + // CS2 server crashed in Steam auth and this line blamed ptrace.) let mem = File::open(format!("/proc/{pid}/mem")).with_context(|| { - format!( - "open /proc/{pid}/mem — needs ptrace access (yama ptrace_scope=0 or run as root)" - ) + match proc_state(pid) { + // A crashed child stays a ZOMBIE until the parent reaps it, so `/proc/` still exists + // and only `mem` is unreadable — an existence check alone reports it as a permissions + // fault. Read the state instead. + Some('Z') | None => format!( + "the game process {pid} DIED during the live stage — it is {}, so there is nothing \ + left to read. This is NOT a ptrace-permission problem: check the server's own log \ + and /tmp/dumps for a minidump.", + if proc_state(pid) == Some('Z') { + "a zombie (crashed, not yet reaped)" + } else { + "gone" + } + ), + Some(_) => format!( + "open /proc/{pid}/mem — needs ptrace access (yama ptrace_scope=0 or run as root)" + ), + } })?; Ok(Self { mem, @@ -209,14 +251,110 @@ pub struct CallResult { pub clean_return: bool, } +/// One argument to a remote call. +/// +/// [`Arg::Scratch`] exists because a callee that takes a POINTER needs a structure to point at, and the +/// address of that structure is not known until the call frame is laid out. Naming it relative to the +/// scratch base lets the caller describe "argument 5 points at my blob" without knowing where the blob +/// will land. +#[derive(Clone, Copy)] +pub enum Arg { + Val(u64), + /// `scratch_base + addend`. + Scratch(i64), +} + +/// A blob placed in the target's stack scratch before the call. +pub struct Scratch<'a> { + pub bytes: &'a [u8], + /// `(offset, addend)` — write `scratch_base + addend` as a little-endian u64 at `offset` in the blob. + /// This is how a pointer INSIDE the blob becomes absolute; an array-of-pointers argument is otherwise + /// impossible to build, since every element has to name an address that does not exist yet. + pub relocs: &'a [(usize, i64)], +} + +/// How long an injected call may run before it is abandoned and the thread restored. +/// +/// Generous by design: every call site here is a nullary accessor or a `this`-only query, which returns in +/// microseconds, so a second is four orders of magnitude of headroom and only a genuinely stuck callee +/// reaches it. `clean_return: false` is then the honest verdict — the same one a faulting call gets. +const CALL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(1); + +/// Write `data` into the target at `addr`, a word at a time. +/// +/// A trailing partial word is read back and merged rather than zero-filled: `PTRACE_POKEDATA` writes a +/// whole word, so writing the tail without preserving the bytes past it would clobber memory the caller +/// never asked to touch. +unsafe fn poke_bytes(pid: i32, addr: u64, data: &[u8]) -> Result<()> { + use anyhow::bail; + let mut i = 0usize; + while i < data.len() { + let at = addr + i as u64; + let n = (data.len() - i).min(8); + let mut word = if n == 8 { + [0u8; 8] + } else { + // PEEKDATA returns -1 both for an error and for a word whose value IS -1, so errno is the + // only way to tell them apart and it must be cleared first. + unsafe { *libc::__errno_location() = 0 }; + let cur = unsafe { libc::ptrace(libc::PTRACE_PEEKDATA, pid, at as usize, 0usize) }; + if cur == -1 && errno() != 0 { + bail!("PEEKDATA at {at:#x} failed (errno {})", errno()); + } + (cur as u64).to_le_bytes() + }; + word[..n].copy_from_slice(&data[i..i + n]); + let w = u64::from_le_bytes(word) as usize; + if unsafe { libc::ptrace(libc::PTRACE_POKEDATA, pid, at as usize, w) } < 0 { + bail!("POKEDATA at {at:#x} failed (errno {})", errno()); + } + i += n; + } + Ok(()) +} + /// Call the function at runtime address `func` inside process `pid` with `args` (SysV: up to 6 in /// registers), via ptrace. Attaches, saves the main thread's registers, sets up a call frame whose /// return address is 0 (so the function traps on return, where we read RAX), runs it, then restores /// the thread exactly — the SIGSEGV from the return trap is suppressed. Needs ptrace permission /// (owned child, or same-user with ptrace_scope=0). UNSAFE: only call leaf-ish functions with valid args. pub fn call_remote(pid: i32, func: u64, args: &[u64]) -> Result { + let regs: Vec = args.iter().map(|&v| Arg::Val(v)).collect(); + call_remote_ex(pid, func, ®s, &[], None) +} + +/// [`call_remote`] plus stack arguments and a scratch blob placed in the target. +/// +/// Needed for callees that take more than six integer arguments or a pointer to a structure the caller has +/// to build — neither of which the register-only form can express. +/// +/// **Stack geometry**, descending from the interrupted `rsp`, chosen so three regions cannot collide: +/// the 128-byte red zone is left alone (the interrupted frame lives there); the scratch blob sits at +/// `rsp-1024`; the call frame starts at `rsp-2048`, so the callee's own stack — which grows DOWN from +/// there — can never reach the scratch ABOVE it. Entry keeps SysV's `rsp % 16 == 8`, with the return +/// address at `[rsp]` and stack argument *i* at `[rsp + 8 + 8i]`. +pub fn call_remote_ex( + pid: i32, + func: u64, + regs_in: &[Arg], + stack_in: &[Arg], + scratch: Option>, +) -> Result { use anyhow::bail; let dbg = std::env::var("SOURCE2ROSETTA_DBG").is_ok(); + if regs_in.len() > 6 { + bail!("{} register arguments; SysV has 6", regs_in.len()); + } + if let Some(s) = &scratch { + // The blob lives in the 1 KiB between the frame and the red zone. Refuse rather than silently + // overlap the call frame, which would corrupt the return address mid-call. + if s.bytes.len() > 768 { + bail!( + "scratch blob is {} bytes; the reserved window is 768", + s.bytes.len() + ); + } + } unsafe { if libc::ptrace(libc::PTRACE_ATTACH, pid, 0usize, 0usize) < 0 { bail!( @@ -249,6 +387,31 @@ pub fn call_remote(pid: i32, func: u64, args: &[u64]) -> Result { // If we attached mid-syscall, orig_rax holds the syscall number and the kernel would run its // syscall-restart logic on our injected rip. Setting it to -1 says "no syscall in progress". regs.orig_rax = u64::MAX; + + // Place the scratch blob first: every Arg::Scratch resolves against its base. + let scratch_base = (saved.rsp - 1024) & !0xfu64; + if let Some(s) = &scratch { + let mut blob = s.bytes.to_vec(); + for &(off, addend) in s.relocs { + let Some(dst) = blob.get_mut(off..off + 8) else { + restore(&saved); + bail!( + "scratch reloc at {off} runs past the {}-byte blob", + s.bytes.len() + ); + }; + dst.copy_from_slice(&scratch_base.wrapping_add(addend as u64).to_le_bytes()); + } + if let Err(e) = poke_bytes(pid, scratch_base, &blob) { + restore(&saved); + return Err(e.context(format!("placing scratch at {scratch_base:#x}"))); + } + } + let resolve = |a: Arg| match a { + Arg::Val(v) => v, + Arg::Scratch(addend) => scratch_base.wrapping_add(addend as u64), + }; + let slots = [ &mut regs.rdi as *mut u64, &mut regs.rsi, @@ -257,12 +420,12 @@ pub fn call_remote(pid: i32, func: u64, args: &[u64]) -> Result { &mut regs.r8, &mut regs.r9, ]; - for (i, &a) in args.iter().take(6).enumerate() { - *slots[i] = a; + for (i, &a) in regs_in.iter().enumerate() { + *slots[i] = resolve(a); } - // Scratch stack BELOW the 128-byte redzone so we never corrupt the interrupted frame; write a + // Call frame well below the scratch, so the callee's downward stack growth cannot reach it. Write a // return address of 0 and keep SysV's `rsp % 16 == 8` at function entry. - let mut sp = (saved.rsp - 512) & !0xfu64; + let mut sp = (saved.rsp - 2048) & !0xfu64; sp -= 8; if libc::ptrace(libc::PTRACE_POKEDATA, pid, sp as usize, 0usize) < 0 { restore(&saved); @@ -271,6 +434,17 @@ pub fn call_remote(pid: i32, func: u64, args: &[u64]) -> Result { errno() ); } + // Stack arguments sit immediately above the return address, which is where the callee reads them. + for (i, &a) in stack_in.iter().enumerate() { + let at = sp + 8 + 8 * i as u64; + if libc::ptrace(libc::PTRACE_POKEDATA, pid, at as usize, resolve(a) as usize) < 0 { + restore(&saved); + bail!( + "POKEDATA(stack arg {i}) at {at:#x} failed (errno {})", + errno() + ); + } + } let wrote = libc::ptrace(libc::PTRACE_PEEKDATA, pid, sp as usize, 0usize); regs.rsp = sp; regs.rip = func; @@ -285,10 +459,37 @@ pub fn call_remote(pid: i32, func: u64, args: &[u64]) -> Result { ); } - // Run, absorbing any spurious signals, until the function returns into our null trap. + // Run, absorbing any spurious signals, until the function returns into our null trap — or until + // the deadline. BOUNDED, because the alternative is unbounded: the injected callee is chosen to + // be leaf-ish, but "chosen to be" is not "proven to be", and one that blocks on a lock, a socket + // or a condition variable would park this `waitpid` forever with the tracee STOPPED — hanging a + // CI derive with no output and no timeout above it. A live check that cannot finish is a failed + // live check, not a reason to stop the release from ever being decided. + let deadline = std::time::Instant::now() + CALL_TIMEOUT; loop { libc::ptrace(libc::PTRACE_CONT, pid, 0usize, 0usize); - if libc::waitpid(pid, &mut status, 0) < 0 || !libc::WIFSTOPPED(status) { + // Polled rather than blocking, so the deadline is observable at all. + let waited = loop { + let r = libc::waitpid(pid, &mut status, libc::WNOHANG); + if r != 0 { + break r; + } + if std::time::Instant::now() >= deadline { + break 0; + } + std::thread::sleep(std::time::Duration::from_millis(1)); + }; + if waited == 0 { + // Still RUNNING, so `restore` would fail ESRCH — stop it first, then put it back exactly. + libc::kill(pid, libc::SIGSTOP); + libc::waitpid(pid, &mut status, 0); + restore(&saved); + return Ok(CallResult { + rax: 0, + clean_return: false, + }); + } + if waited < 0 || !libc::WIFSTOPPED(status) { restore(&saved); bail!("target vanished mid-call (status {status:#x})"); } diff --git a/src/locate.rs b/src/locate.rs index ae65d44..86c16d6 100644 --- a/src/locate.rs +++ b/src/locate.rs @@ -17,6 +17,23 @@ use iced_x86::{Decoder, DecoderOptions, FlowControl, OpKind}; use std::collections::BTreeSet; use std::path::{Path, PathBuf}; +/// Every plausible function ENTRY in the image, sorted and deduped: relocation code-pointers (every vtable +/// slot, every stored function pointer) ∪ decoded `call` targets ∪ `.eh_frame` FDE starts. +/// +/// The union is the point, and it is why this is one function rather than four lines repeated. CS2 strips +/// `.eh_frame` from the game code — the FDE list covers the statically-linked runtime tail, roughly 8,327 +/// of libserver's ~70,000 functions — so an FDE-only list misses the entire gameplay region, while a +/// relocation/call-target-only list misses the runtime tail that has no code pointer taken. Six callers +/// need exactly this set: the xref index, the ConVar and VScript readers, the change digest, and both +/// anchor passes. A fork adding PLT or ifunc entries edits here, once. +pub fn function_entries(img: &CodeImage) -> Vec { + let mut entries = candidate_entries(img); + entries.extend(img.eh_frame_functions().into_iter().map(|(s, _)| s)); + entries.sort_unstable(); + entries.dedup(); + entries +} + /// Every plausible function entry address in `img`: relocation values that point into code, plus /// the targets of direct near `call`s found by a linear sweep. Sorted, de-duplicated. pub fn candidate_entries(img: &CodeImage) -> Vec { diff --git a/src/main.rs b/src/main.rs index 8271e0f..24d9da0 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,7 @@ -//! source2rosetta — CLI front-end. A thin clap layer over `source2rosetta::pipeline`: parse args, -//! select the game profile, dispatch to the engine. +//! source2rosetta — CLI front-end. A thin clap layer over BOTH engine halves — +//! `source2rosetta::pipeline` (the offline derivation engine) and `source2rosetta::produce` (CI +//! orchestration plus everything that drives a running server): parse args, select the game profile, +//! dispatch. use anyhow::{Context, Result}; use clap::{Parser, Subcommand}; @@ -53,12 +55,14 @@ enum Cmd { /// Server library to derive from; defaults to the active game's server lib. #[arg(long)] lib: Option, - /// Seconds to wait for the server to come up and bots to spawn alive. + /// Seconds to wait for the server to come up and reach its readiness anchor — an alive bot pawn + /// for a pawn game, a live `ready_class` instance otherwise. #[arg(long, default_value_t = 60)] wait: u64, #[arg(long)] // default resolved from the active game profile at dispatch map: Option, - /// Number of bots to fill the server with. + /// Number of bots to fill the server with. A pawn-less game uses this only to size `-maxplayers`; + /// nothing waits for a bot pawn there. #[arg(long, default_value_t = 9)] bots: u32, /// Optional gamedata json to also validate-live against the running server. @@ -66,23 +70,28 @@ enum Cmd { gamedata: Option, /// Write the validated (kept) gamedata here (with --gamedata) — so this one command owns the /// server AND persists the live-validated result, no separate validate-live needed. - #[arg(long)] + #[arg(long, requires = "gamedata")] out: Option, /// Leave the launched server running instead of killing it after the test. #[arg(long)] keep: bool, /// With --gamedata, also run the LIVE fuzzer against this same server for N randomized probes - /// (0 = off). Runs against the server `produce` already launched; there is no separate command for it. + /// (0 = off). PAWN GAMES ONLY — a pawn-less game runs no live fuzz. Runs against the server THIS + /// command launched: `integration-test` boots its own and does not attach to one `produce` left + /// behind. #[arg(long, default_value_t = 500)] fuzz_iterations: usize, }, /// The whole per-game build in ONE in-memory command: derive → fold → (if `--game-dir` is given) - /// validate-live + typed netvars → fold model, writing the release set (`gamedata-`/`netvars-`/`model-`/ - /// `manifest`) into --out-dir. No per-stage intermediate files. **Pass `--game-dir` for a full, - /// live-validated build; omit it for a fast OFFLINE build (gamedata + model only, no server).** + /// validate-live + typed netvars → merge → fold model, writing the release set + /// (`rosetta-.json` + `manifest.json`, plus `model-.json` when `--corpus-model` was the + /// source — the sidecar is that model rolled N → N+1, so a `--corpus` genesis run writes two files, + /// not three) into --out-dir. No per-stage intermediate files. **Pass `--game-dir` for a full, + /// live-validated build; omit it for a fast OFFLINE build (no server, so no live validation and a + /// `null` schema).** Produce { /// A launchable game install → the FULL build (boots a server for validate-live + typed netvars). - /// OMIT for an offline build (gamedata + model only). The offline/full switch — no separate flag. + /// OMIT for an offline build. The offline/full switch — no separate flag. #[arg(long = "game-dir")] game_dir: Option, /// Dir holding the on-disk libs for make-sig + live validation (defaults to --game-dir, else --target). @@ -91,12 +100,13 @@ enum Cmd { /// Server library to derive from; defaults to the active game's server lib. #[arg(long)] lib: Option, - /// One bundled seed (catalogue + naming sections) — the release form. Replaces the loose - /// --catalogue/--promotable/--candidates/--full-names/--extra-offsets/--extra-sigs flags. + /// One bundled seed (catalogue + naming sections) — the release form. Carries everything the loose + /// --catalogue/--promotable/--candidates/--full-names/--extra-offsets/--extra-sigs flags carry, and + /// CONFLICTS with each of them: pass one form or the other, never a mix. #[arg(long)] seed: Option, /// Function catalogue (loose form; omit when using --seed). - #[arg(long)] + #[arg(long, conflicts_with = "seed")] catalogue: Option, /// Corpus-signal source A: the raw build binaries to fingerprint on the fly. Exactly ONE of /// --corpus / --corpus-model is required (--corpus-model is the production forward-derive path). @@ -104,7 +114,7 @@ enum Cmd { corpus: Option, /// Corpus-signal source B: a distilled `model-.json` — forward-derives from the model + only the /// target binary (no corpus). Also triggers the sidecar fold (model N → N+1). See --corpus. - #[arg(long)] + #[arg(long, conflicts_with = "corpus")] corpus_model: Option, /// The build DIRECTORY to DERIVE gamedata from — the primary input (its libs are searched by name). /// A bare `.so` path is not searched; pass the directory that contains it. REQUIRED. @@ -112,27 +122,31 @@ enum Cmd { target: PathBuf, /// Optional: names eligible for promotion into high_confidence (from the naming producer flow). /// Omit to promote nothing — the catalogue still derives in full. - #[arg(long)] + #[arg(long, conflicts_with = "seed")] promotable: Option, /// Optional: prefiltered per-address context for those names (`{"candidates": [...]}`). Omit for none. - #[arg(long)] + #[arg(long, conflicts_with = "seed")] candidates: Option, /// Optional: the full-slice name universe. When set, the monolith also carries an `experimental` /// tier — the least-filtered inclusion band (every name guess, graded, each with a resolvable /// locator but an UNVERIFIED name). - #[arg(long)] + #[arg(long, conflicts_with = "seed")] full_names: Option, /// Multilib ground-truth vtable offsets to fold as high_confidence — `{lib: [{name,class,slot}]}` /// (e.g. the macOS symbol transfer). Folded directly, bypassing the candidate gate. - #[arg(long)] + #[arg(long, conflicts_with = "seed")] extra_offsets: Option, /// Multilib non-virtual names to fold as sigs — `{lib: [{name,addr}]}`; `make_sig` runs per lib. - #[arg(long)] + #[arg(long, conflicts_with = "seed")] extra_sigs: Option, /// Declared C++ prototypes (`mappings/prototypes.json`) to judge against this build's measured - /// register footprints. Emits `abi-.json`. Static repo input — omit to skip the manifest. + /// register footprints. Static repo input — omit and no function carries a declared prototype. #[arg(long)] prototypes: Option, + /// Authored function descriptions (`mappings/semantics-.json`), folded in beside each + /// function. Static repo input, keyed on the NAME — omit and no function carries one. + #[arg(long)] + semantics: Option, /// Valve's naming for the entity class behind each `PVAL_EHANDLE` Pulse parameter /// (`mappings/ehandle-classes.json`), propagated across the parameters this build's destructor /// addresses prove are the same type. Static repo input — omit and the bindings artifact simply @@ -160,12 +174,12 @@ enum Cmd { /// Distill the whole corpus into a shippable model (vtable-alignment hops + reference fingerprints /// + slot timelines) so derivation needs only the model + the target binary, not the 86 GB corpus. CorpusModel { - /// One bundled seed — the release form; its catalogue section is what gets distilled. Replaces the - /// loose --catalogue (naming sections are ignored here — the model tracks catalogue names only). + /// One bundled seed — the release form; its catalogue section is what gets distilled. CONFLICTS with + /// the loose --catalogue (naming sections are ignored here — the model tracks catalogue names only). #[arg(long)] seed: Option, /// Function catalogue (loose form; omit when using --seed). - #[arg(long)] + #[arg(long, conflicts_with = "seed")] catalogue: Option, #[arg(long)] corpus: PathBuf, @@ -184,11 +198,12 @@ enum Cmd { /// The existing model N (carries the `abi_obs` window the fold re-windows). #[arg(long)] model: PathBuf, - /// One bundled seed — the release form; its catalogue section is folded. Replaces the loose --catalogue. + /// One bundled seed — the release form; its catalogue section is folded. CONFLICTS with the loose + /// --catalogue. #[arg(long)] seed: Option, /// Function catalogue (loose form; omit when using --seed). Must match the model's distill catalogue. - #[arg(long)] + #[arg(long, conflicts_with = "seed")] catalogue: Option, /// The one new build dir to fold in (holds the just-updated libserver.so etc.). #[arg(long)] @@ -228,7 +243,8 @@ enum Cmd { out: Option, }, /// Classify how much a library changed between two builds — the CI branch primitive. Enumerates every - /// function (`.eh_frame`) in each build and compares their bodies with the position-dependent bytes + /// function in each build (relocation code-pointers ∪ decoded call targets ∪ `.eh_frame` starts — + /// the FDE list alone covers ~12% of these binaries) and compares their bodies with the position-dependent bytes /// (RIP-relative displacements + near-branch targets) masked out, so the verdict is shift-invariant: /// a pure layout move (bodies unchanged, addresses shifted) reads as UNCHANGED, unlike a raw byte diff. /// Prints `skip` (nothing meaningful changed → no release), `normal` (an ordinary patch → re-derive) or @@ -249,13 +265,15 @@ enum Cmd { lib: Option, /// Extra `skip` tolerance: a changed-fraction below this also counts as `skip`. Default 0 — /// only a code-IDENTICAL build (0 functions changed) skips, so any real patch re-derives. Raise - /// it (e.g. 0.01) to also skip changes under N%. (Calibration on 339 CS2 pairs: 311 are - /// code-identical, real patches touch <=6 functions / <=0.08%, the 2 toolchain jumps are 34%/53%.) + /// it (e.g. 0.01) to also skip changes under N%. The default is the one setting that does not + /// depend on the calibration below: zero changed functions is zero at any denominator. #[arg(long, default_value_t = 0.0)] skip_below: f64, - /// changed-fraction at or above this = `shift`. Default 0.20 — the CS2 corpus's real patches top - /// out near 0.08% while its two toolchain jumps are 34%/53%, so 20% cleanly separates them with - /// wide margin and (unlike 40%) doesn't misclassify the 34% jump as an ordinary patch. + /// changed-fraction at or above this = `shift`. Default 0.20. Measured over 344 CS2 builds + /// (~70,300 functions each): 82 are code-identical, the 252 ordinary patches run from 0.001% to + /// 17.8% (median 0.12%), and the 9 toolchain jumps start at 22.4% and reach 93.8%. 0.20 sits in + /// that gap — but the gap is ~4.6 points wide, not the wide margin an earlier calibration + /// claimed, so recalibrate before trusting `shift` on another game or a re-cut corpus. #[arg(long, default_value_t = 0.20)] shift_above: f64, /// Emit a machine-readable JSON object instead of the human summary. @@ -277,7 +295,8 @@ enum Cmd { /// code-identity collapses (any real change keeps the build code-distinct). #[arg(long, default_value_t = 0.0)] skip_below: f64, - /// changed-fraction at or above this marks a toolchain shift = an era boundary (default 0.20). + /// changed-fraction at or above this marks a toolchain shift = an era boundary (default 0.20; see + /// `classify-change --shift-above` for what that number was measured against). #[arg(long, default_value_t = 0.20)] shift_above: f64, #[arg(long)] @@ -294,9 +313,11 @@ fn lib_or_default(prof: &profile::GameProfile, lib: Option) -> String { } /// Resolve the catalogue for the model commands (`corpus-model`/`fold-model`) from either a `--seed` bundle -/// (release form) or a loose `--catalogue` file. The seed's catalogue section parses to the same functions as -/// the loose `needed-functions.json`, so the distilled/folded model is identical either way. When a seed is -/// given, its sections unpack under a `.seed` dir beside `out` (as `produce` does beside its out-dir). +/// (release form) or a loose `--catalogue` file — never both; `catalogue` declares the conflict, so the +/// `None` arm here means the flag was genuinely absent. The seed's catalogue section parses to the same +/// functions as the loose `needed-functions.json`, so the distilled/folded model is identical either way. +/// When a seed is given, its sections unpack under a `.seed` dir beside `out` (as `produce` does beside +/// its out-dir). fn model_catalogue( prof: &profile::GameProfile, seed: Option, @@ -367,6 +388,7 @@ fn main() -> Result<()> { extra_offsets, extra_sigs, prototypes, + semantics, ehandle_classes, sig_cap, version, @@ -377,6 +399,9 @@ fn main() -> Result<()> { bots, } => { // derive inputs come from a single --seed bundle (release form) or the loose flags (dev/verify). + // The bundle arm reads NONE of the loose bindings, which is only honest because each of them + // declares `conflicts_with = "seed"` — clap rejects the mix before dispatch rather than letting + // this arm drop an explicitly passed input on the floor. let inputs = match seed { Some(s) => unpack_seed(profile, &s, &out_dir.join(".seed"))?, None => SeedInputs { @@ -406,6 +431,7 @@ fn main() -> Result<()> { extra_offsets: inputs.extra_offsets.as_deref(), extra_sigs: inputs.extra_sigs.as_deref(), prototypes: prototypes.as_deref(), + semantics: semantics.as_deref(), ehandle_classes: ehandle_classes.as_deref(), sig_cap, version: &version, @@ -494,3 +520,50 @@ fn main() -> Result<()> { } } } + +#[cfg(test)] +mod tests { + use super::*; + use clap::CommandFactory; + + /// A dropped input is a silent skip, and this is the one place the CLI could produce one: the `--seed` + /// arms unpack every loose input themselves and never read the loose bindings, so an undeclared + /// conflict means `produce --seed s.json --full-names f.json` runs to exit 0 with `--full-names` + /// ignored — and a monolith with no experimental tier is exactly what a game with no naming harvest + /// legitimately ships, so no collapse floor downstream can tell the two apart. + #[test] + fn a_seed_bundle_refuses_the_loose_inputs_rather_than_ignoring_them() { + Cli::command().debug_assert(); + let parse = |argv: &[&str]| { + let full: Vec<&str> = std::iter::once("source2rosetta") + .chain(argv.iter().copied()) + .collect(); + Cli::try_parse_from(&full) + }; + let refused = |argv: &[&str]| { + assert!( + parse(argv).is_err(), + "accepted, so one of these inputs is silently dropped: {argv:?}" + ); + }; + let produce = ["produce", "--target", "t", "--out-dir", "o", "--seed", "s"]; + for flag in [ + "--catalogue", + "--promotable", + "--candidates", + "--full-names", + "--extra-offsets", + "--extra-sigs", + ] { + refused(&[&produce[..], &[flag, "x"]].concat()); + } + let model = ["--out", "o", "--seed", "s", "--catalogue", "c"]; + refused(&[&["corpus-model", "--corpus", "c"][..], &model].concat()); + refused(&[&["fold-model", "--model", "m", "--build", "b"][..], &model].concat()); + // Either form ALONE still parses — the conflict must not have made the loose form unusable. + assert!(parse(&produce).is_ok()); + let loose = ["--catalogue", "c", "--full-names", "f"]; + let bare = &produce[..produce.len() - 2]; // the same command minus `--seed s` + assert!(parse(&[bare, &loose[..]].concat()).is_ok()); + } +} diff --git a/src/pipeline.rs b/src/pipeline.rs index 461098f..48659bd 100644 --- a/src/pipeline.rs +++ b/src/pipeline.rs @@ -1,7 +1,11 @@ -//! source2rosetta — the derivation/verification engine: catalogue resolution, corpus-model -//! distillation, gamedata folding, live validation, backfill, and change classification. The -//! `source2rosetta` binary is a thin clap front-end over this module (see `main.rs`); keeping the -//! engine in the library lets CI and tests link and call it directly instead of shelling out. +//! The OFFLINE derivation engine: catalogue resolution, corpus-model distillation, gamedata folding, +//! the experimental band, and monolith assembly. Everything here is a pure function of files on disk — +//! **nothing in this module attaches to a running process.** Live validation, the typed schema walk and +//! change classification are `produce`'s, and the split is the design rather than an accident: it is what +//! lets an offline build produce a smaller honest artifact with no server anywhere in sight. +//! +//! The `source2rosetta` binary is a thin clap front-end over this module and `produce` (see `main.rs`); +//! keeping the engine in the library lets CI and tests link and call it directly instead of shelling out. use crate::elf::CodeImage; use crate::locate::{find_file, load_lib}; @@ -44,7 +48,7 @@ type VoteList = Vec<(u64, usize)>; /// Where `gamedata` pulls its cross-build reference signals from — exactly one of the two. #[derive(Clone, Copy)] -pub enum CorpusSource<'a> { +pub(crate) enum CorpusSource<'a> { /// The raw corpus of build binaries (each fingerprinted on the fly). Binaries(&'a Path), /// A distilled corpus model (already parsed) — then only the target binary is read. The caller owns the @@ -158,6 +162,32 @@ fn candidate_libs(prof: &GameProfile, f: &Func) -> Vec { } } +/// Why no pass could produce a locator for `f` — the DETAIL that ships beside its `unresolved` entry. +/// +/// Worth distinguishing rather than saying "not found", because the three cases are different claims and +/// only one of them is about this build. Most of what lands here was never a function: the catalogue is +/// harvested from other people's dumps, and a dumper's own JSON keys (`build_number`, `dwEntityList`, +/// `attack`) arrive looking exactly like names. Reporting those as functions this build failed to locate +/// would be its own kind of lie — the artifact would assert that CS2 has a function called `jump`. +fn unresolvable_because(f: &Func) -> &'static str { + let kinds: Vec = f.variants.iter().map(|v| v.kind).collect(); + if !kinds.is_empty() && kinds.iter().all(|k| *k == VariantKind::Offset) { + // A raw member offset, not a vtable slot — the kind `ContributionKind` deliberately excludes. + return "catalogue carries only `offset` variants — a raw member offset, which this tool does \ + not derive (it derives signatures and VTABLE slots). Often not a function at all."; + } + if !linux_sigs(f).is_empty() && f.library.iter().all(|l| l == "unknown") { + return "signature variants name no library, so there is no image to scan — the harvested source \ + did not record one"; + } + if linux_sigs(f).is_empty() && string_anchors(f).is_empty() { + return "no linux signature, no string anchor and no vtable offset — nothing this build knows \ + how to look for"; + } + "no locator produced by any pass — the signature did not resolve uniquely and no string anchor \ + referenced exactly one function in the target" +} + fn linux_sigs(f: &Func) -> Vec<&Variant> { f.variants .iter() @@ -181,8 +211,20 @@ pub(crate) fn label_of(dir: &Path) -> String { .unwrap_or_else(|| dir.display().to_string()) } -/// Load every library the catalogue references (usually just libserver/libengine2) from a build. -fn preload_images(prof: &GameProfile, funcs: &[Func], dir: &Path) -> HashMap { +/// Load every library the catalogue references (usually just libserver/libengine2) from a build, plus the +/// names that were PRESENT and would not parse. +/// +/// The two failures are not the same fact and must not read the same. A library the catalogue names but +/// this tree does not have is ordinary — `library` is community-sourced and routinely wrong, and +/// `seed-cs2.json` names `client`, `hammer` and `undefined` among others, none of which exist in a +/// dedicated-server tree. A library that IS there and does not parse is a broken input, and every catalogue +/// entry naming it then resolves nowhere and ships as `SigDrifted` — "no unique/recovered signature in +/// target" — asserting that a signature drifted inside a file nobody opened. +fn preload_images( + prof: &GameProfile, + funcs: &[Func], + dir: &Path, +) -> (HashMap, Vec) { let mut wanted: BTreeSet = BTreeSet::new(); for f in funcs { if !linux_sigs(f).is_empty() { @@ -190,14 +232,19 @@ fn preload_images(prof: &GameProfile, funcs: &[Func], dir: &Path) -> HashMap { + images.insert(fname.clone(), img); + } + Err(e) => unreadable.push(format!("{fname} ({e:#})")), } } - images + (images, unreadable) } /// Every distinct address a UNIQUE-matching, de-duplicated era-sig of `f` resolves to in `img`, each mapped @@ -220,23 +267,149 @@ fn scan_sig_hits(f: &Func, img: &CodeImage) -> BTreeMap { votes } +/// Two things the binary states about an address, kept per image so a name can be checked against both. +/// +/// Built once per image set and shared read-only across the resolution threads. Both halves are OFFLINE — +/// the VScript registry constant-propagates out of its initialiser and the SchemaSystem states each class's +/// instance size in static data — so this check runs identically in an offline derive, a live one, and the +/// distill. +struct LibIdentity { + /// Implementation address -> the C++ name Valve's VScript registry registers there. Ground truth: it is + /// the binary naming its own function, not an inference about it. + vscript_at: HashMap, + /// Schema class -> instance size in bytes, as the class states it. + class_size: HashMap, +} + +/// The identity evidence for every preloaded image, keyed by SHORT library name (`server`) — never the +/// file name it was loaded from. See [`Identity::contradiction`] for why that distinction is load-bearing. +pub(crate) struct Identity(HashMap); + +impl Identity { + fn of(images: &HashMap) -> Self { + Identity( + images + .iter() + .map(|(fname, img)| { + let vscript_at = crate::vscript::vscript_functions(img) + .into_iter() + .filter_map(|v| match v.imp { + // Only a plain address identifies a function here; a virtual `Slot` names a + // vtable index, which locates nothing without the class. + Some(crate::vscript::Impl::Addr(a)) if a != 0 => Some((a, v.cpp_name)), + _ => None, + }) + .collect(); + let class_size = schema::enumerate_schema(img) + .into_iter() + .filter(|c| c.size > 0) + .map(|c| (c.name, c.size as u64)) + .collect(); + ( + lib_name_from_file(fname), + LibIdentity { + vscript_at, + class_size, + }, + ) + }) + .collect(), + ) + } + + /// Why `addr` CONTRADICTS `name`, or `None` if it does not. + /// + /// **A conjunction of two independent contradictions, and it needs both.** Either alone is too noisy to + /// reject on, which is the whole reason this is shaped as an AND: + /// + /// - *Valve's registry names it something else.* Alone this rejects real aliases — a dozen CS2 bindings + /// are bound STRAIGHT to the native method rather than through a script wrapper, so `SetAbsOrigin` and + /// `CBaseEntity::SetAbsOrigin` are legitimately one address, as is `ScriptSetSize` / + /// `CBaseModelEntity::SetCollisionBounds` whose names do not even resemble each other. + /// - *The code says it is a different class.* Alone this rejects working locators whose NAME merely + /// carries the wrong class prefix — measured: four `CPathMover::` entries that are really `CFuncMover` + /// setters, and two `CBasePlayerController::` entries that are really `CCSPlayerController`. Those + /// locate correctly; only their qualifier is wrong, and dropping them would lose real call sites. + /// + /// Together they fire on the case where Valve names the address one thing and the machine code agrees it + /// is not the class the catalogue claims. Measured across 3,988 CS2 entries: **exactly one hit**, and it + /// was a genuine defect that had shipped in a release (`CBaseEntity::DispatchTraceAttack`, in fact + /// `CLogicRelay::Trigger`). n=1, so this rejects one entry rather than aborting a release. + fn contradiction(&self, lib: &str, img: &CodeImage, addr: u64, name: &str) -> Option { + // `Identity::of` gives every loaded image an entry, and both call sites key from a file in that + // same map, so a miss here does NOT mean "a library with no evidence" — it means the caller holds + // the wrong FORM of the key, and the `?` this used to be then disabled the entire check without a + // word. That is precisely how it sat dead on the fold path. + // + // NOT a `debug_assert!`: that compiles out in release, and the shipped binary is a release build, + // so the guard would have gone on silently passing in the one configuration that matters. + let Some(lib) = self.0.get(lib) else { + panic!("Identity is keyed by SHORT library name (`server`), got `{lib}`"); + }; + let (class, method) = name.split_once("::")?; + let registered = lib.vscript_at.get(&addr)?; + if names_correspond(registered, method) { + return None; // Valve's name for this address agrees — a direct binding, not a contradiction + } + let size = *lib.class_size.get(class)?; + let reach = abi::this_reach(img, addr)?; + (reach >= size).then(|| { + format!( + "Valve's VScript registry registers {addr:#x} as `{registered}`, and the code reaches \ + `this+{reach}` on a `{class}` of {size} bytes — the address is not this function" + ) + }) + } +} + +/// Whether a VScript-registered C++ name and a catalogue method name are the same function under two +/// spellings. Valve prefixes script-bound wrappers inconsistently (`ScriptSetAbsAngles`, `Script_TakeDamage`, +/// bare `SetAbsOrigin`), so the prefix is stripped before comparing, and containment either way is accepted +/// because the two vocabularies abbreviate differently (`GetEHandle` / `GetRefEHandle`). +fn names_correspond(registered: &str, method: &str) -> bool { + let norm = |s: &str| { + s.trim_start_matches("Script_") + .trim_start_matches("Script") + .to_ascii_lowercase() + }; + let (a, b) = (norm(registered), norm(method)); + !a.is_empty() && !b.is_empty() && (a.contains(&b) || b.contains(&a)) +} + /// The unique address of `f` in the preloaded images, if exactly one variant resolves cleanly. fn locate_addr<'a>( prof: &GameProfile, f: &Func, images: &'a HashMap, +) -> Option<(&'a CodeImage, u64, String)> { + locate_addr_ident(prof, f, images, None) +} + +/// `locate_addr`, refusing an address the binary itself contradicts (see [`Identity::contradiction`]). +/// Passing `None` skips the check, which is what the callers that have no image set to build it from do. +fn locate_addr_ident<'a>( + prof: &GameProfile, + f: &Func, + images: &'a HashMap, + ident: Option<&Identity>, ) -> Option<(&'a CodeImage, u64, String)> { let (img, fname) = candidate_libs(prof, f) .into_iter() .find_map(|fname| images.get(&fname).map(|img| (img, fname)))?; let hits = scan_sig_hits(f, img); - (hits.len() == 1).then(|| { - ( - img, - *hits.keys().next().unwrap(), - lib_name_from_file(&fname), - ) - }) + let [addr] = hits.keys().copied().collect::>()[..] else { + return None; + }; + // Derived ONCE and used for both the identity lookup and the return: the two want the same value, and + // spelling it twice is how they came to disagree — the lookup was passed the FILE name against a map + // keyed by the short one, so it missed on every call and the guard below never rejected anything. + let lib = lib_name_from_file(&fname); + if let Some(id) = ident + && id.contradiction(&lib, img, addr, &f.name).is_some() + { + return None; + } + Some((img, addr, lib)) } /// Every distinct target address a unique-matching era-sig lands on, ranked by how many distinct @@ -261,7 +434,28 @@ fn locate_candidates<'a>( fn load_catalogue(path: &Path) -> Result> { let text = std::fs::read_to_string(path).with_context(|| format!("read {}", path.display()))?; - serde_json::from_str(&text).context("parse catalogue json") + let funcs: Vec = serde_json::from_str(&text).context("parse catalogue json")?; + // A name may appear ONCE. The catalogue is keyed by name everywhere downstream — `gd.entries`, the + // flag lists, the completeness sweep — but the distill walks this Vec, so a repeat pushes that name's + // slot observation twice and gives one function two votes in its own timeline. `gamedata` already + // merges same-named contributions into one `Func`'s variants for exactly this reason; a duplicate + // reaching here means the catalogue itself is malformed, which is an intake error rather than + // something to silently average out. Same posture as `is_iso_date` and the closed `ContributionKind`. + let mut seen: HashSet<&str> = HashSet::with_capacity(funcs.len()); + let dups: Vec<&str> = funcs + .iter() + .map(|f| f.name.as_str()) + .filter(|n| !seen.insert(n)) + .collect(); + ensure!( + dups.is_empty(), + "catalogue {} carries {} duplicate name(s): {}. Every consumer keys on the name, and the distill \ + walks the list — a repeat gives one function two votes in its own slot timeline.", + path.display(), + dups.len(), + dups.join(", ") + ); + Ok(funcs) } /// The two locator kinds a human may contribute. DELIBERATELY not `VariantKind`: that one carries a @@ -685,8 +879,13 @@ fn fold_extra_offsets( addr: Some(String::new()), confidence: Some(e.confidence.as_deref().unwrap_or("high").to_string()), self_named: Some(e.self_named), - by_value: Some(false), - ret_class: Some("ret=?".to_string()), + // NOT stated, because nothing here measured them. `by_value: false` is a SAFETY + // claim — "returns nothing by value, so a naive call is safe" — and this fold has + // only a name and a vtable slot, no address to measure at. The entry's `abi`, which + // `offset_abi_shapes` fills by resolving the slot, is the one statement about this + // function's return that rests on evidence. + by_value: None, + ret_class: None, source: Some(source.to_string()), rtti_class: Some(e.class.clone()), rationale: Some(format!("multilib vtable offset ({elib}, {source})")), @@ -752,6 +951,7 @@ fn fold_extra_sigs( unmakeable += 1; continue; }; + let shape = abi::abi_shape(eimg, addr); t3.insert( e.name.clone(), model::Entry::signature(elib_name.clone(), sig), @@ -762,8 +962,19 @@ fn fold_extra_sigs( addr: Some(e.addr.clone()), confidence: Some(e.confidence.as_deref().unwrap_or("medium").to_string()), self_named: Some(e.self_named), - by_value: Some(false), - ret_class: Some("ret=?".to_string()), + // MEASURED at the address this entry resolves to, not assumed. `by_value` says a + // naive call is safe; asserting `false` for every folded name would vouch for a + // by-value returner, which writes through a hidden pointer the caller never passed. + // Where the function does not decode, both stay `None` — an absent claim. + // THREE-way, not two: a decoded function whose return class is `Unknown` has not + // been shown safe either. `false` is a positive claim — "not a by-value returner, so + // a naive call will not write through a hidden pointer" — and it is only earned by a + // return class the measurement actually settled. + by_value: shape.and_then(|sh| match sh.ret_class { + abi::RetClass::Unknown => None, + c => Some(c == abi::RetClass::ByValue), + }), + ret_class: shape.map(|sh| sh.ret_class.describe().to_string()), source: Some( e.source .as_deref() @@ -793,12 +1004,20 @@ fn fold_extra_sigs( Ok(n) } +// The provenance `source` ids. Declared HERE because this is where they are stamped, and `pub(crate)` +// because `prototypes` reads them back to decide what a name's evidence implies — it used to re-declare +// its own literals "kept in step" by a comment, which is an invariant nothing checks. + /// The provenance `source` id an entity-IO datadesc name ships under. -const VALVE_DATADESC: &str = "valve-datadesc"; +pub(crate) const VALVE_DATADESC: &str = "valve-datadesc"; /// The provenance `source` id prefix a console-command handler ships under; the callback FORM is -/// appended after a colon (`valve-concommand:direct`). Kept in step with `prototypes::VALVE_CONCOMMAND`. -const VALVE_CONCOMMAND: &str = "valve-concommand"; +/// appended after a colon (`valve-concommand:direct`). +pub(crate) const VALVE_CONCOMMAND: &str = "valve-concommand"; + +/// Provenance id for a name the SCRIPT VM registry states. Same class of evidence as the datadesc and +/// console-command tables: the binary names the function and gives its address in one initialiser. +pub(crate) const VALVE_VSCRIPT: &str = "valve-vscript"; /// A console-command handler's gamedata name. The command name is Valve's own string; the prefix marks /// what the entry IS — the handler bound to console command `X` — rather than claiming a C++ symbol we @@ -848,7 +1067,7 @@ fn concmd_int_args(form: concmd::CallbackForm) -> u8 { } /// `PulseValueType_t::PVAL_EHANDLE`. Checkable rather than assumed: the enum is schema-registered, so -/// the `enums` section of `netvars-.json` states the same value. +/// the `schema.enums` section of the shipped artifact states the same value. const PVAL_EHANDLE: i32 = 13; /// `mappings/ehandle-classes.json` — Valve's own naming for the entity class behind each handle @@ -968,20 +1187,28 @@ fn fold_valve_tables( source_build: source_build.to_string(), pulse: 0, pulse_typed: 0, + pulse_callable: 0, entity_inputs: 0, entity_outputs: 0, entity_classes: 0, commands: 0, + convars: 0, + vscript: 0, + vscript_located: 0, + vscript_classed: 0, }, pulse: BTreeMap::new(), entity_inputs: Vec::new(), entity_outputs: Vec::new(), entity_classes: BTreeMap::new(), commands: Vec::new(), + convars: Vec::new(), + vscript: Vec::new(), }, }; let (mut folded, mut ambiguous, mut unmakeable) = (0u32, 0usize, 0u32); let (mut cmd_total, mut cmd_folded, mut cmd_dup, mut cmd_unmakeable) = (0u32, 0u32, 0u32, 0u32); + let mut vscript_folded = 0u32; let (mut cmd_measured, mut cmd_agree) = (0u32, 0u32); let (mut io_measured, mut io_agree) = (0u32, 0u32); let (mut out_resolved, mut out_total) = (0u32, 0u32); @@ -992,12 +1219,23 @@ fn fold_valve_tables( let mut dup_regs = 0u32; let mut dup_conflicts: Vec = Vec::new(); let mut dup_names: BTreeSet = BTreeSet::new(); + let mut unreadable: Vec = Vec::new(); let threads = default_threads(None); for f in prof.libs { - // A profile's lib list is a superset across builds and games, so an absent library is normal. - let Ok(img) = load_lib(build, f) else { - continue; + // A profile's lib list is a superset across builds and games, so an ABSENT library is normal and + // silent. A library that is present and does not PARSE is not: it would drop that module's whole + // declared surface — its commands, its Pulse bindings, its datadesc — and the artifact would look + // exactly like a build where the module registered nothing. Say which one it was. + let img = match find_file(build, f, 8) { + None => continue, + Some(path) => match CodeImage::load(&path) { + Ok(img) => img, + Err(e) => { + unreadable.push(format!("{f} ({e:#})")); + continue; + } + }, }; // Console commands come first because they are the one source here that is independent of the // static tables: a library can register a hundred commands and hold neither a Pulse binding nor @@ -1005,6 +1243,22 @@ fn fold_valve_tables( // table-emptiness skip below. let commands = concmd::console_commands(&img); let lib = lib_name_from_file(f); + // ConVars: the other half of the console surface, read by the same pass. Documentation, not a + // locator — a consumer finds a convar by name at runtime; the flags are what it cannot get itself. + out.bindings + .convars + .extend( + concmd::convars(&img, &lib) + .into_iter() + .map(|c| model::ConVar { + name: c.name, + library: c.library, + description: c.description, + flags: c.flags, + flags_raw: c.flags_raw, + addr: c.addr, + }), + ); { let addrs: Vec = commands.iter().map(|c| c.handler).collect(); let sigs = parallel_map(&addrs, threads, |&a| emit::make_sig(&img, a, sig_cap)); @@ -1074,6 +1328,97 @@ fn fold_valve_tables( } } + // VScript — the script VM's registry. Folded exactly like the console commands: the binary + // states the name and the implementation in one initialiser, so the entry is `valve-table` + // provenance and self-named. + // + // Keyed by the C++ name, not the script-facing one. The script name is what a Lua author types + // and belongs in the binding row; the C++ name is what actually lives at the address, and + // gamedata names functions. The two never collide with existing entries — measured at ZERO + // shared addresses and ZERO shared names against the catalogue, because a + // `Script_TakeDamage` is a wrapper and not the `TakeDamage` it wraps. + { + let vsf = crate::vscript::vscript_functions(&img); + // A C++ name registered at more than one address cannot be keyed honestly, so it is dropped + // rather than resolved by fiat — the rule the ambiguous datadesc handlers already follow. On + // the current builds this is 2 of 1,650 on Dota and 0 of 256 on CS2. + let mut addrs_of: HashMap<&str, HashSet> = HashMap::new(); + for f in &vsf { + if let Some(crate::vscript::Impl::Addr(a)) = f.imp { + addrs_of.entry(f.cpp_name.as_str()).or_default().insert(a); + } + } + let foldable: Vec<&crate::vscript::VScriptFunc> = vsf + .iter() + .filter(|f| { + matches!(f.imp, Some(crate::vscript::Impl::Addr(_))) + && addrs_of + .get(f.cpp_name.as_str()) + .is_some_and(|s| s.len() == 1) + }) + .collect(); + let vaddrs: Vec = foldable + .iter() + .filter_map(|f| match f.imp { + Some(crate::vscript::Impl::Addr(a)) => Some(a), + _ => None, + }) + .collect(); + let vsigs = parallel_map(&vaddrs, threads, |&a| emit::make_sig(&img, a, sig_cap)); + for (f, sig) in foldable.iter().zip(vsigs) { + let Some(sig) = sig else { continue }; + if t3.contains_key(&f.cpp_name) { + continue; + } + let Some(crate::vscript::Impl::Addr(addr)) = f.imp else { + continue; + }; + t3.insert( + f.cpp_name.clone(), + model::Entry::signature(lib.clone(), sig), + ); + prov.insert( + f.cpp_name.clone(), + model::Provenance { + addr: Some(format!("{addr:#x}")), + confidence: Some("high".to_string()), + self_named: Some(true), + source: Some(VALVE_VSCRIPT.to_string()), + rationale: Some(format!( + "registered with the script VM as {:?} in {f_lib}", + f.name, + f_lib = lib + )), + ..model::Provenance::with_tier(model::Tier::ValveTable) + }, + ); + vscript_folded += 1; + } + for f in &vsf { + out.bindings.vscript.push(model::VScriptBinding { + name: f.name.clone(), + // Filled in by the live oracle; not derivable here (see `VScriptBinding::class`). + class: None, + cpp: f.cpp_name.clone(), + library: lib.clone(), + description: f.description.clone().unwrap_or_default(), + ret: f.ret.map(str::to_string), + ret_raw: f.ret_raw, + addr: match f.imp { + Some(crate::vscript::Impl::Addr(a)) => Some(format!("{a:#x}")), + _ => None, + }, + vtable_slot: match f.imp { + Some(crate::vscript::Impl::Slot(s)) => Some(s), + _ => None, + }, + // Joined at view time, off the function record this row folds onto — see + // `VScriptBinding::doc`. + doc: None, + }); + } + } + let pulse = valvetab::pulse_bindings(&img); // The datadesc by ARRAY, so each handler can be attributed to the class that owns it. The // record carries no owning class; the array's FIELD descriptors do, because a `(member, offset)` @@ -1260,6 +1605,16 @@ fn fold_valve_tables( returns: sig.as_ref().map(|s| s.returns.clone()).unwrap_or_default(), typed: sig.is_some(), descriptor: format!("{:#x}", b.descriptor), + shim: (b.shim != 0).then(|| format!("{:#x}", b.shim)), + // Measured per shim rather than assumed from the tier: the calling contract is fixed, but + // WHICH slots a given shim reads is the whole difference between host-callable and not. + call: (b.shim != 0) + .then(|| pulse::shim_reads(&img, b.shim)) + .flatten() + .map(|r| model::ShimCall { + needs: r.needs().to_string(), + reads: r.reads.iter().map(|s| s.to_string()).collect(), + }), }; // The registry is keyed by qualified name across libraries, so a binding registered by // more than one module keeps ONE row. That is the documented lossiness — of the LIBRARY, @@ -1272,17 +1627,35 @@ fn fold_valve_tables( // impossible to miss. An earlier "0 disagreements" reading here predates the typed-signature // recovery and was never revisited. Until it is, a consumer reading `params`/`returns` for a // multiply-registered binding is reading ONE module's account of it, not a merged one. - if let Some(prev) = out.bindings.pulse.get(&b.name) { - dup_regs += 1; - dup_names.insert(b.name.clone()); - if prev.params != entry.params - || prev.returns != entry.returns - || prev.typed != entry.typed - { - dup_conflicts.push(b.name.clone()); + // The FIRST library wins, which is the rule every sibling table in this loop already + // follows (commands, VScript, datadesc, entity classes, the live schema) and the one + // `GameProfile::libs` documents — "an earlier lib wins". Pulse was the lone `insert`, so the + // LAST registration overwrote everything, and 224 of 580 CS2 rows shipped another module's + // account under a name libserver also registers. It also broke the oracle pairing: the live + // shim and descriptor checks run against the SERVER image, so for exactly the duplicated + // names the rows that got verified were not the rows that got shipped. + // + // One exception, because precedence must not cost information: a typed row is strictly more + // than an untyped one, so a later library that DID recover a signature replaces an earlier + // one that did not. Never the reverse. + match out.bindings.pulse.get(&b.name) { + Some(prev) => { + dup_regs += 1; + dup_names.insert(b.name.clone()); + if prev.params != entry.params + || prev.returns != entry.returns + || prev.typed != entry.typed + { + dup_conflicts.push(b.name.clone()); + } + if entry.typed && !prev.typed { + out.bindings.pulse.insert(b.name, entry); + } + } + None => { + out.bindings.pulse.insert(b.name, entry); } } - out.bindings.pulse.insert(b.name, entry); } for i in inputs { out.bindings.entity_inputs.push(model::EntityInput { @@ -1300,6 +1673,14 @@ fn fold_valve_tables( .sort_by(|a, b| (&a.input, &a.handler, &a.addr).cmp(&(&b.input, &b.handler, &b.addr))); out.bindings.meta.pulse = out.bindings.pulse.len(); out.bindings.meta.pulse_typed = out.bindings.pulse.values().filter(|b| b.typed).count(); + // Counted from the emitted rows rather than tallied during the fold, so the number in `meta` cannot + // drift from the number of rows a consumer can actually act on. + out.bindings.meta.pulse_callable = out + .bindings + .pulse + .values() + .filter(|b| b.call.as_ref().is_some_and(|c| c.needs == "args-only")) + .count(); out.bindings.meta.entity_inputs = out.bindings.entity_inputs.len(); out.bindings .entity_outputs @@ -1310,6 +1691,9 @@ fn fold_valve_tables( .commands .sort_by(|a, b| (&a.name, &a.addr).cmp(&(&b.name, &b.addr))); out.bindings.meta.commands = out.bindings.commands.len(); + out.bindings.meta.convars = out.bindings.convars.len(); + out.bindings.meta.vscript = out.bindings.vscript.len(); + out.bindings.meta.vscript_located = vscript_folded as usize; if cmd_total > 0 { let libs: BTreeSet<&str> = out @@ -1329,6 +1713,16 @@ fn fold_valve_tables( unmakeable-sig" ); } + eprintln!( + " +{vscript_folded} names from the script-VM registry ({} bindings, {} with a \ + script-facing name Valve documents)", + out.bindings.vscript.len(), + out.bindings + .vscript + .iter() + .filter(|v| !v.description.is_empty()) + .count() + ); // A STANDING ORACLE, and an intrinsic one — it needs no external list. Every command has its // own handler, so commands and distinct handler addresses should track each other. The failure // this catches is specific: the member-callback form finds its handler by scanning the accessor @@ -1380,6 +1774,22 @@ fn fold_valve_tables( 100.0 * f64::from(out_resolved) / f64::from(out_total) ); } + // OUTSIDE the Pulse block below, and that is exactly the point: a library that failed to parse + // contributes no Pulse registrations, so `pulse_total > 0` is the condition LEAST likely to hold when + // this warning is most needed. Nested there, it silenced itself in its own trigger case. + if !unreadable.is_empty() { + eprintln!( + " WARNING {} declared-surface librar{} PRESENT but unreadable, so their commands, Pulse \ + bindings and datadesc are missing from this artifact rather than absent from the build: {}", + unreadable.len(), + if unreadable.len() == 1 { + "y is" + } else { + "ies are" + }, + unreadable.join(", ") + ); + } if pulse_total > 0 { // The stride is DERIVED per image, so report it: it is the one layout fact the reader takes from // consensus rather than from each record, and a build that changed the record size would show up @@ -1456,6 +1866,239 @@ fn binding_kind(f: valvetab::PulseFlags) -> model::BindingKind { } } +/// Fold string anchors onto every monolith entry whose name carries one, in every tier. +/// +/// Returns how many landed. That number is REPORTED rather than assumed because the two populations are +/// independent: the catalogue says which names have anchors, the derive says which names got a locator, and +/// an anchor for a name that never resolved has nowhere to go. A large gap is a fact about the build, not a +/// bug — but it should be visible rather than inferred from an artifact diff. +fn attach_anchors(mono: &mut model::Monolith, anchors: &BTreeMap>) -> usize { + let mut n = 0; + for tier in [ + &mut mono.core, + &mut mono.high_confidence, + &mut mono.experimental, + ] { + for (name, e) in tier.iter_mut() { + if let Some(a) = anchors.get(name) { + // Deduplicated on the way in: the same anchor can appear on several catalogue variants, + // and this list ships in a byte-reproducible artifact. + for s in a { + if !e.locator.anchors.contains(s) { + e.locator.anchors.push(s.clone()); + } + } + n += 1; + } + } + } + n +} + +/// A string worth anchoring on: long enough to be distinctive, printable, and not a lone format specifier. +/// +/// The thresholds are the knob this whole feature turns on. Loosening them raises coverage and lowers +/// distinctiveness; they were measured, not guessed — at these values 4,322 of libserver's 70,288 functions +/// have a unique anchor, and 27% of the shipped set does. +fn usable_anchor(s: &str) -> bool { + s.len() >= 8 + && s.len() <= 200 + && s.is_ascii() + && s.chars().filter(|c| c.is_ascii_alphanumeric()).count() >= 5 +} + +/// Where every anchorable string in `img` is referenced FROM: string address -> the instruction addresses +/// that load it, plus the string itself. +/// +/// Deliberately instruction-level and function-agnostic. Attributing a string to a function needs function +/// BOUNDARIES, and this binary does not reliably supply them — `.eh_frame_hdr` describes 8,327 of libserver's +/// ~70,000 functions, so a `[entry, next_entry)` range routinely spans a real function plus one or more +/// unindexed neighbours, and every neighbour's strings then look like the first function's. An instruction +/// address, by contrast, is exactly what it is. The caller decides membership against an extent it walked +/// itself, which is the only claim available that does not depend on the entry list being complete. +fn string_refs(img: &CodeImage) -> HashMap)> { + let entries = crate::locate::function_entries(img); + + let mut out: HashMap)> = HashMap::new(); + for (i, &start) in entries.iter().enumerate() { + let end = entries.get(i + 1).copied().unwrap_or(u64::MAX); + let Some(code) = img.code_range(start, end) else { + continue; + }; + let mut insn = iced_x86::Instruction::default(); + let mut dec = iced_x86::Decoder::with_ip(64, code, start, iced_x86::DecoderOptions::NONE); + while dec.can_decode() { + dec.decode_out(&mut insn); + if insn.is_invalid() || !insn.is_ip_rel_memory_operand() { + continue; + } + let va = insn.ip_rel_memory_address(); + if let Some(e) = out.get_mut(&va) { + e.1.push(insn.ip()); + } else if let Some(s) = img.read_c_string(va).filter(|s| usable_anchor(s)) { + out.insert(va, (s, vec![insn.ip()])); + } + } + } + out +} + +/// Instruction addresses reachable from `entry` by following control flow, and the string addresses it loads. +/// +/// The function's OWN extent, determined by where its branches go and where it returns, rather than by the +/// next symbol. That is what makes the anchor check sound without a complete function list. +fn reachable_strings(img: &CodeImage, entry: u64) -> Option<(HashSet, Vec)> { + const CAP: u64 = 0x4000; + let all = img.code_at(entry)?; + let extent = (all.len() as u64).min(CAP); + let code = &all[..extent as usize]; + let mut seen: HashSet = HashSet::new(); + let mut loads: Vec = Vec::new(); + // Saturating for the same reason `pulse::shim_reads` is: a file-controlled extent must not wrap the + // range inside out under the overflow-checked build the fuzzers use. + let end = entry.saturating_add(extent); + let mut work = vec![entry]; + let mut insn = iced_x86::Instruction::default(); + while let Some(at) = work.pop() { + if at < entry || at >= end || !seen.insert(at) || seen.len() > 40000 { + continue; + } + let mut dec = iced_x86::Decoder::with_ip( + 64, + &code[(at - entry) as usize..], + at, + iced_x86::DecoderOptions::NONE, + ); + if !dec.can_decode() { + continue; + } + dec.decode_out(&mut insn); + if insn.is_invalid() || insn.len() == 0 { + continue; + } + if insn.is_ip_rel_memory_operand() { + loads.push(insn.ip_rel_memory_address()); + } + match insn.flow_control() { + iced_x86::FlowControl::Return + | iced_x86::FlowControl::IndirectBranch + | iced_x86::FlowControl::Exception + | iced_x86::FlowControl::Interrupt => {} + iced_x86::FlowControl::UnconditionalBranch => work.push(insn.near_branch_target()), + iced_x86::FlowControl::ConditionalBranch => { + work.push(at + insn.len() as u64); + work.push(insn.near_branch_target()); + } + _ => work.push(at + insn.len() as u64), + } + } + Some((seen, loads)) +} + +/// Derive an anchor for every entry that has none, from the address its SHIPPED signature resolves to. +/// +/// Three conditions, each closing a way this can name the wrong function: +/// +/// 1. **The resolved address must be a function ENTRY POINT.** ModSharp's `refs.strings` locates a +/// *function*; a great many shipped locators deliberately point MID-function (`CBaseButton::InputPress` +/// resolves to a `mov`, `BotNavIgnore` to a `je` — patterns anchored at a hook site, not a prologue). An +/// anchor cannot denote the same thing as one of those, so those entries get none rather than a locator +/// that resolves somewhere else. +/// 2. **The string must be referenced from inside the function's OWN flow-reachable code**, walked from the +/// entry, not from a `[entry, next_entry)` range. `.eh_frame_hdr` covers a small fraction of these +/// binaries' functions, so such a range routinely swallows unindexed neighbours and inherits their +/// strings — which is exactly how a first cut of this produced "`CBaseButton::InputPress` references +/// *Traced intervals in %.3fus*". +/// 3. **Every instruction that loads the string must be inside that same reachable set.** This is the +/// uniqueness test, done at instruction level so it never consults a function boundary. A string also +/// loaded from elsewhere locates nothing and is dropped. +/// +/// Server-library only, the restriction [`recover_by_string_anchor`] already carries: the fold holds that one +/// image, and loading a second full set of 22 keyed images to reach the rest would add several hundred MB to a +/// pipeline that has already been OOM-killed on Dota. +/// +/// Returns `(attached, considered)`. Degrades quietly toward FEWER anchors and never toward a wrong one. +fn attach_derived_anchors( + mono: &mut model::Monolith, + img: &CodeImage, + server_lib: &str, +) -> (usize, usize) { + let wants = |e: &model::MonoEntry| { + e.locator.anchors.is_empty() + && e.locator + .signature + .as_ref() + .is_some_and(|s| s.library == server_lib) + }; + let any = [&mono.core, &mono.high_confidence, &mono.experimental] + .iter() + .any(|t| t.values().any(&wants)); + if !any { + return (0, 0); + } + let refs = string_refs(img); + // Condition 1's test set: the addresses this image treats as function starts. + let starts = crate::locate::function_entries(img); + + // Why each candidate was rejected, so a low yield is a FACT rather than a mystery. The three + // conditions fail for very different reasons and the mix differs sharply between games (CS2 derives + // ~5% of candidates, Dota ~0.5%); without this the difference is unattributable. + let (mut attached, mut considered) = (0usize, 0usize); + let (mut no_resolve, mut mid_fn, mut no_unique) = (0usize, 0usize, 0usize); + for tier in [ + &mut mono.core, + &mut mono.high_confidence, + &mut mono.experimental, + ] { + for e in tier.values_mut() { + if !wants(e) { + continue; + } + considered += 1; + let Some(sig) = e.locator.signature.as_ref() else { + continue; + }; + let Ok(pat) = crate::sig::Pattern::parse(&sig.linux) else { + continue; + }; + let hits = img.find(&pat); + let [addr] = hits.as_slice() else { + no_resolve += 1; + continue; + }; + let addr = *addr; + if starts.binary_search(&addr).is_err() { + mid_fn += 1; // condition 1: mid-function locator, not a function an anchor can name + continue; + } + let Some((reach, loads)) = reachable_strings(img, addr) else { + continue; + }; + // Candidates this function actually loads, longest first then lexicographic — deterministic, + // because this lands in a byte-reproducible artifact. + let mut cands: Vec<&(String, Vec)> = loads + .iter() + .filter_map(|va| refs.get(va)) + .filter(|(_, from)| from.iter().all(|ip| reach.contains(ip))) + .collect(); + cands.sort_unstable_by(|a, b| b.0.len().cmp(&a.0.len()).then_with(|| a.0.cmp(&b.0))); + match cands.first() { + Some((s, _)) => { + e.locator.anchors.push(s.clone()); + attached += 1; + } + None => no_unique += 1, + } + } + } + eprintln!( + " anchor derivation: {attached} attached; rejected {no_resolve} (pattern did not resolve \ + uniquely), {mid_fn} (locator is mid-function, which an anchor cannot name), {no_unique} (no string \ + unique to the function)" + ); + (attached, considered) +} + /// Assemble the monolith in memory and render its CS# gamedata (the string the live validate stage checks). /// Writes NOTHING — `produce` holds the `Monolith` (to annotate it live) plus this render, and writes the /// monolith exactly once at the end (after live validation, if a game is present). @@ -1470,8 +2113,10 @@ fn build_monolith( t3: &BTreeMap, prov: &BTreeMap, abi: &BTreeMap, + anchors: &BTreeMap>, + server_img: Option<(&CodeImage, &str)>, ) -> Result<(model::Monolith, String)> { - let mono = assemble_monolith( + let mut mono = assemble_monolith( prof, source_build, version, @@ -1483,6 +2128,22 @@ fn build_monolith( prov, abi, )?; + // Attached AFTER assembly, across every tier at once, rather than at the three MonoEntry construction + // sites: an anchor belongs to a NAME, not to a tier, and one pass cannot leave a tier out by omission. + let attached = attach_anchors(&mut mono, anchors); + // Then DERIVE one for everything the catalogue does not cover. Reported separately from the catalogued + // count: they are different claims — one is a curated string somebody chose, the other is this build's + // own machine code answering the same question — and collapsing them would hide either going to zero. + let (derived, considered) = match server_img { + Some((img, lib)) => attach_derived_anchors(&mut mono, img, lib), + None => (0, 0), + }; + eprintln!( + " string anchors: {attached} of {} catalogued reached the monolith; {derived} DERIVED for {considered} \ + server entries that had none ({} total anchored)", + anchors.len(), + attached + derived + ); let cssharp = render::render_monolith_cssharp(&mono, model::TierSelect::HighConfidence); eprintln!( " monolith: {} core + {} high-conf + {} experimental + {} unresolved", @@ -1491,6 +2152,14 @@ fn build_monolith( mono.meta.counts.experimental, mono.meta.counts.unresolved ); + eprintln!( + " aliases: {} names over {} functions carry a second shipped name ({:.1}% of the resolved \ + surface is one function under several names)", + mono.meta.aliased_names, + mono.meta.alias_groups, + 100.0 * mono.meta.aliased_names as f64 + / (mono.meta.counts.core + mono.meta.counts.high_confidence).max(1) as f64 + ); Ok((mono, cssharp)) } @@ -1513,6 +2182,8 @@ pub(crate) struct FoldArgs<'a> { pub unverified: &'a BTreeSet, /// The derive's measured argument footprints, folded onto the monolith entries. pub abi: &'a BTreeMap, + /// The derive's catalogue string anchors, folded onto the monolith entries the same way. + pub anchors: &'a BTreeMap>, pub sig_cap: usize, pub version: &'a str, pub full_names: Option<&'a Path>, @@ -1525,13 +2196,6 @@ pub(crate) struct FoldArgs<'a> { pub source_build: &'a str, } -/// Fold the verified name-extrapolation harvest + curated entries under the guaranteed core into ONE -/// shipped gamedata — the whole deterministic promote stage in a single per-game command. Each promotable -/// gets the correct-by-construction locator (a vtable OFFSET when its RTTI class is clean and the AI's -/// class matches ground-truth, else a fresh `make_sig`); the prefiltered `--candidates` membership drops -/// dead weight; the guaranteed `--core` wins name collisions. `--extra-offsets` folds multilib ground-truth -/// vtable methods (name + slot) from the other server libs directly as high_confidence offsets. Emits the -/// combined file + a provenance sidecar (tier / confidence / return-class / by-value flag). /// Measure the argument footprint of OFFSET-located entries. A vtable slot IS the function address once the /// class's vtable is located, so the same `abi_shape` that covers signatures covers virtuals — and virtuals /// are the bulk of the shipped surface. Signature entries already carry a shape from the derive; this fills @@ -1568,6 +2232,13 @@ fn offset_abi_shapes<'a>( out } +/// Fold the verified name-extrapolation harvest + curated entries under the guaranteed core into ONE +/// shipped gamedata — the whole deterministic promote stage in a single per-game command. Each promotable +/// gets the correct-by-construction locator (a vtable OFFSET when its RTTI class is clean and the AI's +/// class matches ground-truth, else a fresh `make_sig`); the prefiltered `--candidates` membership drops +/// dead weight; the guaranteed `--core` wins name collisions. `--extra-offsets` folds multilib ground-truth +/// vtable methods (name + slot) from the other server libs directly as high_confidence offsets. Emits the +/// combined file + a provenance sidecar (tier / confidence / return-class / by-value flag). pub(crate) fn build_gamedata_cmd(prof: &GameProfile, a: FoldArgs) -> Result { let FoldArgs { build, @@ -1578,6 +2249,7 @@ pub(crate) fn build_gamedata_cmd(prof: &GameProfile, a: FoldArgs) -> Result Result Result Result { serde_json::from_str(&stripped).context("parse gamedata json") } -/// Assemble the monolith (`gamedata-.json`) from the in-memory derive/fold results: +/// Assemble the monolith (the tiered catalogue that becomes `rosetta-.json`'s `functions`) from +/// the in-memory derive/fold results: /// the rendered `core_json` → core tier; the fold's `t3`/`prov` → high_confidence; the `experimental` guesses /// → the non-promoted experimental tail; the `flagged` list → unresolved. Pure assembly, no re-derivation and /// no intermediate files. `validated` stays `None` (the live stage annotates it later). @@ -2144,7 +2819,6 @@ fn assemble_monolith( name.clone(), MonoEntry { locator: render::entry_from_value(v), - class: None, abi: abi.get(name.as_str()).cloned(), provenance: Provenance { source: Some(source.into()), @@ -2152,6 +2826,7 @@ fn assemble_monolith( ..Provenance::with_tier(Tier::Core) }, validated: None, + aliases: Vec::new(), // filled once both shipped tiers exist }, ); } @@ -2167,10 +2842,10 @@ fn assemble_monolith( name.clone(), MonoEntry { locator, - class: None, abi: abi.get(name.as_str()).cloned(), provenance: provenance.clone(), validated: None, + aliases: Vec::new(), // filled once both shipped tiers exist }, ); } @@ -2202,13 +2877,22 @@ fn assemble_monolith( ..Provenance::with_tier(g.tier) }; exp_tier.entry(g.name.clone()).or_insert(MonoEntry { - locator: locator.clone(), - class: g.class.clone(), + // The class rides on the LOCATOR now, not beside it: for an offset entry the class is what + // makes the slot index mean anything, and keeping them together is what lets it reach the + // emitters through `Monolith::select`. + locator: model::Entry { + class: g.class.clone(), + ..locator.clone() + }, // The band's own measurement first: it was taken at the guess's exact address, which IS // what the locator resolves to. The name-keyed map is the fallback. abi: g.abi.clone().or_else(|| abi.get(g.name.as_str()).cloned()), provenance, validated: None, + // Never grouped: an unverified name sharing a target with another unverified name is not + // evidence they mean the same thing. This band states the converse through + // `provenance.collision` (one name guessed at several addresses). + aliases: Vec::new(), }); } } @@ -2237,6 +2921,8 @@ fn assemble_monolith( }); } + let (alias_groups, aliased_names) = link_aliases(&mut core, &mut high); + let counts = Counts { core: core.len(), high_confidence: high.len(), @@ -2250,6 +2936,8 @@ fn assemble_monolith( source_build: source_build.to_string(), version: version.to_string(), counts, + alias_groups, + aliased_names, }, core, high_confidence: high, @@ -2258,11 +2946,78 @@ fn assemble_monolith( }) } -/// Fold the live-validation verdict INTO the monolith (Stage F): an entry that survived `validate-live` (is -/// present in `validated_path`) becomes `validated: Some(true)`, one that was dropped confident-bad becomes -/// `Some(false)`. Only the shipped tiers (`core` + `high_confidence`) are annotated — `experimental` was -/// never sent to the server, so it stays `None`. This keeps the monolith self-contained (no standalone -/// validation sidecar). +/// Cross-link the shipped tiers' ALIASES: names that locate the same function, written onto each entry as +/// the other names for it. Returns `(groups, names covered)` for the meta counters. +/// +/// **Locator identity is the key, and for a signature it is exactly address identity.** A shipped pattern is +/// generated AT the resolved address and then confirmed unique within its library, so two entries carrying +/// the same `(library, pattern)` cannot resolve anywhere but the same single address — the uniqueness check +/// the emitter already performs is what makes string equality a sound proxy here, with no second scan. A +/// vtable entry keys on `(class, slot)`, which is the same argument: the slot means nothing except relative +/// to a named vtable, and together they name one function. +/// +/// **A bare slot — an `offset` with no `class` — is deliberately left ungrouped.** It names no vtable, so two +/// of them sharing a slot index are not evidence of anything; grouping them anyway put 1,080 CS2 names into +/// 70 fictitious groups when measured. Those entries ship with no `aliases` because none is derivable, not +/// because none exists, and the field's doc says so rather than letting a reader infer uniqueness from the +/// silence. +fn link_aliases( + core: &mut BTreeMap, + high: &mut BTreeMap, +) -> (usize, usize) { + // The locator's identity as a comparable key, or None where the entry locates nothing groupable. + let key = |e: &model::MonoEntry| -> Option<(String, String)> { + if let Some(s) = &e.locator.signature { + return Some((s.library.clone(), s.linux.clone())); + } + match (&e.locator.class, e.locator.offset) { + (Some(c), Some(slot)) => Some((c.clone(), format!("#{slot}"))), + _ => None, + } + }; + + // Group ACROSS the two tiers, not within each: a `core` name and a `high_confidence` name on one address + // are aliases, and that pairing is the one a consumer is least likely to spot unaided. A `BTreeSet` per + // target rather than a `Vec` because the tiers are only disjoint by construction, and a name reaching + // this twice must not inflate its own group or turn up as its own alias. + let mut by_target: BTreeMap<(String, String), BTreeSet> = BTreeMap::new(); + for (name, e) in core.iter().chain(high.iter()) { + if let Some(k) = key(e) { + by_target.entry(k).or_default().insert(name.clone()); + } + } + by_target.retain(|_, names| names.len() > 1); + + // Resolve every membership first, then write: an entry is reached through whichever tier holds it, + // and both are written the same way rather than one path shadowing the other. + let mut others_of: BTreeMap> = BTreeMap::new(); + for names in by_target.values() { + for name in names { + others_of.insert( + name.clone(), + names.iter().filter(|n| *n != name).cloned().collect(), + ); + } + } + for (name, e) in core.iter_mut().chain(high.iter_mut()) { + if let Some(others) = others_of.get(name) { + e.aliases = others.clone(); + } + } + (by_target.len(), others_of.len()) +} + +/// Fold the live-validation verdict INTO the monolith (Stage F), from the `verdicts` map the live oracle +/// returns. +/// +/// **THREE-valued, and that is the whole point of the function.** `Some(true)` = the running server +/// confirmed it; `Some(false)` = the oracle dropped it confident-bad; `None` = the oracle could not check +/// it at all (a library this run did not map, a non-vtable class), and the artifact must say so rather +/// than pick a side. A two-state reading — "present means good, absent means bad" — is exactly the +/// collapse this exists to prevent, because it would report an unchecked entry as validated. +/// +/// Only the shipped tiers (`core` + `high_confidence`) are annotated; `experimental` was never sent to the +/// server, so it keeps `None`. Keeps the monolith self-contained — no standalone validation sidecar. pub(crate) fn annotate_validation( mono: &mut model::Monolith, verdicts: &BTreeMap>, @@ -2580,7 +3335,7 @@ impl<'de> serde::Deserialize<'de> for Hop { /// Distilled cross-build corpus signals — everything `gamedata` reads from the full build corpus, /// WITHOUT the Valve binaries. Fingerprints/offsets/slot-indices are derived facts (zero -/// Valve bytes) → shippable. Produced by `corpus-model`; consumed by `gamedata --corpus-model` +/// Valve bytes) → shippable. Produced by `corpus-model`; consumed by `produce --corpus-model` /// alongside only the target build's binary. Incremental: model N + build N+1 → model N+1. #[derive(serde::Serialize, serde::Deserialize)] pub struct CorpusModel { @@ -2611,7 +3366,7 @@ pub struct CorpusModel { /// (BTreeMap like the other fields, so the serialized model is deterministic; the transient per-build /// `VtableFps` stays a HashMap — this is the one boundary where they convert.) latest_vtable_fps: BTreeMap>>>, - /// sig function -> its consensus ABI shape across the newest builds. Lets `gamedata --corpus-model` + /// sig function -> its consensus ABI shape across the newest builds. Lets `produce --corpus-model` /// flag a target whose derived shape differs from history at DERIVE time — the prototype-drift signal /// `abi-diff` gives, but forward and corpus-free. consensus_abi: BTreeMap, @@ -2624,6 +3379,41 @@ pub struct CorpusModel { /// Number of newest builds whose raw sig fingerprints go into the model's verification set. const CORPUS_REF_K: usize = 8; +/// The per-build array shape every downstream reader assumes. +/// +/// `slot_counts`, `hops` and `resolved_slot` are read by build INDEX, so a length desync does not fail — +/// it silently re-dates an observation, attributing this build's slot to some older one. Checked where the +/// model is WRITTEN rather than only where it is rolled forward, because a distill that emits a malformed +/// model is the same defect one fold later and the fold's error would then name the wrong producer. +/// O(classes) against a pass that just walked whole binaries, so it runs on the production path rather +/// than behind a debug assert. +fn check_model_shape(m: &CorpusModel) -> Result<()> { + let nb = m.builds.len(); + for (c, v) in &m.slot_counts { + ensure!( + v.len() == nb, + "slot_counts[{c}] has {} entries, expected {nb}", + v.len() + ); + } + for (c, v) in &m.hops { + ensure!( + v.len() == nb - 1, + "hops[{c}] has {} entries, expected {}", + v.len(), + nb - 1 + ); + } + for (n, v) in &m.resolved_slot { + ensure!( + v.len() == nb, + "resolved_slot[{n}] has {} entries, expected {nb}", + v.len() + ); + } + Ok(()) +} + /// The set of classes a model tracks hops for — THE rule that has to agree between the full distill and the /// incremental fold, since `fold_model_cmd` claims to produce a model equal to a re-distill over the same /// builds and CI depends on that. Shared for the same reason `extract_build_vtables` and `ref_obs_of_build` @@ -2861,6 +3651,9 @@ pub fn corpus_model_cmd( consensus_abi, abi_obs, }; + // Checked HERE too, not only in the fold: a distill that emits a desynced model is the same defect + // one build later, and the fold's error would then name the wrong producer. + check_model_shape(&model)?; let text = serde_json::to_string(&model)?; std::fs::write(out, &text).with_context(|| format!("write {}", out.display()))?; eprintln!( @@ -2988,9 +3781,15 @@ fn ref_obs_of_build( sig_funcs: &[&Func], nthreads: usize, ) -> RefObs { - let rimg = preload_images(prof, cat, dir); + let (rimg, _unreadable) = preload_images(prof, cat, dir); + // The identity check belongs HERE, not only where the artifact is emitted. This function is what + // teaches the model what a name looks like, and it is shared by the distill and the incremental fold — + // so a contradiction rejected only at emit time would leave the model still learning the wrong + // function's fingerprint, and the strict fingerprint check would then CONFIRM that wrong resolution on + // the next build. Measured: that is exactly how one bad entry survived three guards and shipped. + let ident = Identity::of(&rimg); parallel_map(sig_funcs, nthreads, |f| { - let (img, addr, _) = locate_addr(prof, f, &rimg)?; + let (img, addr, _) = locate_addr_ident(prof, f, &rimg, Some(&ident))?; let fp = fingerprint::extract(img, addr)?.to_vec(); Some(( f.name.clone(), @@ -3175,32 +3974,7 @@ pub fn fold_model_cmd( consensus_abi, abi_obs, }; - // The per-build arrays are read by build INDEX everywhere downstream, so a length desync silently - // re-dates an observation instead of failing. Check the shape the readers assume — O(classes) against - // a fold that just walked a whole binary, and this is the production path, so not a debug-only assert. - let nb = folded.builds.len(); - for (c, v) in &folded.slot_counts { - ensure!( - v.len() == nb, - "slot_counts[{c}] has {} entries, expected {nb}", - v.len() - ); - } - for (c, v) in &folded.hops { - ensure!( - v.len() == nb - 1, - "hops[{c}] has {} entries, expected {}", - v.len(), - nb - 1 - ); - } - for (n, v) in &folded.resolved_slot { - ensure!( - v.len() == nb, - "resolved_slot[{n}] has {} entries, expected {nb}", - v.len() - ); - } + check_model_shape(&folded)?; let out_text = serde_json::to_string(&folded)?; std::fs::write(out, &out_text).with_context(|| format!("write {}", out.display()))?; @@ -3233,7 +4007,21 @@ enum SigResolve { Flag(String), Emit(String, String, String), // confident: (name, library, signature) EmitFallback(String, String, String), // heuristic-flagged but uniquely resolves — live-validate + /// The address resolved, and the BINARY CONTRADICTS the name there — `(name, why)`. Kept distinct from + /// `Flag` because it is a different fact and a louder one: a drifted sig failed to find its function, + /// while this one found a function that is provably not it. + Contradicted(String, String), } +/// What a candidate address is checked AGAINST, in one place because the three travel together: the +/// cross-build fingerprint history and the bar it has to clear, plus what the binary itself states about +/// the address ([`Identity`]). Fingerprints answer "is this the same function as last build"; `Identity` +/// answers "is this the function this name means at all" — different questions, both needed. +struct Verify<'a> { + ref_fps: HashMap>>, + ref_majority: usize, + ident: &'a Identity, +} + /// `(dbg line, resolution, optional (name, abi-drift detail), optional (name, derived ABI shape))` per /// catalogue function. type SigItem = ( @@ -3262,11 +4050,11 @@ fn resolve_signatures( prof: &GameProfile, cat: &[Func], images: &HashMap, - ref_fps: &HashMap>>, - ref_majority: usize, + v: &Verify<'_>, cmodel: Option<&CorpusModel>, dbg: bool, ) -> Vec { + let (ref_fps, ref_majority, ident) = (&v.ref_fps, v.ref_majority, v.ident); const VERIFY_L1_MAX: u64 = 12; parallel_map(cat, default_threads(None), |f| { if linux_sigs(f).is_empty() { @@ -3319,6 +4107,19 @@ fn resolve_signatures( // validate-live as the real gate rather than dropping a real function that merely drifted. let was_flagged = chosen.is_none(); let chosen = chosen.or_else(|| (cands.len() == 1).then(|| cands[0].0)); + // Refuse an address the binary itself says is a different function — including one the fallback + // above would otherwise emit, since "exactly one era-sig resolves" is precisely how a stale sig's + // coincidental hit gets through. + if let Some(addr) = chosen + && let Some(why) = ident.contradiction(&lib, img, addr, &f.name) + { + return ( + None, + SigResolve::Contradicted(f.name.clone(), why), + None, + None, + ); + } // Derive-time prototype-drift check (model path only): unknown-return-guarded, a kept signal for // review, not a drop — the sig still emits. // Measured for EVERY resolved signature, not just those with corpus history: it is what lets a @@ -3335,13 +4136,25 @@ fn resolve_signatures( ) }) }); - let shape_out = shape.map(|s| (f.name.clone(), shipped_abi(s))); - let r = match chosen + // The measured footprint ships ONLY where the signature does, and the pairing is what makes it + // meaningful: a `Flag` means this address produced no signature, so the name goes on to + // `sig_flag` where `recover_by_string_anchor` / `recover_virtual_sigs` may relocate it. `make_sig` + // is deterministic per (image, address) and already failed here, so any later recovery is + // provably at a DIFFERENT address — and a footprint measured at this one would then describe some + // other function while `prototypes::agrees` judged declared types against it. No shape is the + // acceptable degradation; a shape belonging elsewhere is the thing this project forbids. + let (r, shape_out) = match chosen .and_then(|addr| emit::make_sig(img, addr, CORE_SIG_CAP).map(|s| (lib, s))) { - Some((lib, sig)) if was_flagged => SigResolve::EmitFallback(f.name.clone(), lib, sig), - Some((lib, sig)) => SigResolve::Emit(f.name.clone(), lib, sig), - None => SigResolve::Flag(f.name.clone()), + Some((lib, sig)) if was_flagged => ( + SigResolve::EmitFallback(f.name.clone(), lib, sig), + shape.map(|s| (f.name.clone(), shipped_abi(s))), + ), + Some((lib, sig)) => ( + SigResolve::Emit(f.name.clone(), lib, sig), + shape.map(|s| (f.name.clone(), shipped_abi(s))), + ), + None => (SigResolve::Flag(f.name.clone()), None), }; (dbg_line, r, abi_drift, shape_out) }) @@ -3387,7 +4200,7 @@ fn build_ref_fingerprints( } let per_ref: Vec)>> = parallel_map(ref_dirs, default_threads(None), |dir| { - let rimg = preload_images(prof, cat, dir); + let (rimg, _unreadable) = preload_images(prof, cat, dir); let mut v = Vec::new(); for f in cat { if linux_sigs(f).is_empty() { @@ -3428,6 +4241,7 @@ fn apply_sig_items( let mut sig_ok = 0; let mut sig_flag: Vec = Vec::new(); let mut sig_fallback: Vec = Vec::new(); + let mut contradicted: Vec = Vec::new(); let mut abi_drift: Vec = Vec::new(); let mut shapes: BTreeMap = BTreeMap::new(); for (dbg_line, r, drift, shape) in sig_items { @@ -3447,6 +4261,17 @@ fn apply_sig_items( match r { SigResolve::Skip => {} SigResolve::Flag(name) => sig_flag.push(name), + SigResolve::Contradicted(name, why) => { + // Carried with its OWN reason rather than merged into the drifted name list: the artifact + // must not tell a consumer "no signature resolved" when one did and was refused. It rides + // the `Flagged` channel (which already carries a reason per entry) rather than widening + // this function's return. + contradicted.push(model::Flagged::new( + name, + model::FlagReason::NameContradicted, + why, + )); + } SigResolve::Emit(name, lib, sig) => { gd.set_signature(name, lib, sig); sig_ok += 1; @@ -3458,6 +4283,17 @@ fn apply_sig_items( } } } + if !contradicted.is_empty() { + eprintln!( + " {} signatures REFUSED — the binary contradicts the name at the address they resolve to \ + (they ship as `unresolved`, not as a locator):", + contradicted.len() + ); + for c in &contradicted { + eprintln!(" {} — {}", c.name, c.detail); + } + } + abi_drift.extend(contradicted); if !sig_fallback.is_empty() { eprintln!( " {} signatures emitted via unique-resolve fallback (fingerprint-UNVERIFIED — marked \ @@ -3486,6 +4322,13 @@ pub(crate) struct Derived { /// Per-entry argument footprint measured in the target binary — the machine half of the /// locator/prototype split, and what a declared prototype is checked against. pub abi: BTreeMap, + /// Per-entry string ANCHORS from the catalogue — distinctive literals the function references. + /// + /// Its own side table for the same reason `abi` is: the derive→fold transport for `core` is the cssharp + /// locator shape, which has no anchor field, so anything ridden in on an `Entry` there would be dropped + /// when the fold re-parses it. Carrying them separately keeps the cssharp artifact unchanged — CS# has + /// no `refs` feature and should not grow a key it cannot read. + pub anchors: BTreeMap>, } /// Derive a target build's gamedata OFFLINE and return it in memory. @@ -3560,16 +4403,42 @@ pub(crate) fn gamedata( // ---- signatures: resolve a known sig in the target, VERIFY the hit is really the function // (fingerprint vs the newest reference builds — a stale era-sig can uniquely match the // WRONG function), then regenerate a fresh unique sig. ---- - let images = preload_images(prof, &cat, target); + let (images, unreadable_libs) = preload_images(prof, &cat, target); + // Named loudly: every catalogue entry pointing at one of these will resolve nowhere and ship as + // `SigDrifted`, whose detail says a signature drifted in the target — a false CAUSE for a file that + // was never opened. The reason has to reach the log even though it cannot reach every flag detail. + if !unreadable_libs.is_empty() { + eprintln!( + " WARNING {} target librar{} PRESENT but unreadable — every catalogue entry naming one \ + scans nothing and is flagged as drifted, which is not why it failed: {}", + unreadable_libs.len(), + if unreadable_libs.len() == 1 { + "y is" + } else { + "ies are" + }, + unreadable_libs.join(", ") + ); + } // The target must be a build DIRECTORY that `find_file` can search (a bare `.so` path is NOT searched — // read_dir on a file yields nothing). Without this, a mistyped/file target loads zero images and the // derive silently emits an all-flagged, near-empty release that even clears the live gate. Fail loudly // instead — unless the catalogue is offset-only (no sigs to locate), where empty images is legitimate. ensure!( images.contains_key(prof.server_lib) || cat.iter().all(|f| linux_sigs(f).is_empty()), - "target {} loaded no {} — pass the build DIRECTORY (a bare .so path is not searched)", + "target {} loaded no {} — {}", label_of(target), - prof.server_lib + prof.server_lib, + // Two very different causes, and telling the operator the wrong one costs an hour: a mistyped or + // file-shaped target searches nothing, while a present-but-corrupt server lib is a broken input. + if unreadable_libs + .iter() + .any(|u| u.starts_with(prof.server_lib)) + { + "it is PRESENT but failed to parse (see the warning above) — truncated, or not an ELF" + } else { + "pass the build DIRECTORY (a bare .so path is not searched)" + } ); // Sample the newest reference builds (there a sig still lands on the real function) to reject a target @@ -3587,8 +4456,16 @@ pub(crate) fn gamedata( // reference fingerprints, and emit a fresh sig — all read-only over images/ref_fps, each doing many // whole-binary memchr scans. Resolve across threads (capturing any SOURCE2ROSETTA_DBG line), then apply in // catalogue order so gd (name-keyed), the counts and the flag list are byte-identical to a serial run. - let sig_items = resolve_signatures(prof, &cat, &images, &ref_fps, ref_majority, cmodel, dbg); - let (mut sig_ok, mut sig_flag, unverified, abi_drift, abi_shapes) = + // Built once over the whole image set and shared read-only across the resolution threads: both halves + // are whole-image passes, so recomputing per function would dominate the derive. + let ident = Identity::of(&images); + let verify = Verify { + ref_fps, + ref_majority, + ident: &ident, + }; + let sig_items = resolve_signatures(prof, &cat, &images, &verify, cmodel, dbg); + let (mut sig_ok, mut sig_flag, unverified, abi_drift, mut abi_shapes) = apply_sig_items(sig_items, &mut gd); // ---- one full-corpus vtable pass feeds BOTH offset chaining and vtable-anchoring recovery. @@ -3635,11 +4512,20 @@ pub(crate) fn gamedata( ); if !vrec.is_empty() { sig_ok += vrec.len(); - sig_flag.retain(|n| !vrec.contains(n)); + // Re-measured AT THE ADDRESS RECOVERY LANDED ON. The resolver ships no footprint for a flagged + // name precisely because recovery moves it, so this is what puts one back — measured where the + // signature now points rather than where it used to. + for (name, lib, addr) in &vrec { + if let Some(sh) = images.get(*lib).and_then(|im| abi::abi_shape(im, *addr)) { + abi_shapes.insert(name.clone(), shipped_abi(sh)); + } + } + let names: Vec<&str> = vrec.iter().map(|(n, ..)| n.as_str()).collect(); + sig_flag.retain(|n| !names.contains(&n.as_str())); eprintln!( " {} drifted signatures RECOVERED via vtable anchoring: {}", vrec.len(), - vrec.join(", ") + names.join(", ") ); } @@ -3650,11 +4536,20 @@ pub(crate) fn gamedata( let arec = recover_by_string_anchor(prof, &cat, &images, &mut gd); if !arec.is_empty() { sig_ok += arec.len(); - sig_flag.retain(|n| !arec.contains(n)); + // Same re-measurement, same reason. String anchors are server-lib by construction. + if let Some(im) = images.get(prof.server_lib) { + for (name, addr) in &arec { + if let Some(sh) = abi::abi_shape(im, *addr) { + abi_shapes.insert(name.clone(), shipped_abi(sh)); + } + } + } + let names: Vec<&str> = arec.iter().map(|(n, _)| n.as_str()).collect(); + sig_flag.retain(|n| !names.contains(&n.as_str())); eprintln!( " {} functions RECOVERED by string anchor: {}", arec.len(), - arec.join(", ") + names.join(", ") ); } @@ -3684,13 +4579,19 @@ pub(crate) fn gamedata( rendered.join(", ") ); } - if !abi_drift.is_empty() { + // Scoped to the drift reason: this vec also carries the name-contradiction refusals, which are a + // different fact and are reported where they are found. + let drifted: Vec<&model::Flagged> = abi_drift + .iter() + .filter(|f| f.reason == model::FlagReason::AbiDrift) + .collect(); + if !drifted.is_empty() { // A prototype-drift WARNING (sig still emitted): the target's ABI shape differs from the model's // consensus — the loader-hook seam the byte-sig can't see, caught forward without the corpus. eprintln!( " {} signatures with ABI DRIFT vs model consensus (kept; review prototype): {}", - abi_drift.len(), - abi_drift + drifted.len(), + drifted .iter() .map(|f| format!("{} ({})", f.name, f.detail)) .collect::>() @@ -3710,11 +4611,58 @@ pub(crate) fn gamedata( .collect(); flagged.extend(off_flag); flagged.extend(abi_drift); + // ---- the completeness sweep, and it is the thing that makes `unresolved` a CONTRACT rather than a + // by-product. Every pass above flags what IT could not place: the sig resolver flags a drifted + // signature, the offset pass flags a low-confidence vote. But a name reaches those passes only if + // it has the input they consume, and one class of entry has neither — an ANCHOR-ONLY catalogue + // entry (476 of CS2's 1,601) never enters the sig resolver at all, so when its anchor finds zero + // or several xref hits it lands in no tier and no flag list: it simply stops existing, which is + // the one outcome README.md ("it never just disappears") and CONTRIBUTING.md both rule out. + // Sweeping the catalogue itself, rather than adding a fourth per-pass flag, is what makes the + // claim hold for the NEXT locator kind too. ---- + let accounted: HashSet<&str> = gd + .entries + .keys() + .map(String::as_str) + .chain(flagged.iter().map(|f| f.name.as_str())) + .collect(); + let by_name: HashMap<&str, &Func> = cat.iter().map(|f| (f.name.as_str(), f)).collect(); + let mut vanished: Vec<&str> = by_name + .keys() + .copied() + .filter(|n| !accounted.contains(n)) + .collect(); + vanished.sort_unstable(); + if !vanished.is_empty() { + eprintln!( + " {} catalogue entries produced no locator and no flag — recorded as unresolved: {}", + vanished.len(), + vanished.join(", ") + ); + flagged.extend(vanished.into_iter().map(|n| { + model::Flagged::new( + n, + model::FlagReason::Unresolved, + unresolvable_because(by_name[n]), + ) + })); + } + // Every catalogue entry's anchors, whether or not a byte sig located it. `recover_by_string_anchor` + // uses them only as a FALLBACK locator; this ships them as a supplement, which is a different job — an + // entry that resolved perfectly still benefits from a second locator with a different failure mode. + let anchors: BTreeMap> = cat + .iter() + .filter_map(|f| { + let a: Vec = string_anchors(f).into_iter().map(str::to_string).collect(); + (!a.is_empty()).then(|| (f.name.clone(), a)) + }) + .collect(); Ok(Derived { core, flagged, unverified: unverified.into_iter().collect(), abi: abi_shapes, + anchors, }) } @@ -3737,13 +4685,15 @@ struct BuildVtables { /// per build: for each catalogue function with a string-anchor not already located by a byte sig, take /// the *unique* function referencing that string in the target and emit a fresh sig there. A string /// referenced by ≥2 functions is not distinctive enough → skipped (stays flagged). Server-only (all -/// curated anchors are server-lib). Returns the recovered names. +/// curated anchors are server-lib). Returns each recovered name WITH the address it was relocated to — +/// the caller re-measures the footprint there, because the one measured before recovery belonged to an +/// address this build rejected. fn recover_by_string_anchor( prof: &GameProfile, cat: &[Func], target_images: &HashMap, gd: &mut model::Gamedata, -) -> Vec { +) -> Vec<(String, u64)> { let anchored: Vec<&Func> = cat .iter() .filter(|f| !string_anchors(f).is_empty()) @@ -3756,20 +4706,50 @@ fn recover_by_string_anchor( } let idx = xref::XrefIndex::build(img); let mut recovered = Vec::new(); + let mut unreachable = 0usize; for f in anchored { if gd.entries.contains_key(&f.name) { continue; // already located by a byte sig — the anchor is just a backup } for s in string_anchors(f) { - if let [addr] = xref::funcs_using_string(img, &idx, s).as_slice() - && let Some(sig) = emit::make_sig(img, *addr, CORE_SIG_CAP) - { + let hits = xref::funcs_using_string(img, &idx, s); + let [addr] = hits.as_slice() else { continue }; + // "Exactly one function references it" is attribution by `containing_func` — nearest entry + // at-or-below — and these binaries do not support that on its own: CS2 strips `.eh_frame` + // from game code, so a `[entry, next_entry)` range routinely spans a real function plus + // unindexed neighbours and inherits their strings. `attach_derived_anchors` spends two + // conditions on exactly this hazard when it DERIVES an anchor; using one to locate a + // function is the same claim in the other direction and gets the same test: every + // instruction that loads the string must sit inside the candidate's own flow-reachable + // code. Where it does not, the real referrer is unindexed and this "unique" hit is its + // preceding neighbour — a signature that resolves, validates live, and names the wrong + // function, shipped into the guaranteed tier. Dropping it is the honest degradation. + let Some((reach, _)) = reachable_strings(img, *addr) else { + continue; + }; + let attributable = img + .find_bytes(s.as_bytes()) + .into_iter() + .flat_map(|va| idx.refs_to(va)) + .all(|ip| reach.contains(ip)); + if !attributable { + unreachable += 1; + continue; + } + if let Some(sig) = emit::make_sig(img, *addr, CORE_SIG_CAP) { gd.set_signature(f.name.clone(), "server", sig); - recovered.push(f.name.clone()); + recovered.push((f.name.clone(), *addr)); break; } } } + if unreachable > 0 { + eprintln!( + " string-anchor recovery: {unreachable} anchors REJECTED — the string is loaded from \ + outside the candidate's reachable code, so the unique-referrer hit is a neighbouring \ + function rather than the one the anchor names" + ); + } recovered } @@ -3870,6 +4850,12 @@ fn derive_offsets( match chain_and_vote(&anchors, hv, target_idx) { Some((pred, conf)) if conf >= 80 => { gd.set_offset(f.name.clone(), pred as i64); + // The class whose vtable this slot indexes — half the locator, since an index alone locates + // nothing. It is `class_of(f.name)`: `vtable_offset_timelines` builds `VtFunc::class` that + // way and both `hops` and `bv.fps` are keyed by it, so the class the chain walked and the + // class in the name are one fact, not two. Emitting it saves the consumer a name split; it + // does not add information the name lacks. + gd.set_class(f.name.clone(), f.class.clone()); off_ok += 1; } Some((pred, conf)) => { @@ -4066,7 +5052,8 @@ fn build_hops<'a>( /// still resolved *to a slot of its class vtable* (that slot index is its offset, and requiring a real slot /// auto-rejects decoy matches), chain the offset forward to the target through the order-preserving vtable /// alignments, vote on the target slot, then read `vtable[offset]` in the target and emit a sig there. -/// Consumes the shared vtable pass. Returns the recovered names. +/// Consumes the shared vtable pass. Returns each recovered name with the LIBRARY and address it was +/// relocated to, so the caller can re-measure the footprint there — see `recover_by_string_anchor`. fn recover_virtual_sigs( prof: &GameProfile, virt_funcs: &[(&Func, String)], @@ -4075,7 +5062,7 @@ fn recover_virtual_sigs( target_idx: usize, target_images: &HashMap, gd: &mut model::Gamedata, -) -> Vec { +) -> Vec<(String, &'static str, u64)> { let mut recovered = Vec::new(); for (f, class) in virt_funcs { let Some(hv) = hops.get(class.as_str()) else { @@ -4118,7 +5105,7 @@ fn recover_virtual_sigs( && let Some(sig) = emit::make_sig(&target_images[lib], addr, CORE_SIG_CAP) { gd.set_signature(f.name.clone(), lib_name_from_file(lib), sig); - recovered.push(f.name.clone()); + recovered.push((f.name.clone(), lib, addr)); } } } @@ -4431,6 +5418,44 @@ pub fn backfill_cmd( mod tests { use super::*; + // ---- the identity check's key form. This guard rejects an address the binary itself says is a + // different function, and it is keyed by SHORT library name. A caller holding the FILE name made + // `get` miss, `?` return, and the whole check pass silently — which is indistinguishable from "no + // contradiction found". These pin both halves: that it fires, and that the wrong form is loud. ---- + fn identity_fixture() -> Identity { + Identity(HashMap::from([( + "server".to_string(), + LibIdentity { + // Valve's registry says this address is `CLogicRelay::Trigger`, not what we asked about. + vscript_at: HashMap::from([(0x1000, "Trigger".to_string())]), + class_size: HashMap::from([("CBaseEntity".to_string(), 0x100)]), + }, + )])) + } + + // mov %rdi,%r13 ; cmpb $0,0x7bc(%r13) ; ret — reaches `this+0x7bc`, past a 0x100-byte class. + const REACHES_PAST: &[u8] = &[ + 0x49, 0x89, 0xFD, 0x41, 0x80, 0xBD, 0xBC, 0x07, 0x00, 0x00, 0x00, 0xC3, + ]; + + #[test] + fn a_contradiction_is_found_under_the_short_library_name() { + let img = crate::elf::CodeImage::for_test(0x1000, REACHES_PAST); + let why = identity_fixture() + .contradiction("server", &img, 0x1000, "CBaseEntity::SetAbsOrigin") + .expect("registry disagrees AND the reach exceeds the class — both halves hold"); + assert!(why.contains("Trigger"), "{why}"); + } + + #[test] + #[should_panic(expected = "keyed by SHORT library name")] + fn the_file_name_form_is_loud_rather_than_a_silent_pass() { + let img = crate::elf::CodeImage::for_test(0x1000, REACHES_PAST); + // The same contradiction, looked up by the form `images` is keyed by. Before this was asserted it + // returned `None` — "no contradiction" — on every call. + identity_fixture().contradiction("libserver.so", &img, 0x1000, "CBaseEntity::SetAbsOrigin"); + } + // ---- contribution intake gate (the fork-facing surface) ---- #[test] fn is_iso_date_accepts_only_yyyy_mm_dd() { @@ -4501,28 +5526,30 @@ mod tests { experimental: 0, unresolved: 0, }, + alias_groups: 0, + aliased_names: 0, }, core: BTreeMap::from([( "CBaseEntity::TakeDamage".to_string(), MonoEntry { locator: Entry::signature("server", "48 8B 05 ? ? ? ?"), - class: None, abi: None, provenance: Provenance { source: Some("catalogue".into()), ..Provenance::with_tier(Tier::Core) }, validated: None, + aliases: Vec::new(), }, )]), high_confidence: BTreeMap::from([( "CCSPlayerPawn::IsBot".to_string(), MonoEntry { locator: Entry::offset(42), - class: None, abi: None, provenance: Provenance::with_tier(Tier::SelfNamed), validated: None, + aliases: Vec::new(), }, )]), experimental: BTreeMap::new(), @@ -4539,6 +5566,61 @@ mod tests { assert_eq!(off.offset, Some(42)); } + // ---- link_aliases groups by LOCATOR IDENTITY, across tiers, and refuses to group a bare slot. The + // last of those is the one worth pinning: an `offset` with no `class` names no vtable, so bucketing + // those by slot index would put every unbound "slot 0" in one group and assert 1,080 CS2 names are + // aliases of each other. ---- + #[test] + fn link_aliases_groups_by_locator_and_never_by_a_bare_slot() { + use model::{Entry, MonoEntry, Provenance, Tier}; + let e = |loc: Entry| MonoEntry { + locator: loc, + abi: None, + provenance: Provenance::with_tier(Tier::Core), + validated: None, + aliases: Vec::new(), + }; + let sig = |lib: &str, pat: &str| e(Entry::signature(lib, pat)); + let slot = |class: Option<&str>, n: i64| { + e(Entry { + class: class.map(str::to_string), + ..Entry::offset(n) + }) + }; + + let mut core: BTreeMap = BTreeMap::from([ + ("A::Make".into(), sig("server", "48 8B 05")), + ("Make".into(), sig("server", "48 8B 05")), + // same pattern, DIFFERENT library — a different function, so not a group. + ("Other::Make".into(), sig("engine2", "48 8B 05")), + // bare slots: identical index, no class, so nothing links them. + ("IdleState::OnEnter".into(), slot(None, 0)), + ("HideState::OnEnter".into(), slot(None, 0)), + ]); + let mut high: BTreeMap = BTreeMap::from([ + // cross-tier: joins the `core` pair above, which is the pairing a reader is least likely to spot. + ("UTIL::Make".into(), sig("server", "48 8B 05")), + ("CFoo::Tick".into(), slot(Some("CFoo"), 12)), + ("CFoo::Update".into(), slot(Some("CFoo"), 12)), + ("CBar::Tick".into(), slot(Some("CBar"), 12)), + ]); + + let (groups, covered) = link_aliases(&mut core, &mut high); + assert_eq!((groups, covered), (2, 5)); // the 3-name sig group + the 2-name CFoo group + + // Cross-tier membership, key-sorted, and never self-referential. + assert_eq!(core["A::Make"].aliases, ["Make", "UTIL::Make"]); + assert_eq!(high["UTIL::Make"].aliases, ["A::Make", "Make"]); + // A shared pattern in another library is a different address. + assert!(core["Other::Make"].aliases.is_empty()); + // A class-bound slot groups; the same slot on another class does not join it. + assert_eq!(high["CFoo::Tick"].aliases, ["CFoo::Update"]); + assert!(high["CBar::Tick"].aliases.is_empty()); + // The whole point: two bare slot-0 entries are NOT claimed to be the same function. + assert!(core["IdleState::OnEnter"].aliases.is_empty()); + assert!(core["HideState::OnEnter"].aliases.is_empty()); + } + // ---- annotate_validation must NOT claim validation it didn't perform ("never lies"). A live-confirmed // entry -> Some(true); an entry the oracle KEPT-BUT-COULD-NOT-CHECK (verdict None) -> None (unverified, // NOT true); an entry the oracle dropped (absent from the verdict map) -> Some(false). ---- @@ -4547,10 +5629,10 @@ mod tests { use model::{Counts, Entry, MonoEntry, MonoMeta, Monolith, Provenance, Tier}; let entry = |loc: Entry, tier| MonoEntry { locator: loc, - class: None, abi: None, provenance: Provenance::with_tier(tier), validated: None, + aliases: Vec::new(), }; let mut mono = Monolith { meta: MonoMeta { @@ -4564,6 +5646,8 @@ mod tests { experimental: 0, unresolved: 0, }, + alias_groups: 0, + aliased_names: 0, }, core: BTreeMap::from([ ( diff --git a/src/produce.rs b/src/produce.rs index a9c1935..84b486c 100644 --- a/src/produce.rs +++ b/src/produce.rs @@ -1,6 +1,6 @@ //! CI orchestration + the LIVE half of the engine. `produce` runs the whole per-game build in one -//! long-running command (derive → fold → validate-live → typed netvars → fold-model), assembling the monolith -//! artifact set; `classify-change` and `filter-corpus` are the CI *branch* primitives (is this buildid worth +//! long-running command (derive → fold → validate-live → typed netvars → fold-model), merging every +//! stage's account of a function into the one shipped artifact; `classify-change` and `filter-corpus` are the CI *branch* primitives (is this buildid worth //! a release? which corpus builds are code-distinct?). Everything that attaches to and drives a RUNNING //! server lives here, not in `pipeline`: the semantic oracle (`run_live_oracle`, pawn probing, `fuzz_live_run`), //! `integration_test_cmd`, the live validators (`validate_live_cmd`/`verify_live_cmd` + their sig/offset @@ -23,9 +23,15 @@ use serde_json::{Value, json}; use std::collections::{BTreeMap, HashMap, HashSet}; use std::path::{Path, PathBuf}; -/// The per-game derive INPUTS, whether passed as loose files or unpacked from a `--seed` bundle. All of -/// `mappings/`'s non-contribution content collapses into one release artifact; the loose-flag form stays -/// for dev/verify. The model is NOT bundled here — it is its own (streamed-write) artifact, `--corpus-model`. +/// The per-game derive INPUTS a `--seed` bundle carries, whether passed as loose files or unpacked from +/// the bundle: the catalogue plus the naming-harvest sections, and a folded snapshot of the contributions +/// inbox. +/// +/// NOT the complete input surface, and the difference matters when tracking down where a fact came from. +/// The judged/authored inputs stay separate flags (`--prototypes`, `--semantics`, `--ehandle-classes`), +/// the corpus model is its own streamed-write artifact (`--corpus-model`), and on the loose-flag path the +/// derive additionally reads `/contributions//*.json` implicitly — which is +/// why `unpack_seed` writes the bundle's contributions beside the catalogue rather than anywhere else. pub struct SeedInputs { pub catalogue: PathBuf, /// Optional bring-up refinements — a seed without them still derives the full catalogue. @@ -38,8 +44,9 @@ pub struct SeedInputs { /// Un-bundle a `--seed` file — one JSON object whose sections are the verbatim contents of the former /// loose files — into on-disk inputs under `work/`, so the derive reads them exactly as before (the fold -/// re-parses, so a serde round-trip of a section changes nothing downstream). Sections are optional except -/// the three the derive requires; a missing optional section (e.g. Dota has no `full_names` yet) stays None. +/// re-parses, so a serde round-trip of a section changes nothing downstream). Only `catalogue` is required; +/// every other section is optional and a missing one stays `None` — a game with no naming harvest yet ships +/// a seed with no `promotable`, and `seed-dota2.json` carries no `contributions`. pub fn unpack_seed(prof: &GameProfile, seed: &Path, work: &Path) -> Result { let v: Value = serde_json::from_str(&std::fs::read_to_string(seed)?) .with_context(|| format!("parse seed {}", seed.display()))?; @@ -57,8 +64,16 @@ pub fn unpack_seed(prof: &GameProfile, seed: &Path, work: &Path) -> Result/), so the derive's // `load_contributions` (which reads catalogue.parent()) folds them exactly as the loose form does from // mappings/contributions/. The repo dir stays the human PR inbox; the seed carries a folded snapshot. + let cdir = work.join("contributions").join(prof.game_key); + // CLEARED first, and it has to be: `load_contributions` folds every file it finds in this directory, + // so a leftover from an earlier run under a reused --out-dir would be merged into a build whose seed + // never mentioned it. The artifact would then depend on what happened to be on disk rather than on + // its inputs, which is the one property a reproducible derive cannot give up. + if cdir.exists() { + std::fs::remove_dir_all(&cdir) + .with_context(|| format!("clear stale contributions in {}", cdir.display()))?; + } if let Some(Value::Object(files)) = v.get("contributions") { - let cdir = work.join("contributions").join(prof.game_key); std::fs::create_dir_all(&cdir)?; for (fname, content) in files { std::fs::write(cdir.join(fname), serde_json::to_string(content)?)?; @@ -77,19 +92,36 @@ pub fn unpack_seed(prof: &GameProfile, seed: &Path, work: &Path) -> Result Result> { + #[derive(serde::Deserialize)] + struct SemanticsDoc { + descriptions: BTreeMap, + } + let text = std::fs::read_to_string(path).with_context(|| format!("read {}", path.display()))?; + let doc: SemanticsDoc = + serde_json::from_str(&text).with_context(|| format!("parse {}", path.display()))?; + Ok(doc.descriptions) +} + /// Inputs to [`produce_cmd`], grouped so the CLI passes ONE named-field value instead of a long positional /// list (where two same-typed `Option<&Path>` could silently transpose). Built by the clap front-end after /// it resolves the corpus source and the seed-or-loose derive inputs. pub struct ProduceArgs<'a> { pub prof: &'a GameProfile, /// A launchable game install. `Some` → the full build (validate-live + typed netvars); `None` → OFFLINE - /// (gamedata + model only, no server). This is the whole offline/full switch — there is no separate flag. + /// (no server, so no live validation and a `null` schema). The whole offline/full switch — there + /// is no separate flag. pub game: Option<&'a Path>, pub build: Option<&'a Path>, pub lib: &'a str, pub catalogue: &'a Path, - /// Reference-signal source paths — exactly one is `Some` (validated in `produce_cmd`). A `--corpus-model` - /// is parsed ONCE here so the derive can borrow it and the sidecar fold can consume the same instance. + /// Reference-signal source paths — exactly one is `Some`, enforced at the top of `produce_cmd` rather + /// than only by clap, because an embedder calling `produce_cmd` directly bypasses the CLI. A + /// `--corpus-model` is parsed ONCE here so the derive can borrow it and the sidecar fold can consume + /// the same instance. pub corpus: Option<&'a Path>, pub corpus_model: Option<&'a Path>, /// Class scope for the sidecar model fold — must match the scope the input model was distilled with. @@ -100,11 +132,15 @@ pub struct ProduceArgs<'a> { pub full_names: Option<&'a Path>, pub extra_offsets: Option<&'a Path>, pub extra_sigs: Option<&'a Path>, - /// Declared prototypes to JUDGE against this build's measured footprints -> `abi-.json`. - /// Static repo input, not rolling state, so it is passed as a path rather than fetched. + /// Declared prototypes to JUDGE against this build's measured footprints. Static repo input, not + /// rolling state, so it is passed as a path rather than fetched. pub prototypes: Option<&'a Path>, + /// Authored function descriptions (`mappings/semantics-.json`), folded in beside each + /// function. A repo input on the same terms as `prototypes` — reviewed, committed, and keyed on the + /// NAME, so it survives every build that does not rename a function. Optional. + pub semantics: Option<&'a Path>, /// Valve's `PVAL_EHANDLE` entity-class naming (`mappings/ehandle-classes.json`) — a static repo - /// input the bindings artifact is enriched with. Optional. + /// input the Pulse surface is enriched with. Optional. pub ehandle_classes: Option<&'a Path>, pub sig_cap: usize, pub version: &'a str, @@ -115,11 +151,11 @@ pub struct ProduceArgs<'a> { } /// The whole per-game build in ONE command, entirely in memory — derive → fold → (if a game is given) -/// validate-live + typed netvars → fold model — writing the release set ONCE (`gamedata-.json` + -/// `netvars-.json` [full only] + `model-.json` [corpus-model source] + `manifest.json`). No -/// per-stage intermediate files: the derive hands its rendered gamedata straight to the fold, the fold's -/// monolith is annotated live in place, the schema is read straight off the process. Offline vs full is -/// decided solely by whether a launchable `game` is present. +/// validate-live + typed netvars → judge prototypes → merge → fold model — writing the release set ONCE +/// (`rosetta-.json` + `model-.json` [corpus-model source] + `manifest.json`). No per-stage +/// intermediate files: the derive hands its rendered gamedata straight to the fold, the fold's catalogue +/// is annotated live in place, the schema is read straight off the process, and the merge folds all of +/// it together. Offline vs full is decided solely by whether a launchable `game` is present. pub fn produce_cmd(a: ProduceArgs) -> Result<()> { let ProduceArgs { prof, @@ -137,6 +173,7 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { extra_offsets, extra_sigs, prototypes, + semantics, ehandle_classes, sig_cap, version, @@ -145,6 +182,14 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { map, bots, } = a; + // Exactly one reference-signal source, checked HERE rather than only in clap: an embedder calls + // `produce_cmd` directly, and the `(Some(m), _)` arm below silently drops `--corpus` when both are + // given — a derive that quietly used a different signal source than the one the caller named. + ensure!( + corpus.is_some() != corpus_model.is_some(), + "pass exactly ONE of --corpus / --corpus-model — they are two different \ + reference-signal sources and only one can be used" + ); // `build` (the on-disk libs for make-sig + live validation) defaults to the game when one is given (so // the validated libs match the running server), else the derive target. let build = build.unwrap_or_else(|| game.unwrap_or(target)); @@ -159,6 +204,7 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { Some(m) => Some(load_model(m)?), None => None, }; + // The `ensure!` above has already ruled out both-or-neither. let source = match (&cmodel, corpus) { (Some(m), _) => CorpusSource::Model(m), (None, Some(c)) => CorpusSource::Binaries(c), @@ -171,7 +217,7 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { let Folded { mut mono, cssharp, - bindings, + mut bindings, } = build_gamedata_cmd( prof, FoldArgs { @@ -183,6 +229,7 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { flagged: &derived.flagged, unverified: &derived.unverified, abi: &derived.abi, + anchors: &derived.anchors, sig_cap, version, full_names, @@ -193,6 +240,22 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { }, )?; + // The DERIVED-SURFACE collapse floor, checked here rather than left to the live oracle — and it has to + // be, because that gate is a pass RATE over entries that reached the gamedata document. A signature + // that failed to resolve never enters it, so a derive emitting forty functions instead of four + // thousand passes at 100%. Every in-binary table already has one of these; the tool's primary product + // did not. See `GameProfile::min_core_functions`. + let shipped = mono.meta.counts.core + mono.meta.counts.high_confidence; + ensure!( + shipped >= prof.min_core_functions, + "derived only {shipped} shipped functions ({} core + {} high-confidence, floor {}) — a corpus \ + model from another game or branch, a --target from the wrong build, or a library missing from \ + the tree all land here; refusing to publish a collapsed derive", + mono.meta.counts.core, + mono.meta.counts.high_confidence, + prof.min_core_functions + ); + // 2. live stages — ONLY when a launchable game is given: validate (annotate the monolith in place) + the // typed netvars (read straight off the live process). produce launches + tears down its own server. let mut netvars: Option = None; @@ -207,6 +270,44 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { { annotate_validation(&mut mono, &verdicts); } + // The one VScript field the fold cannot derive. Done here rather than inside the oracle + // because it ENRICHES the artifact instead of verifying a claim about it, and because + // `integration-test` — which shares the oracle — builds no artifact to enrich. + if !bindings.vscript.is_empty() { + let img = load_lib(build, lib)?; + let live = live::LiveProcess::attach(pid)?; + // `lib` is already the mapped filename (`libserver.so`), so it is passed through + // rather than rebuilt. An earlier revision spelled it `lib{lib}.so`, produced + // `liblibserver.so.so`, and the `if let Some` swallowed the miss — a silent zero that + // looks exactly like "this build has no classes to attribute". Hence the else. + match live.base(lib) { + Some(base) => { + let (set, classes) = + attribute_vscript_classes(&live, base, &img, &mut bindings); + eprintln!( + " VScript classes (live-only): {set} of {} bindings attributed across \ + {classes} classes", + bindings.vscript.len() + ); + } + None => eprintln!( + " WARNING: {lib} is not mapped in the live server, so no VScript class \ + could be attributed — the artifact will ship without the field the \ + `moddota` format groups by." + ), + } + // Live-only, so it is floored HERE rather than beside the other binding floors below: + // those run on every build, and zero is the correct offline answer. See + // GameProfile::min_vscript_classed. + ensure!( + bindings.meta.vscript_classed >= prof.min_vscript_classed, + "attributed only {} VScript bindings to an owning class (floor {}) — the live \ + descriptor walk likely broke; refusing to ship a binding registry the `moddota` \ + format would render as empty", + bindings.meta.vscript_classed, + prof.min_vscript_classed + ); + } let nv = schema::live_schema(prof, pid, build, &label_of(target))?; // Gate the type-resolution the schema-layout oracle can't see (see NETVARS_MIN_TYPED): a // wholesale CSchemaType reshape resolves every field 'untyped' and would otherwise ship a @@ -227,6 +328,16 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { typed_frac * 100.0, NETVARS_MIN_TYPED * 100.0 ); + // The CLASS table first, because everything below rests on it — and because it is the + // one table whose collapse no other check here would catch. See + // GameProfile::min_schema_classes for why the live oracle's own class gate does not. + ensure!( + nv.classes.len() >= prof.min_schema_classes, + "recovered only {} schema classes (floor {}) — the SchemaClassInfoData_t layout \ + likely moved; refusing to ship a schema whose class table collapsed", + nv.classes.len(), + prof.min_schema_classes + ); // The enum table is read by shape like the class table, so a Valve reshape yields zero // enums rather than wrong ones — safe, but silent. See GameProfile::min_schema_enums. ensure!( @@ -236,6 +347,12 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { nv.meta.enums, prof.min_schema_enums ); + eprintln!( + " typed netvars: {} classes, {} typed fields, {} untyped", + nv.classes.len(), + nv.meta.typed, + nv.meta.untyped + ); netvars = Some(nv); Ok(()) })(); @@ -243,29 +360,12 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { let _ = server.child.wait(); result?; // tear the server down first, THEN surface any stage error } - None => eprintln!( - "\n===== offline: no --game-dir -> gamedata + model only (no live validate / netvars) =====" - ), + None => { + eprintln!("\n===== offline: no --game-dir -> no live validate, no typed schema =====") + } } - // 3. write the release set ONCE. - let gd_name = format!("gamedata-{token}.json"); - std::fs::write(p(&gd_name), serde_json::to_string_pretty(&mono)?) - .with_context(|| format!("write {gd_name}"))?; - let mut artifacts = vec![gd_name]; - if let Some(schema) = &netvars { - let nv_name = format!("netvars-{token}.json"); - std::fs::write(p(&nv_name), serde_json::to_string_pretty(schema)?) - .with_context(|| format!("write {nv_name}"))?; - eprintln!( - " typed netvars -> {nv_name}: {} classes, {} typed fields, {} untyped", - schema.classes.len(), - schema.meta.typed, - schema.meta.untyped - ); - artifacts.push(nv_name); - } - // The declared callable surface. Gated PER TABLE, not on the sum: each is matched by its own record + // 3. the declared callable surface. Gated PER TABLE, not on the sum: each is matched by its own record // shape, so Valve reshaping one collapses that one alone — and a summed floor stays satisfied by the // tables that still work. See GameProfile::min_pulse_bindings. for (what, got, floor) in [ @@ -279,6 +379,11 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { bindings.meta.pulse_typed, prof.min_pulse_typed, ), + ( + "host-callable Pulse shims", + bindings.meta.pulse_callable, + prof.min_pulse_callable, + ), ( "entity-IO records", bindings.meta.entity_inputs + bindings.meta.entity_outputs, @@ -294,6 +399,8 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { bindings.meta.commands, prof.min_commands, ), + ("ConVars", bindings.meta.convars, prof.min_convars), + ("VScript bindings", bindings.meta.vscript, prof.min_vscript), ] { ensure!( got >= floor, @@ -301,23 +408,85 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { likely moved; refusing to ship a release whose declared surface silently collapsed" ); } - if !bindings.is_empty() { - let bd_name = format!("bindings-{token}.json"); - std::fs::write(p(&bd_name), serde_json::to_string_pretty(&bindings)?) - .with_context(|| format!("write {bd_name}"))?; - eprintln!( - " binding registry -> {bd_name}: {} Pulse bindings ({} typed), {} entity-IO inputs, {} outputs, {} entity classnames, {} console commands", - bindings.meta.pulse, - bindings.meta.pulse_typed, - bindings.meta.entity_inputs, - bindings.meta.entity_outputs, - bindings.meta.entity_classes, - bindings.meta.commands - ); - artifacts.push(bd_name); - } + // 4. the prototype manifest — the declared parameter types, each judged against the footprint measured + // in THIS build. Built before the merge rather than written beside it: a declaration and the + // measurement that judges it are two facts about one function, and the merged record holds both. + let manifest_abi = match prototypes { + Some(pp) => { + // The script VM's declared return types, keyed by the C++ name the fold used for the locator, + // so a binding's `void` reaches the manifest instead of the register class measurement infers. + let vs_ret: BTreeMap = bindings + .vscript + .iter() + .filter_map(|v| v.ret.as_ref().map(|r| (v.cpp.clone(), r.clone()))) + .collect(); + let man = crate::prototypes::build_manifest( + pp, + &mono, + netvars.as_ref().map(|n| &n.types), + Some(&vs_ret), + )?; + let n = |k: &str| man.meta.counts.get(k).copied().unwrap_or(0); + eprintln!( + " prototypes: {} judged ({} verified, {} mismatch, {} unverified, {} return-only, \ + {} ambiguous)", + man.functions.len(), + n("status:verified"), + n("status:mismatch"), + n("status:unverified"), + n("status:return-only"), + n("core:overloaded") + n("high_confidence:overloaded") + ); + Some(man) + } + None => None, + }; - // 4. sidecar: fold model N -> N+1 (offline), emitted when a --corpus-model was the source. The derive has + // 5. authored descriptions — a repo input like the prototypes, keyed on the NAME. A name this build + // does not ship simply finds no record; the join count below is what makes that visible. + let descriptions = match semantics { + Some(sp) => read_semantics(sp)?, + None => BTreeMap::new(), + }; + + // 6. merge and write the release artifact ONCE. Everything above is a different STAGE's account of + // the same functions, so it ships as one record per function rather than four files to join. + let rosetta = model::merge(mono, manifest_abi, Some(bindings), netvars, descriptions); + let art_name = format!("rosetta-{token}.json"); + std::fs::write(p(&art_name), serde_json::to_string_pretty(&rosetta)?) + .with_context(|| format!("write {art_name}"))?; + let j = &rosetta.meta.joined; + eprintln!( + "\n {art_name}: {} functions ({} prototypes, {} entity-IO + {} command + {} VScript bindings, \ + {} descriptions), {} unresolved, schema {}", + rosetta.functions.len(), + j.prototypes, + j.bindings.entity_input, + j.bindings.command, + j.bindings.vscript, + j.descriptions, + rosetta.unresolved.len(), + match &rosetta.schema { + Some(s) => format!("{} classes", s.classes.len()), + None => "null (offline build)".to_string(), + } + ); + let u = &rosetta.surfaces.unjoined; + eprintln!( + " surfaces: {} Pulse bindings, {} entity outputs, {} classnames, {} ConVars, \ + {} declared rows with no function record of their own ({} entity-IO, {} commands, {} VScript)", + rosetta.surfaces.pulse.len(), + rosetta.surfaces.entity_outputs.len(), + rosetta.surfaces.entity_classes.len(), + rosetta.surfaces.convars.len(), + u.entity_inputs.len() + u.commands.len() + u.vscript.len(), + u.entity_inputs.len(), + u.commands.len(), + u.vscript.len() + ); + let mut artifacts = vec![art_name]; + + // 7. sidecar: fold model N -> N+1 (offline), emitted when a --corpus-model was the source. The derive has // returned, so its read-only borrow of the model is done — the fold consumes the same instance by value. if let Some(model) = cmodel { eprintln!("\n===== fold model N -> N+1 (sidecar) ====="); @@ -326,29 +495,7 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { artifacts.push(model_name); } - // The prototype manifest: the declared parameter types, each judged against the footprint measured - // in THIS build. Emitted beside the gamedata because the two answer different questions — where a - // function is, and how to call it — and a consumer needs both to make a call at all. - if let Some(pp) = prototypes { - let man = crate::prototypes::build_manifest(pp, &mono, netvars.as_ref().map(|n| &n.types))?; - let ab_name = format!("abi-{token}.json"); - std::fs::write(p(&ab_name), serde_json::to_string_pretty(&man)?) - .with_context(|| format!("write {ab_name}"))?; - let n = |k: &str| man.meta.counts.get(k).copied().unwrap_or(0); - eprintln!( - " prototype manifest -> {ab_name}: {} entries ({} verified, {} mismatch, {} unverified, \ - {} return-only, {} ambiguous)", - man.functions.len(), - n("status:verified"), - n("status:mismatch"), - n("status:unverified"), - n("status:return-only"), - n("core:overloaded") + n("high_confidence:overloaded") - ); - artifacts.push(ab_name); - } - - // 5. the interop manifest. + // 8. the interop manifest. let manifest = json!({ "version": version, "artifacts": artifacts }); std::fs::write(p("manifest.json"), serde_json::to_string_pretty(&manifest)?)?; eprintln!( @@ -362,9 +509,24 @@ pub fn produce_cmd(a: ProduceArgs) -> Result<()> { /// Multiset of normalized function-body digests for one image: digest -> how many functions carry it. /// Identical-code-folded clones (many tiny thunks share a body) collapse to one digest with a count >1, /// which the min-count intersection in `classify_change_cmd` then handles exactly. +/// +/// **Enumerated over the same union `xref::XrefIndex::build` uses, and it has to be.** CS2 strips +/// `.eh_frame` from the game code — `.eh_frame_hdr` describes 8,327 of libserver's ~70,000 functions, all +/// of them in the statically-linked runtime tail — so digesting the FDE list alone samples the ~12% of the +/// binary least likely to change and calls it the whole. A gameplay-only patch then shows zero changed +/// digests and `classify-change` answers `skip`: "no release needed", about a build whose gamedata moved. +/// Relocation code-pointers ∪ decoded call targets ∪ FDE starts covers the gameplay region too. +/// +/// A `[start, next_start)` range can span a real function plus an unindexed neighbour, so a digest is not +/// a claim about one function. It does not need to be: what both callers compare is the MULTISET, and a +/// range that is stable across two builds carries the same digest in both whatever it contains. fn function_digests(img: &CodeImage) -> HashMap { + let entries = crate::locate::function_entries(img); + let mut m: HashMap = HashMap::new(); - for (start, end) in img.eh_frame_functions() { + for (i, &start) in entries.iter().enumerate() { + // The last entry runs to the end of its executable block, which `normalized_digest` clamps to. + let end = entries.get(i + 1).copied().unwrap_or(u64::MAX); if let Some(d) = emit::normalized_digest(img, start, end) { *m.entry(d).or_default() += 1; } @@ -462,7 +624,8 @@ pub fn classify_change_cmd( let db = function_digests(&load_lib(new, lib)?); ensure!( !da.is_empty() && !db.is_empty(), - "no .eh_frame functions in one of the builds" + "no functions enumerated in one of the builds — refusing to classify rather than report `skip` \ + from an empty sample" ); let ch = digest_change(&da, &db); let (n_prev, n_new, common, changed, removed, frac) = ( @@ -683,14 +846,6 @@ fn pawn_chain(prof: &GameProfile, img: &CodeImage, class: &str) -> (HashSet { @@ -702,6 +857,14 @@ struct PawnProbe<'a> { vt_slots: usize, } +/// Semantic CALL sweep: the composition of the ABI shape (part a) with live calling (part b). For +/// every derived vtable-method offset the pawn actually carries whose ABI shape is `this`-only and +/// whose name reads as a pure query, CALL `vtable[offset](pawn)` via ptrace and confirm it returns +/// cleanly. This turns the single hand-picked IsPlayerPawn probe into a sweep over every safely- +/// callable derived method — the semantic gate for a wrong/absent offset. A faulting call is caught +/// and the process restored (call_remote suppresses the signal), so a bad offset degrades to a FLAG, +/// never a crash. It is a smoke test, not an identity proof: a clean return proves the slot is a +/// callable this-method, while the OFFLINE abi-diff proves the prototype itself didn't move. fn callable_method_sweep( prof: &GameProfile, p: &PawnProbe, @@ -803,7 +966,6 @@ impl Lcg { /// fields (for netvar reads). struct LiveClass { vtable_slot0: u64, - vt_slots: usize, query_methods: Vec<(String, usize)>, // (gamedata name, vtable slot) fields: Vec<(String, i32)>, // (netvar, offset) } @@ -813,10 +975,10 @@ struct LiveClass { /// on them, which is the whole point of running the checks. Absent this, the netvars half of a release /// was governed by nothing but a human reading a log line. #[derive(Default, Clone, Copy)] -pub struct OracleCounts { - pub checked: u32, - pub ok: u32, - pub faulted: u32, +pub(crate) struct OracleCounts { + pub(crate) checked: u32, + pub(crate) ok: u32, + pub(crate) faulted: u32, } impl OracleCounts { @@ -854,9 +1016,13 @@ const ORACLE_MIN_SAMPLE: u32 = 25; /// wholesale type-record reshape, not on the odd unresolved field. const NETVARS_MIN_TYPED: f64 = 0.5; -/// The live-fuzzing loop against an ALREADY-ATTACHED server — shared by the standalone -/// command and the `integration-test` harness (which owns the server, so no separate launch and no fixed -/// wall-clock: it runs exactly `iterations` probes and stops). +/// The live-fuzzing loop against an ALREADY-ATTACHED server — shared by `produce`'s live stage and the +/// `integration-test` harness. Both own the server already, so there is no separate launch and no fixed +/// wall-clock: it runs exactly `iterations` probes and stops. +/// +/// `seed` is passed FIXED (`0x5137`) by both callers and no flag varies it, so every run replays the same +/// probe sequence. That is deliberate for a release gate — a failure is reproducible by re-running the +/// same command — and it is the reason this is a smoke test rather than a search. fn fuzz_live_run( prof: &GameProfile, pid: u32, @@ -912,17 +1078,25 @@ fn fuzz_live_run( if query_methods.is_empty() && fields.is_empty() { continue; } + // No `vt_slots` here: `query_methods` is already filtered to `slot < vt.slots.len()` above, so + // carrying the bound only to re-test it downstream reads as a guard that can fire when it cannot. classes.push(LiveClass { vtable_slot0: vt.slot0, - vt_slots: vt.slots.len(), query_methods, fields, }); } - ensure!( - !classes.is_empty(), - "no probeable classes (gamedata offsets with RTTI vtables) — is --gamedata right?" - ); + // A SMOKE TEST with nothing to probe is a smoke test that found no problems. Aborting here would + // fail a release that is already fully derived and live-validated, on the grounds that an optional + // extra check had no sample — the opposite of "degrade or stop loudly": the loud part is right, the + // stopping is not. Zero probeable classes is a real thing to say, so say it and return. + if classes.is_empty() { + eprintln!( + " fuzz-live SKIPPED: no probeable classes (no gamedata offset resolves to a class with an \ + RTTI vtable and a this-only query method). Nothing was fuzzed; nothing failed." + ); + return Ok(()); + } let n_methods: usize = classes.iter().map(|c| c.query_methods.len()).sum(); eprintln!( "fuzz-live: {} probeable classes, {n_methods} this-only query methods, {} iterations, seed {seed}", @@ -946,9 +1120,6 @@ fn fuzz_live_run( let do_call = !c.query_methods.is_empty() && (c.fields.is_empty() || rng.next() & 1 == 0); if do_call { let (name, slot) = &c.query_methods[rng.below(c.query_methods.len())]; - if *slot >= c.vt_slots { - continue; - } let Ok(vtp) = live.read_u64(inst) else { continue; }; @@ -1130,74 +1301,179 @@ pub(crate) fn run_live_oracle( health, }) = pawn_ctx { - // A pawn selected back at pawn-probe time can be freed during the wide schema walk that ran in - // between (a bots-deathmatch pawn dies and is unmapped). That is a property of the live process, not - // of the fully-derived in-memory release — so a read failure here must DEGRADE (skip the smoke test), - // not `?`-propagate past produce's fail-fast and abort the release. Same treatment as - // `callable_method_sweep` below. `(|| -> Option ...)()` lets one unreadable access bail the probe. - println!("\n=== CALL test (ptrace injection — the thing read-only can't do) ==="); - // The slot THIS build derived, not the constant frozen in the profile. The two agree today, but - // the catalogue shows this slot taking four distinct values in nine months, and a stale index - // does not fail loudly — it ptrace-CALLS whatever function now occupies it, on the same live - // process this run then reads typed netvars from and fuzzes 500 times. The frozen value survives - // only as a fallback for a run with no rendered gamedata to consult. - let is_player_pawn = doc - .as_ref() - .and_then(|d| d.get("CBaseEntity::IsPlayerPawn")) - .and_then(|e| render::entry_from_value(e).offset) - .and_then(|o| u64::try_from(o).ok()) - .unwrap_or(pa.is_player_pawn_slot); - if is_player_pawn != pa.is_player_pawn_slot { - eprintln!( - " NOTE derived IsPlayerPawn slot {is_player_pawn} differs from the profile's frozen \ + // A closure so a "nothing to test" exit skips the CALL test ALONE — the Pulse shim and descriptor + // oracles below are independent of it and must still run. + (|| { + println!("\n=== CALL test (ptrace injection — the thing read-only can't do) ==="); + // The slot THIS build derived, never the constant frozen in the profile. `IsPlayerPawn` is an + // offset-only name, so `derive_offsets` drops it into `unresolved` whenever no anchor chains or + // the recency-weighted vote falls under the bar — and it does that precisely in the builds where + // the slot MOVED. Falling back to the frozen index there would be the worst possible moment: + // the catalogue shows this slot taking six distinct values in ten months, and the fallback would + // ptrace-CALL whatever now occupies a stale index, on the same process this run goes on to read + // typed netvars from and fuzz 500 times, then print PASS about an offset the gamedata lacks. + // `pa.is_player_pawn_slot` is therefore a RECORDED REFERENCE VALUE, cross-checked against and + // never itself called. + let derived = doc + .as_ref() + .and_then(|d| d.get("CBaseEntity::IsPlayerPawn")) + .and_then(|e| render::entry_from_value(e).offset) + .and_then(|o| u64::try_from(o).ok()); + // The two ways of having no slot are different facts and get different sentences: an + // `integration-test` run with no `--gamedata` is normal, while a `produce` run that derived + // nothing is a statement about this build. One WARNING covering both blamed the derivation for + // the perfectly ordinary case. + let Some(is_player_pawn) = derived else { + match doc { + None => println!( + " no gamedata document supplied, so there is no derived slot to test — skipping. \ + (`integration-test` without --gamedata; `produce` always supplies one.)" + ), + Some(_) => eprintln!( + " WARNING this build derived NO IsPlayerPawn slot — it is offset-only, so it lands \ + in `unresolved` when no anchor chains or the vote is under the bar. SKIPPING the \ + CALL test rather than injecting a call at the profile's recorded {}. The semantic \ + sweep below still covers every offset this build DID derive.", + pa.is_player_pawn_slot + ), + } + return; + }; + if is_player_pawn != pa.is_player_pawn_slot { + eprintln!( + " NOTE derived IsPlayerPawn slot {is_player_pawn} differs from the profile's recorded \ {} — using the derived one; update GameProfile::is_player_pawn_slot", - pa.is_player_pawn_slot - ); - } - let probed = (|| -> Option<()> { - let hp = live.read_i32(pawn + health).ok()?; - println!("alive pawn {pawn:#014x}, live m_iHealth = {hp}"); - let vtable_ptr = live.read_u64(pawn).ok()?; - let func = live.read_u64(vtable_ptr + is_player_pawn * 8).ok()?; - // Same gate the other two `call_remote` sites apply: never inject a call to something that - // is not executable code in the live process. - if !live.is_exec(func) { - println!( - " slot {is_player_pawn} does not point at live executable code — skipping" - ); - return None; - } - println!( - "calling IsPlayerPawn (gamedata vtable offset {is_player_pawn}, fn {func:#x}) on the live pawn..." - ); - let r = live::call_remote(pid as i32, func, &[pawn]).ok()?; - let ret = r.rax & 0xff; - println!( - " -> returned {ret} (expect 1=true), clean_return={}", - r.clean_return - ); - if r.clean_return && ret == 1 { - println!( - " PASS: gamedata offset {is_player_pawn} semantically IS IsPlayerPawn — verified by CALLING it." - ); - } else { - println!( - " (unexpected result — offset may be wrong, or the pawn wasn't a player pawn)" + pa.is_player_pawn_slot ); } - Some(()) + // A pawn selected back at pawn-probe time can be freed during the wide schema walk that ran in + // between (a bots-deathmatch pawn dies and is unmapped). That is a property of the live process, + // not of the fully-derived in-memory release — so a read failure here must DEGRADE rather than + // `?`-propagate past produce's fail-fast and abort. Each bail names the reason it actually hit: + // one message said "pawn became unreadable" for every exit, including the one where the pawn read + // fine and the SLOT was wrong, which reframed a stale offset as a benign live-process race. + let outcome = (|| -> Result<(), String> { + let hp = live + .read_i32(pawn + health) + .map_err(|_| format!("pawn {pawn:#x} became unreadable (freed mid-oracle?)"))?; + println!("alive pawn {pawn:#014x}, live m_iHealth = {hp}"); + let vtable_ptr = live + .read_u64(pawn) + .map_err(|_| format!("pawn {pawn:#x} has no readable vtable pointer"))?; + let func = live + .read_u64(vtable_ptr + is_player_pawn * 8) + .map_err(|_| { + format!("slot {is_player_pawn} is not readable in the live vtable") + })?; + // Same gate the other two `call_remote` sites apply: never inject a call to something that + // is not executable code in the live process. + if !live.is_exec(func) { + return Err(format!( + "slot {is_player_pawn} does not point at live executable code — the derived offset \ + is wrong or stale, which is a fact about the BUILD, not about this process" + )); + } + println!( + "calling IsPlayerPawn (gamedata vtable offset {is_player_pawn}, fn {func:#x}) on the live pawn..." + ); + let r = live::call_remote(pid as i32, func, &[pawn]) + .map_err(|e| format!("the call itself could not be made: {e:#}"))?; + let ret = r.rax & 0xff; + println!( + " -> returned {ret} (expect 1=true), clean_return={}", + r.clean_return + ); + if r.clean_return && ret == 1 { + println!( + " PASS: gamedata offset {is_player_pawn} semantically IS IsPlayerPawn — verified by CALLING it." + ); + } else { + println!( + " (unexpected result — offset may be wrong, or the pawn wasn't a player pawn)" + ); + } + Ok(()) + })(); + if let Err(why) = outcome { + eprintln!(" CALL test SKIPPED: {why}"); + } })(); - if probed.is_none() { - eprintln!(" CALL test SKIPPED: pawn {pawn:#x} became unreadable (freed mid-oracle?)"); - } } + // The Pulse shim contract, checked by calling. Independent of `--gamedata`: it verifies a claim + // the binding registry makes, not a gamedata locator, so it runs on every live oracle. + println!( + "\n=== Pulse invocation shims: calling every `args-only` binding with a sentinel handle ===" + ); + // Read once, used by both verifiers below — see `PulseRead`. + let pulse = PulseRead::of(&img, 8); + let (shims_probed, shims_ok, shims_faulted, shim_notes) = + verify_pulse_shims(&live, pid, base, &img, &pulse); + println!(" {shims_ok} / {shims_probed} returned cleanly"); + for n in shim_notes.iter().take(8) { + println!(" {n}"); + } + // Probing NOTHING must not read as a pass. `OracleCounts::pass_rate` returns 1.0 for zero checks — + // correct in general, since a stage with nothing to do is not a failure — but here zero means the + // eligibility filter stopped matching, which is precisely the silent collapse the emitted + // `call.needs` field would then be making claims about. The profile floor guarantees the callable + // rows exist, so an empty probe set is a contradiction worth shouting about. + if shims_probed == 0 { + println!( + " WARNING: no shim was eligible to probe. The floor guarantees host-callable rows exist, so \ + this means the probe's own filter no longer matches them — the emitted `call.needs` is \ + UNVERIFIED for this build." + ); + } + // A fault means the emitted argument contract is wrong, which is a claim the artifact should not be + // making. Anything else (a clean non-`-2` return) is a different status protocol, not a broken contract, + // so it counts as OK. + verdicts.push(( + "pulse-shims", + OracleCounts { + checked: shims_probed as u32, + ok: shims_ok as u32, + // COUNTED where the fault happens, not reconstructed by grepping the code's own prose for + // the word it printed — an edit to that sentence used to silently change this number. + faulted: shims_faulted as u32, + }, + )); + + // The reconstructed Pulse signatures, against the descriptors the server actually holds. Like the + // shim check this verifies a claim the binding registry makes rather than a gamedata locator, so it + // runs on every live oracle. + println!( + "\n=== Pulse descriptors: the reconstructed signature vs the one the live server holds ===" + ); + let (desc_checked, desc_agree, desc_notes) = + verify_pulse_descriptors(&live, pid, base, &img, &pulse); + println!(" {desc_agree} / {desc_checked} agree"); + for n in desc_notes.iter().take(8) { + println!(" {n}"); + } + if desc_checked == 0 { + println!( + " WARNING: no descriptor region could be read. Either the accessors stopped populating on \ + call or the region layout moved — either way the emitted `params` are UNVERIFIED for this \ + build." + ); + } + verdicts.push(( + "pulse-descriptors", + OracleCounts { + checked: desc_checked as u32, + ok: desc_agree as u32, + faulted: (desc_checked - desc_agree) as u32, + }, + )); + let live_result = if gamedata.is_some() { println!("\n=== validate-live: derived gamedata vs the running server ==="); // Parsed once, above — it feeds the CALL test's slot, sig/offset validation, and the pawn // sweep/fuzz below. let doc = doc.expect("parsed above whenever `gamedata` is Some"); - let (kept, entry_verdicts) = validate_live_cmd(prof, pid, build, &doc)?; + let (kept, entry_verdicts, val_counts) = validate_live_cmd(prof, pid, build, &doc)?; + verdicts.push(("validate-live", val_counts)); // The semantic sweep + live fuzz operate on a live pawn; pawn-less games stop at sig validation. if let Some(PawnContext { anchor: pa, pawn, .. @@ -1259,16 +1535,347 @@ pub(crate) fn run_live_oracle( Ok(live_result) } -/// A launched, ready CS2 bots server the caller owns (must kill). +/// The sentinel entity handle the Pulse resolve preamble rejects before dereferencing anything. +const PULSE_INVALID_HANDLE: u32 = 0xffff_ffff; + +/// `PVAL_EHANDLE`, from the shipped `PulseValueType_t`. +const PULSE_EHANDLE: i32 = 13; + +/// The owner-pointer offset within a VScript record. The STRIDE is `vscript::STRIDE` — the offline +/// reader's own, rather than a second copy of the same number that would have to be kept in step. +const VS_OWNER: u64 = 0x30; + +/// Attribute every VScript binding to the class that owns it, from the running server. +/// +/// **This is the one VScript field that cannot be derived offline**, and it is worth being precise about +/// why. The record stores its owner at `+0x30`, but the class descriptor reaches the initialiser through +/// a register loaded from memory rather than a `lea`, so constant propagation recovers the pointer for +/// exactly zero of the 1,841 bindings. Nothing about the fold can fix that; the value is not in the +/// instruction stream. +/// +/// A running server has it. Every record in one array points at the same descriptor, and the descriptor's +/// own `+0x00` is its class-name string — the same 16-byte name-pair shape the records use. Walking that +/// chain attributes 1,724 of 1,809 members to 66 classes on Dota. +/// +/// The precedent for a live-only field is the typed schema itself: a schema field's TYPE is a null +/// placeholder on disk and is populated only at runtime, which is why an offline run ships no typed +/// netvars at all. `class` behaves the same way — present in a full build, absent from an offline one — +/// rather than inventing a new kind of gap. +/// +/// It matters because the consumers group by class. Both `api.json` and the `.d.ts` the Dota ecosystem +/// publishes declare members under their owning interface, so a flat function list is not renderable into +/// either. +fn attribute_vscript_classes( + live: &live::LiveProcess, + base: u64, + img: &CodeImage, + bindings: &mut model::Bindings, +) -> (usize, usize) { + let ident = |s: &str| { + !s.is_empty() + && s.len() <= 128 + && s.chars() + .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == ':') + && s.chars() + .next() + .is_some_and(|c| c.is_ascii_alphabetic() || c == '_') + }; + let name_at = |addr: u64| -> Option { + live.read_u64(addr) + .ok() + .filter(|&p| p != 0) + .and_then(|p| live.read_cstr(p).ok()) + .filter(|s| ident(s)) + }; + + let mut of_member: HashMap = HashMap::new(); + // Anchor on a name the fold already recovered, then walk that record's whole array. Most anchors land + // in an array a previous one covered, so the skip keeps this O(classes) rather than O(bindings). + for f in crate::vscript::vscript_functions(img) { + if of_member.contains_key(&f.name) { + continue; + } + let mut needle = f.name.clone().into_bytes(); + needle.push(0); + let Some(&sv) = img.find_bytes(&needle).first() else { + continue; + }; + for h in live.find_instances(base + sv, 32) { + let Ok(owner) = live.read_u64(h + VS_OWNER) else { + continue; + }; + let Some(cname) = (owner != 0).then(|| name_at(owner)).flatten() else { + continue; + }; + // Members of one class are contiguous, and a change of owner is the array boundary — the + // only honest stopping condition. Walking until a record merely fails to validate over-runs + // into whatever is adjacent and attributes unrelated structures to the class. + for dir in [-1i64, 0, 1] { + let mut k = 0i64; + while let Some(addr) = h.checked_add_signed(k.wrapping_mul(crate::vscript::STRIDE)) + { + if live.read_u64(addr + VS_OWNER).ok() != Some(owner) { + break; + } + if let Some(m) = name_at(addr) { + of_member.entry(m).or_insert_with(|| cname.clone()); + } + if dir == 0 || k.abs() > 4096 { + break; + } + k += dir; + } + } + } + } + + // Count the classes ACTUALLY ASSIGNED, not the ones the walk encountered. Those differ: a class reached + // through a late anchor whose members a previous anchor already claimed is encountered and assigned + // nothing (`of_member` is first-writer-wins), so the encountered count drifts run to run with which + // instances the memory search happened to find — 63 on one Dota run and 66 on the next, both attributing + // an identical 1,638 bindings. The assigned count is the stable one and is also the number a consumer + // cares about: `gen`'s `moddota` format groups by class, so it is exactly how many interfaces + // they will emit. + let mut set = 0usize; + let mut assigned: HashSet<&str> = HashSet::new(); + for b in &mut bindings.vscript { + if let Some(c) = of_member.get(&b.name) { + b.class = Some(c.clone()); + set += 1; + } + } + assigned.extend(bindings.vscript.iter().filter_map(|b| b.class.as_deref())); + bindings.meta.vscript_classed = set; + (set, assigned.len()) +} + +/// Offset of the name POINTER within a Pulse descriptor element. +/// +/// MEASURED against a populated region rather than taken from the reconstruction: `+0x00` holds a hash +/// token of the name, the string pointer is at `+0x08`, and the type follows at `+0x10`. The offline +/// reader never needs this because it collects identifier stores anywhere in the region and assigns them +/// by stride; a live read does, and assuming `+0x00` yields a page of spurious disagreements. +/// +/// The element STRIDE is deliberately not a constant here. `pulse::read_all` derives it per image by +/// consensus and the fold reports it, so that a build which resizes the record shows up as a new number +/// rather than as lost signatures — a constant would make the offline reader adapt while this oracle +/// silently read the wrong addresses, and report a clean verdict for doing so. +const PULSE_ELEM_NAME: u64 = 0x08; + +/// One read of the Pulse registry, shared by both live verifiers. +/// +/// They opened with the same three lines and each re-walked the whole image for a registry the other had +/// already built. Reading it once also means both see the SAME derived stride, which is the property that +/// matters: two verifiers disagreeing about the record layout would disagree about which release is good. +struct PulseRead { + regs: Vec, + sigs: Vec>, + /// Element spacing, derived per image by consensus. `0` = no record answered unambiguously, which + /// `pulse::params_at` already handles by dropping every multi-element list. + stride: u64, +} + +impl PulseRead { + fn of(img: &CodeImage, threads: usize) -> Self { + let regs = crate::valvetab::pulse_bindings(img); + let pairs: Vec<(u64, u64)> = regs + .iter() + .map(|b| (b.descriptor, b.arg_descriptor)) + .collect(); + let (sigs, stride, _, _) = crate::pulse::read_all(img, &pairs, threads); + PulseRead { regs, sigs, stride } + } +} + +/// Check the reconstructed Pulse signatures against the descriptors the RUNNING server actually holds. +/// +/// The Pulse signatures in `surfaces.pulse` are a constant-propagated reconstruction of an initialiser, +/// not a read of data — on disk the descriptor elements are zeroes, because they are written at runtime. +/// Nothing offline can confirm that reconstruction, which is why the multi-library duplicate check has +/// been able to report that the registry disagrees with itself (CS2 331 of 419 repeat registrations, +/// Dota 271 of 359) with no way to say which account was right. +/// +/// A live server can say. The regions are plain statics, so at `slide + base` the real elements are +/// there — **once something has called the accessor.** They are lazy-init singletons and a server that +/// never executes a Pulse graph leaves every one of them zeroed, which is the normal case: a standard +/// match executes none. So the oracle calls them, and that is the whole trick. +/// +/// **Why calling them is safe.** These are the `+24`/`+32` accessors the fold deliberately REFUSES to +/// treat as locators — nullary, measured `int=0 float=0`, whose entire body builds a static once and +/// returns it. They take no arguments to get wrong and touch no game state. The same objects that are +/// worthless as locators are exactly what makes this check possible. +fn verify_pulse_descriptors( + live: &live::LiveProcess, + pid: u32, + base: u64, + img: &CodeImage, + pulse: &PulseRead, +) -> (usize, usize, Vec) { + let (regs, sigs) = (&pulse.regs, &pulse.sigs); + + let (mut checked, mut agree) = (0usize, 0usize); + let mut notes: Vec = Vec::new(); + for (b, sig) in regs.iter().zip(sigs.iter()) { + let Some(sig) = sig.as_ref() else { + continue; + }; + let Some((region, count)) = crate::pulse::record_region(img, b.descriptor) else { + continue; + }; + // Populate the singleton. A failure here is not a defect in the artifact — it means the call did + // not land — so it drops out of the sample rather than counting against agreement. + if live::call_remote(pid as i32, base + b.descriptor, &[]).is_err() { + continue; + } + let mut live_names: Vec = Vec::new(); + let mut readable = true; + for i in 0..count { + let e = base + region + i * pulse.stride; + match live + .read_u64(e + PULSE_ELEM_NAME) + .ok() + .filter(|&p| p != 0) + .and_then(|p| live.read_cstr(p).ok()) + { + Some(n) => live_names.push(n), + None => { + readable = false; + break; + } + } + } + if !readable { + continue; + } + let offline: Vec = sig.args.iter().map(|p| p.name.clone()).collect(); + checked += 1; + if offline == live_names { + agree += 1; + } else if notes.len() < 8 { + notes.push(format!( + "{}: derived {offline:?} but the live descriptor holds {live_names:?}", + b.name + )); + } + } + (checked, agree, notes) +} + +/// Verify the emitted Pulse invocation shims by CALLING them — with a handle the engine must reject. +/// +/// The binding registry states that a shim whose `call.needs` is `args-only` can be invoked by a host. +/// That is a claim about behaviour, so it is checked against behaviour rather than left as a derivation: +/// each eligible binding is called with a sentinel handle, and its resolve must return `-2` without +/// dereferencing anything. Confirming the ARGUMENT CONTRACT (the array at `r8+8+8k`, nulls in the slots the +/// measurement says are unread) is the point; the sentinel is what makes it free of side effects. +/// +/// **Why this is safe to run in CI.** Every slot but the argument array is null, so a shim that misuses one +/// dereferences null and FAULTS — and a fault is caught, the signal suppressed and the thread restored. The +/// dangerous case is a valid-but-wrong pointer, which corrupts silently (see [`crate::taxonomy`]); this +/// passes none. The argument array points into the call's own dead stack scratch. +/// +/// Eligibility is narrow on purpose: a shim, `args-only`, no declared return (so the output sink is never +/// needed), and a leading `PVAL_EHANDLE` (so the sentinel is rejected). Anything else is not probed. +/// +/// Derived from the image with the same readers the fold uses, rather than read back from +/// the binding registry: the oracle runs for `integration-test` too, which never builds one, and +/// threading it through both callers to re-parse hex strings would verify the same claim by a longer route. +fn verify_pulse_shims( + live: &live::LiveProcess, + pid: u32, + base: u64, + img: &CodeImage, + pulse: &PulseRead, +) -> (usize, usize, usize, Vec) { + let (regs, sigs) = (&pulse.regs, &pulse.sigs); + + let mut probed = 0usize; + let mut bailed = 0usize; + let mut faulted = 0usize; + let mut bad: Vec = Vec::new(); + for (b, sig) in regs.iter().zip(sigs.iter()) { + let (Some(sig), true) = (sig.as_ref(), b.shim != 0) else { + continue; + }; + let name = &b.name; + let callable = + crate::pulse::shim_reads(img, b.shim).is_some_and(|r| r.needs() == "args-only"); + if !callable + || !sig.returns.is_empty() + || sig.args.first().map(|p| p.ty) != Some(PULSE_EHANDLE) + || sig.args.len() > 2 + { + continue; + } + let at = base + b.shim; + if !live.is_exec(at) { + continue; + } + // [0x00] padding — the array is addressed from +8 and nothing reads +0 + // [0x08] pointer to argument 0 -> relocated to 0x20 + // [0x10] pointer to argument 1 -> relocated to 0x24 + // [0x20] the sentinel handle, [0x24] a zero second argument + let mut blob = [0u8; 0x28]; + blob[0x20..0x24].copy_from_slice(&PULSE_INVALID_HANDLE.to_le_bytes()); + let relocs: &[(usize, i64)] = if sig.args.len() >= 2 { + &[(0x08, 0x20), (0x10, 0x24)] + } else { + &[(0x08, 0x20)] + }; + let args = [ + live::Arg::Val(0), + live::Arg::Val(0), + live::Arg::Val(0), + live::Arg::Val(0), + live::Arg::Scratch(0), + live::Arg::Val(0), + ]; + probed += 1; + match live::call_remote_ex( + pid as i32, + at, + &args, + &[], + Some(live::Scratch { + bytes: &blob, + relocs, + }), + ) { + Ok(r) if r.clean_return && r.rax as i32 == -2 => bailed += 1, + Ok(r) if r.clean_return => { + // A clean return that is not the bail path still proves the contract; only note it. + bailed += 1; + if bad.len() < 8 { + bad.push(format!( + "{name} returned {} (not -2), cleanly", + r.rax as i32 + )); + } + } + // A fault is the contract being WRONG — the shim was entered and the call did not survive. + // "Could not be called" is a different thing (the injection itself did not happen) and is + // deliberately NOT counted as a fault: it says nothing about the argument contract. + Ok(_) => { + faulted += 1; + bad.push(format!("{name} FAULTED — the argument contract is wrong")); + } + Err(e) => bad.push(format!("{name} could not be called: {e}")), + } + } + (probed, bailed, faulted, bad) +} + +/// A launched, ready dedicated server the caller owns (must kill). pub(crate) struct OwnedServer { pub(crate) child: std::process::Child, pub(crate) pid: u32, } -/// Launch a vanilla bots-only CS2 deathmatch server (no mod, no human), wait for an alive bot pawn, then -/// hand back the process. The single CI server-launch, shared by `produce` and `integration-test` -/// (both call this). On timeout the child is killed + an error returned; on success the caller owns -/// the child. +/// Launch this game's vanilla dedicated server per [`GameProfile::launch`] (no mod, no human), wait for the +/// profile's readiness anchor — an alive bot PAWN for a pawn game, a live `ready_class` instance otherwise — +/// then hand back the process. The single CI server-launch, shared by `produce` and `integration-test` +/// (both call this). On timeout the child is killed + an error returned; on success the caller owns the +/// child. pub(crate) fn launch_bots_server( prof: &GameProfile, game: &Path, @@ -1372,16 +1979,21 @@ pub(crate) fn launch_bots_server( } } -/// Validate a generated gamedata json against a LIVE server and write the adjusted (passing) file — -/// the headless CI self-check. Confident-bad entries (a sig that no longer resolves/executes, an -/// offset whose slot isn't code) are dropped; ambiguous ones (base/derived offset, unknown class) -/// are kept but reported so nothing valid is silently lost. +/// Validate a generated gamedata document against a LIVE server and RETURN the kept entries plus each +/// entry's honest verdict and this stage's pass tally — the headless CI self-check. **Nothing is written +/// here**; the caller persists what it needs (`integration-test --out`, or `produce`'s own merge). +/// +/// Confident-bad entries (a sig that no longer resolves or does not execute, an offset whose slot is not +/// code) are dropped; ambiguous ones (base/derived offset, unknown class) are kept but reported, so +/// nothing valid is silently lost. The returned [`OracleCounts`] puts this stage under the same +/// `ORACLE_MIN_PASS` gate as every other one — it judges the tool's primary product, and used to be the +/// only stage whose tally was printed and discarded. fn validate_live_cmd( prof: &GameProfile, pid: u32, dir: &Path, doc: &GdMap, -) -> Result<(GdMap, BTreeMap>)> { +) -> Result<(GdMap, BTreeMap>, OracleCounts)> { let live = live::LiveProcess::attach(pid)?; // Load EVERY on-disk library that is also mapped in the live process, so a class/sig in any lib @@ -1432,21 +2044,47 @@ fn validate_live_cmd( let mut verdicts: BTreeMap> = BTreeMap::new(); let mut t = ValTally::default(); for (name, entry) in doc { - // `render::entry_from_value` is the canonical inverse of the locator shape; a real gamedata locator - // is sig-XOR-offset, so match signature first, then offset. + // EVERY locator the entry carries is checked, not the first one found. An entry may hold a + // signature AND a vtable offset — `model::Entry` says so, and five CS2 `core` entries do — and an + // `else if` here validated only the signature while the artifact went on to stamp + // `validated: true`, asserting a live check of a slot nobody read. Those slots ship into + // ModSharp's `VFuncs` and Metamod's `Offsets`, where a wrong one crashes the consumer. let e = render::entry_from_value(entry); + let mut outcomes: Vec = Vec::new(); if let Some(sig) = e.signature { let fname = lib_filename(prof, &sig.library); let v = validate_sig(&images, &bases, &live, &fname, Some(sig.linux.as_str())); - apply_sig(&mut t, &mut kept, &mut verdicts, name, entry, v); - } else if let Some(off) = e.offset { + outcomes.push(apply_sig(&mut t, name, v)); + } + if let Some(off) = e.offset { let class = class_of(name); let v = validate_offset(&idx, class, off, &bases, &live); - apply_offset(&mut t, &mut kept, &mut verdicts, name, entry, off, class, v); + outcomes.push(apply_offset(&mut t, name, off, class, v)); + } + // Combining is where the honesty lives. `Some(true)` requires EVERY locator to have been + // confirmed; one confidently-bad locator drops the entry whatever the other says; and anything + // the oracle could not check degrades the whole entry to `None` rather than letting a checked + // half vouch for an unchecked one. + let verdict = if outcomes.is_empty() { + Some(None) // no locator at all — nothing to check, and nothing claimed + } else if outcomes.iter().any(|o| matches!(o, LocatorOutcome::Drop)) { + None // dropped: `annotate_validation` reads an absent verdict as Some(false) + } else if outcomes + .iter() + .all(|o| matches!(o, LocatorOutcome::Kept(Some(true)))) + { + Some(Some(true)) + } else if outcomes + .iter() + .any(|o| matches!(o, LocatorOutcome::Kept(Some(false)))) + { + Some(Some(false)) } else { - // no locator at all — nothing the oracle can check; keep it but never claim validation. + Some(None) + }; + if let Some(v) = verdict { kept.insert(name.clone(), entry.clone()); - verdicts.insert(name.clone(), None); + verdicts.insert(name.clone(), v); } } @@ -1468,16 +2106,48 @@ fn validate_live_cmd( if t.flagged.len() > 60 { println!(" … and {} more flags", t.flagged.len() - 60); } - Ok((kept, verdicts)) + // The stage's own pass rate, returned so the release gate covers it like every other oracle stage. + // This is the one stage that judges the tool's PRIMARY product — the derived signatures and vtable + // offsets — and it was the one stage whose tally was printed and discarded. A derive that resolved + // onto the wrong functions (stale model, mismatched --target, a changed lib set) has every entry + // dropped, `annotate_validation` stamps `Some(false)` across core and high_confidence, and the release + // still wrote at exit 0. `Unvalidatable`/`Unknown` are excluded rather than counted as failures: the + // oracle could not judge them at all, which is what the three-valued `validated` already says. + let counts = OracleCounts { + checked: t.sig_ok + t.sig_fail + t.off_live + t.off_bad + t.off_oob, + ok: t.sig_ok + t.off_live, + faulted: t.sig_fail + t.off_bad + t.off_oob, + }; + Ok((kept, verdicts, counts)) } fn verify_live_cmd(prof: &GameProfile, pid: u32, dir: &Path, lib: &str) -> Result { let img = load_lib(dir, lib)?; let classes = schema::enumerate_schema(&img); - ensure!( - !classes.is_empty(), - "offline schema derivation found no classes in {lib}" - ); + // A floor, not merely non-empty: this half compares an offline read against a live one through the same + // `CI_*` constants on the same bytes, so a reshape's survivors agree with themselves at ~1.0 and a + // handful of classes looks like a clean run. + // + // It is `min_schema_classes_LIB`, because this enumerates ONE library while `produce`'s floor counts the + // union across all of them — see `GameProfile::min_schema_classes_lib`. Only `server_lib` has a + // calibrated count, so any other library is enumerated and reported rather than judged against a number + // that does not describe it. + if lib == prof.server_lib { + ensure!( + classes.len() >= prof.min_schema_classes_lib, + "offline schema derivation found {} classes in {lib} (floor {}) — refusing to verify a schema \ + whose class table collapsed", + classes.len(), + prof.min_schema_classes_lib + ); + } else { + eprintln!( + "NOTE: {lib} is not {}, which is the only library with a calibrated class floor — \ + enumerated {} classes, collapse check SKIPPED", + prof.server_lib, + classes.len() + ); + } let live = live::LiveProcess::attach(pid)?; let base = live @@ -1782,92 +2452,85 @@ struct ValTally { flagged: Vec, } -fn apply_sig( - t: &mut ValTally, - kept: &mut GdMap, - verdicts: &mut BTreeMap>, - name: &str, - entry: &serde_json::Value, - v: SigVerdict, -) { - // `keep` records the entry AND its honest validation verdict: Some(true) = live-confirmed, None = kept but - // the oracle could not check it (so the artifact must NOT claim validation). A dropped verdict is left - // absent (annotate_validation defaults absent -> Some(false)). - let keep = |k: &mut GdMap, verd: &mut BTreeMap>, val: Option| { - k.insert(name.to_string(), entry.clone()); - verd.insert(name.to_string(), val); - }; +/// What the oracle concluded about ONE locator of an entry. +/// +/// An entry may carry a signature AND a vtable offset — `model::Entry`'s own doc says so — and each is a +/// separate claim about the running server. Judging them separately, then combining, is what stops the +/// artifact stamping `validated: true` on an entry whose offset was never read. +enum LocatorOutcome { + /// Confidently bad: this locator does not describe the running server. + Drop, + /// Kept, with the honest three-valued verdict — `None` means the oracle could not check it. + Kept(Option), +} + +fn apply_sig(t: &mut ValTally, name: &str, v: SigVerdict) -> LocatorOutcome { match v { SigVerdict::Ok => { t.sig_ok += 1; - keep(kept, verdicts, Some(true)); + LocatorOutcome::Kept(Some(true)) } SigVerdict::Hooked => { t.sig_ok += 1; t.sig_hooked += 1; - keep(kept, verdicts, Some(true)); // sig IS valid; the hook is a runtime overlay, not a mismatch t.flagged.push(format!( "{name} — sig valid; function is HOOKED live (a mod detoured it)" )); + LocatorOutcome::Kept(Some(true)) // the sig IS valid; a hook is a runtime overlay, not a mismatch } SigVerdict::Unvalidatable(why) => { t.sig_unval += 1; - keep(kept, verdicts, None); // lib not mapped this run -> kept but UNVERIFIED, never claim Some(true) t.flagged .push(format!("{name} — sig kept, unvalidated: {why}")); + LocatorOutcome::Kept(None) // lib not mapped this run -> never claim Some(true) } SigVerdict::Fail(why) => { t.sig_fail += 1; t.dropped.push(format!("{name} — sig: {why}")); + LocatorOutcome::Drop } } } fn apply_offset( t: &mut ValTally, - kept: &mut GdMap, - verdicts: &mut BTreeMap>, name: &str, - entry: &serde_json::Value, off: i64, class: &str, v: OffVerdict, -) { - let keep = |k: &mut GdMap, verd: &mut BTreeMap>, val: Option| { - k.insert(name.to_string(), entry.clone()); - verd.insert(name.to_string(), val); - }; +) -> LocatorOutcome { match v { OffVerdict::Live => { t.off_live += 1; - keep(kept, verdicts, Some(true)); + LocatorOutcome::Kept(Some(true)) } OffVerdict::LiveViaSub(d) => { t.off_live += 1; t.off_sub += 1; - keep(kept, verdicts, Some(true)); // the slot IS executable on a subclass vtable — validated t.flagged.push(format!( "{name} — offset {off} valid on subclass {d} (entry names a base class)" )); + LocatorOutcome::Kept(Some(true)) // the slot IS executable on a subclass vtable — validated } OffVerdict::NotCode => { t.off_bad += 1; t.dropped .push(format!("{name} — offset {off}: slot not executable")); + LocatorOutcome::Drop } OffVerdict::Oob => { t.off_oob += 1; - keep(kept, verdicts, Some(false)); // offset exceeds the vtable = likely WRONG -> flag false (render drops it) t.flagged.push(format!( "{name} — offset {off} exceeds {class} and its subclasses' vtables" )); + LocatorOutcome::Kept(Some(false)) // exceeds the vtable = likely WRONG (render drops it) } OffVerdict::Unknown => { t.off_unknown += 1; - keep(kept, verdicts, None); // not a vtable class -> the oracle can't check it, kept but UNVERIFIED t.flagged.push(format!( "{name} — {class} is not a vtable class (engine special / member offset)" )); + LocatorOutcome::Kept(None) // not a vtable class -> the oracle cannot check it } } } @@ -1877,9 +2540,10 @@ mod tests { use super::*; // `DigestChange::classify` IS the CI branch decision: `skip` publishes only a manifest, `shift` marks a - // toolchain jump. The thresholds are user-tunable and the calibration behind the defaults is recorded - // in the CLI help (339 CS2 build pairs: 311 code-identical, real patches <=0.08% changed, the two - // toolchain jumps 34% and 53%). Pin those four cases so a threshold edit has to face them. + // toolchain jump. The thresholds are user-tunable; the calibration behind the defaults is recorded ONCE, + // in `classify-change --shift-above`'s help. The cases below pin its extremes so a threshold edit has + // to face them — deliberately not restated here, since two copies of a measurement is how the last one + // came to be quoted long after it was superseded. fn ch(n_new: u32, common: u32) -> DigestChange { DigestChange { n_prev: n_new, @@ -1889,29 +2553,56 @@ mod tests { } #[test] - fn classify_defaults_match_the_documented_calibration() { + fn classify_defaults_straddle_the_measured_gap() { + // The extremes measured over 344 CS2 builds at ~70,300 functions each. The two INNER values are + // the ones that matter: the largest ordinary patch and the smallest toolchain jump sit 4.6 + // points apart, and the default has to land between them. let (skip_below, shift_above) = (0.0, 0.20); - // code-identical build -> skip (the common case: 311 of 339 pairs) + // code-identical -> skip (82 of 344 builds) assert!(matches!( ch(10_000, 10_000).classify(skip_below, shift_above), ChangeVerdict::Skip )); - // an ordinary patch: 8 of 10_000 = 0.08% -> normal, NOT skip, at the default 0 tolerance + // the smallest real patch, 0.001% -> normal, NOT skip, at the default 0 tolerance assert!(matches!( - ch(10_000, 9_992).classify(skip_below, shift_above), + ch(100_000, 99_999).classify(skip_below, shift_above), ChangeVerdict::Normal )); - // the two observed toolchain jumps, 34% and 53% -> shift + // the LARGEST ordinary patch, 17.78% -> still normal assert!(matches!( - ch(10_000, 6_600).classify(skip_below, shift_above), + ch(10_000, 8_222).classify(skip_below, shift_above), + ChangeVerdict::Normal + )); + // the SMALLEST toolchain jump, 22.36% -> shift + assert!(matches!( + ch(10_000, 7_764).classify(skip_below, shift_above), ChangeVerdict::Shift )); + // and the largest, 93.8% assert!(matches!( - ch(10_000, 4_700).classify(skip_below, shift_above), + ch(10_000, 620).classify(skip_below, shift_above), ChangeVerdict::Shift )); } + #[test] + fn function_digests_do_not_depend_on_eh_frame() { + // The defect this pins: enumerating only `.eh_frame` FDEs samples the statically-linked runtime + // tail — 8,327 of libserver's ~70,000 functions — and reports "nothing changed" about a build + // whose gameplay code moved. A synthetic image has no `.eh_frame` at all, so an FDE-only + // population yields NOTHING here, and `classify-change` would then answer `skip` from an empty + // sample. call rel32 +0 ; ret ; xor eax,eax ; ret — the call target is a second entry. + let img = CodeImage::for_test( + 0x1000, + &[0xE8, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x31, 0xC0, 0xC3], + ); + assert!(img.eh_frame_functions().is_empty(), "fixture has no FDEs"); + assert!( + !function_digests(&img).is_empty(), + "digests must come from the relocation/call-target union too, not FDEs alone" + ); + } + #[test] fn skip_below_tolerance_absorbs_small_patches() { // raising the tolerance to 1% reclassifies the 0.08% patch as skip, and must not touch a shift diff --git a/src/profile.rs b/src/profile.rs index f5b3664..360ac48 100644 --- a/src/profile.rs +++ b/src/profile.rs @@ -56,7 +56,13 @@ impl LaunchSpec { pub struct PawnAnchor { pub pawn_class: &'static str, // player-pawn RTTI class — the live-oracle instance anchor pub health_field: &'static str, // a reliable "is this instance alive" netvar - pub is_player_pawn_slot: u64, // gamedata vtable offset of IsPlayerPawn (call-live smoke test) + /// A RECORDED REFERENCE value for `IsPlayerPawn`'s vtable slot — cross-checked against, never called. + /// + /// The live CALL test uses the slot THIS build derived and skips entirely when the build derived none; + /// this constant only decides whether that run prints a "the slot moved, update me" note. It is not a + /// fallback, and must not become one: the slot has taken six distinct values in ten months, and calling + /// a stale index would inject a call to whatever now occupies it. A new game may record 0 until measured. + pub is_player_pawn_slot: u64, } pub struct GameProfile { @@ -98,6 +104,11 @@ pub struct GameProfile { /// layout moves, and the result would be a release that ships every binding with no signature at all /// — a silent capability loss rather than a wrong answer, which is precisely what a floor is for. pub min_pulse_typed: usize, + /// Floor on Pulse bindings whose invocation shim is HOST-CALLABLE (`call.needs == "args-only"`). + /// Its own floor because it has its own failure mode: the registry can read perfectly and the + /// signatures recover perfectly while a codegen change makes every shim appear to read another slot, + /// which would silently retire the one callable tier instead of failing the release. + pub min_pulse_callable: usize, pub min_entity_io: usize, pub min_entity_classes: usize, /// Console commands recovered from their registration calls. Its own floor because it has its own @@ -105,12 +116,69 @@ pub struct GameProfile { /// invalid-handle sentinel), so a build that reworks that constructor yields zero commands rather /// than wrong ones — correct, and invisible without this. pub min_commands: usize, + /// Floor on recovered ConVars. Its own floor because convar registration is identified by a DIFFERENT + /// test from the command one — convergence of registrar wrappers on a shared core, not a sentinel in the + /// callee — so it can fail while commands keep working. + pub min_convars: usize, + /// Floor on VScript bindings. Its own floor for the usual reason — a THIRD identification test, + /// distinct from both the command sentinel and the convar convergence: a record base computed by the + /// initialiser's own `idx*5 << 4 + [class+0x28]`. A codegen change that reshapes that arithmetic + /// yields zero bindings while every other surface keeps reading perfectly. + /// + /// Set well under the observed count, which is the house rule, but the margin here is deliberately + /// wide: the reader recovers three distinct registration forms (the packed name pair, the + /// `movddup` single-string form, and a base copied between registers), and losing any ONE of them + /// would still clear a tight floor while quietly dropping a third of the surface. + pub min_vscript: usize, + /// Floor on VScript bindings attributed to an OWNING CLASS — and the only floor here that a full run + /// checks and an offline one skips, because zero is correct by construction offline: the descriptor + /// reaches its class through a register loaded from memory, so nothing static recovers it. + /// + /// Separate from `min_vscript` because it fails independently and in the opposite direction. That floor + /// guards the offline READER against a Valve reshape; this one guards the LIVE WALK — the string-anchor + /// instance search, the owner read at the record's `+0x30`, the class-name read behind it. Any of those + /// breaking leaves every binding recovered, described and located, with no class on any of them: a + /// release that clears every other gate. It is `class` that `gen`'s `moddota` format GROUPS BY, so + /// the artifact would ship intact while both of the files it writes came out empty. + pub min_vscript_classed: usize, pub min_schema_enums: usize, + /// Collapse floor for the recovered schema CLASS table — the largest table the deriver reads, and the + /// one every other schema claim rests on: the artifact's whole `schema` section, the entity-output and + /// datadesc joins, the derived type layouts, and `Identity::class_size`, which is half the identity + /// check's conjunction. + /// + /// It needs its own floor because nothing else covers it. `min_schema_enums` does not — `enumerate_enums` + /// uses classes only to exclude field arrays, so it keeps passing at zero classes. The live oracle's + /// class gate does not either: it is SKIPPED below `ORACLE_MIN_SAMPLE` checked classes, and the sample + /// IS the class count, so a collapse into that range disables the check that would catch it. And the + /// offline/live layout comparison reads the same bytes through the same `CI_*` constants, so whatever + /// survives a reshape agrees with itself. + pub min_schema_classes: usize, + /// Collapse floor for the schema CLASS table read from a SINGLE library — the live oracle's population. + /// + /// Distinct from [`min_schema_classes`](Self::min_schema_classes), and the two may never be shared: that + /// one counts the union across every mapped library, this one counts `server_lib` alone, and the union is + /// roughly twice as large. A floor calibrated on the union rejects every healthy build when applied here, + /// because the honest single-library count sits below it by construction. + /// + /// Calibrated the same way as its sibling — well under the observed count, a collapse detector rather + /// than a tight bound — and it only applies to `server_lib`, the one library whose count is calibrated. + pub min_schema_classes_lib: usize, + /// Collapse floor for the DERIVED function tiers — `core + high_confidence`. + /// + /// Every table read out of the binary has one of these; the tool's headline product did not, and the + /// gap is structural rather than an oversight of one number: the live oracle gates a PASS RATE over + /// entries that reached the gamedata document, and a signature that failed to resolve never enters it. + /// So a derive that emits forty functions instead of four thousand passes at 100% — a stale corpus + /// model, a `--target` from the wrong branch or a missing secondary library all land there. + /// + /// A collapse detector, not a tight bound: set well below the observed count, like every sibling floor. + pub min_core_functions: usize, /// Output game-key the game-keyed emitters use (Metamod `Games { {..} }`, Plugify `{ "": {..} }`). pub game_key: &'static str, /// The `--game` CLI token / per-release filename suffix (`cs2`, `dota2`) — distinct from `game_key` (the /// content-dir token `csgo`/`dota` that framework formats key on). Names the artifacts - /// `gamedata-.json` / `model-.json` / `netvars-.json`. + /// `rosetta-.json` / `model-.json`. pub token: &'static str, /// Dedicated-server launcher binary under `bin/linuxsteamrt64/` (CS2: `cs2`). pub executable: &'static str, @@ -185,10 +253,22 @@ pub const CS2: GameProfile = GameProfile { // observed: 580 Pulse, 715 inputs + 226 outputs, 474 entity classnames, 784 commands, 555 enums min_pulse_bindings: 300, min_pulse_typed: 300, + min_pulse_callable: 90, min_entity_io: 400, min_entity_classes: 200, min_commands: 400, + min_convars: 900, + min_vscript: 180, + // observed live: 271 of 300 bindings attributed across 24 classes + min_vscript_classed: 150, min_schema_enums: 250, + // CS2 recovers 1,899 across every mapped library. A floor at 1,200 is well clear of build-to-build + // drift and nowhere near the range a `SchemaClassInfoData_t` reshape would leave. + min_schema_classes: 1_200, + // libserver.so alone holds 852 of those; the live oracle reads that library only. + min_schema_classes_lib: 550, + // CS2 ships 1,086 core + 2,899 high-confidence = 3,985. + min_core_functions: 2_500, game_key: "csgo", token: "cs2", executable: "cs2", @@ -288,10 +368,21 @@ pub const DOTA: GameProfile = GameProfile { // observed: 500 Pulse, 624 inputs, 3,528 entity classnames, 855 commands, 743 enums min_pulse_bindings: 250, min_pulse_typed: 250, + min_pulse_callable: 65, min_entity_io: 300, min_entity_classes: 1000, min_commands: 400, + min_convars: 600, + min_vscript: 1200, + // observed live: 1,638 of 1,841 bindings attributed across 63 classes + min_vscript_classed: 900, min_schema_enums: 350, + // Dota recovers 2,962 across every mapped library. + min_schema_classes: 2_000, + // libserver.so alone holds 1,916 of those; the live oracle reads that library only. + min_schema_classes_lib: 1_250, + // Dota ships 1,096 + 4,047 = 5,143. + min_core_functions: 3_000, game_key: "dota", token: "dota2", executable: "dota2", // bin/linuxsteamrt64/dota2 @@ -373,6 +464,23 @@ pub const DOTA: GameProfile = GameProfile { mod tests { use super::*; + /// The two class floors count DIFFERENT populations — the all-library union and `server_lib` alone — + /// so a profile that gives them the same value has calibrated one of them against the other's + /// population, which rejects every healthy build on whichever site got the larger number. + #[test] + fn the_single_library_class_floor_is_strictly_below_the_all_library_one() { + for prof in [&CS2, &DOTA] { + assert!( + prof.min_schema_classes_lib < prof.min_schema_classes, + "{}: single-library floor {} must sit below the all-library floor {} — one library \ + cannot hold more classes than every library", + prof.token, + prof.min_schema_classes_lib, + prof.min_schema_classes + ); + } + } + #[test] fn cs2_launch_args_are_byte_identical_to_the_old_hand_synced_vec() { // The exact arg vec the live launch requires for map="de_dust2", bots=9 — pins the LaunchSpec diff --git a/src/prototypes.rs b/src/prototypes.rs index de2a2bd..7dbfca8 100644 --- a/src/prototypes.rs +++ b/src/prototypes.rs @@ -17,13 +17,14 @@ use serde::Deserialize; use std::collections::{BTreeMap, BTreeSet}; use std::path::Path; -/// The provenance the deriver stamps on a name it read out of Valve's entity-IO datadesc. Kept in step -/// with `pipeline::VALVE_DATADESC` — the two halves of one fact: which names the datadesc named, and -/// what the engine's dispatch contract therefore says about them. -const VALVE_DATADESC: &str = "valve-datadesc"; +// The provenance ids this module READS are the ones the pipeline STAMPS, imported rather than re-spelled: +// they are one fact — which evidence named the function — and two copies of it "kept in step" by a +// comment is an invariant nothing enforces. A drift there would silently stop matching, and a prototype +// that stops matching does not fail; it simply stops being claimed. +use crate::pipeline::{VALVE_CONCOMMAND, VALVE_DATADESC, VALVE_VSCRIPT}; /// What the manifest calls a prototype that came from how the ENGINE invokes the function rather than -/// from anyone's declaration of it. +/// from anyone's declaration of it. Declared here because only this module states it. const ENGINE_CONTRACT: &str = "engine-contract"; /// The prototype the engine invokes EVERY entity-IO handler through. Kept in step with @@ -31,10 +32,6 @@ const ENGINE_CONTRACT: &str = "engine-contract"; /// derive as a standing oracle — two halves of one fact, one asserting it and one checking it. const ENGINE_CONTRACT_PARAMS: [&str; 2] = ["CEntityInstance*", "InputData_t&"]; -/// The provenance prefix a console-command handler ships under, `:
`-suffixed. Kept in step with -/// `pipeline::VALVE_CONCOMMAND`. -const VALVE_CONCOMMAND: &str = "valve-concommand"; - /// What the engine passes EVERY console-command callback, whatever form it takes. const CONCOMMAND_PARAMS: [&str; 2] = ["CCommandContext*", "CCommand*"]; @@ -72,6 +69,62 @@ fn concommand_contract(source: &str) -> Option> { ) } +/// Read the DIRECTION of a footprint disagreement, and decide what it means. +/// +/// Split out because it is the whole content of the `mismatch` verdict, and it has to be callable: the +/// tests used to re-implement this rule rather than call it, so the regression guard could only fail if +/// someone edited both copies the same wrong way. One definition, two callers. +/// +/// Only an over-READ refutes a declaration. `declared_over` alone is the documented LOWER-BOUND case — +/// calling through it loads a register nobody reads, which is safe — while `measured_over` means the +/// callee reads a register the declaration never mentions, which is not. `both` stays a mismatch: a +/// class where the callee reads more is unsafe regardless of another class where it reads fewer. 81 of +/// CS2's 140 former mismatches were the safe direction, reported as "does not describe this build". +fn adjudicate_mismatch( + chosen: &Candidate, + s: &model::AbiShape, + types: Option<&BTreeMap>, +) -> (model::AbiStatus, &'static str) { + let (i, f) = footprint(chosen.params, types); + // The direction has to be read through the SAME allowance the verdict was, or the invisible `this` + // reads as an over-count on its own: `CGameEvent::GetFloat` is declared `(char const*, float)` and + // measures `int=2 float=0`, where the extra integer register is the receiver and the only real + // disagreement is the float. + let i = if chosen.complete { + i + } else { + (i..=i + 1) + .min_by_key(|d| d.abs_diff(s.int as usize)) + .expect("the range always has two elements") + }; + let (i, f) = (i.min(6), f.min(8)); + let measured_over = s.int as usize > i || s.float as usize > f; + let declared_over = i > s.int as usize || f > s.float as usize; + let status = if declared_over && !measured_over { + model::AbiStatus::LowerBound + } else { + model::AbiStatus::Mismatch + }; + let note = match (measured_over, declared_over) { + (true, true) => { + "measured and declared footprints disagree in BOTH directions, in different register \ + classes: the callee reads a register the declaration does not mention AND the declaration \ + passes one the callee never reads" + } + (false, true) => { + "the declaration passes registers the callee never reads, and contradicts it in no register \ + class — the measured footprint is a documented LOWER bound, so this is expected rather than \ + evidence against the declaration" + } + (true, false) => { + "measured footprint EXCEEDS declared: the callee reads a register the declaration does not \ + mention, so this declaration does not describe this build" + } + _ => "the footprints disagree in neither direction, which a mismatch cannot be", + }; + (status, note) +} + /// One declared prototype as the frozen input records it. #[derive(Deserialize)] struct Decl { @@ -288,6 +341,7 @@ pub fn build_manifest( prototypes: &Path, mono: &model::Monolith, types: Option<&BTreeMap>, + vscript_ret: Option<&BTreeMap>, ) -> Result { let doc: PrototypeDoc = serde_json::from_str( &std::fs::read_to_string(prototypes) @@ -397,7 +451,22 @@ pub fn build_manifest( .and_then(|e| e.locator.offset); let decls: &[Decl] = exact.or(by_bare_hit).map_or(&[][..], |v| v.as_slice()); - if decls.is_empty() && !is_contract { + + // The SCRIPT VM'S OWN declared return, for a name the registry states. It ranks above the + // measured register class for the reason spelled out below: a callee cannot tell whether its + // caller reads RAX, so measurement is wrong about known-void functions roughly seven times + // in eight — and `void` is what the registry declares for 849 of Dota's bindings, which is + // exactly the population measurement gets wrong. It ranks BELOW a real declaration only to + // keep "a source wrote this down" ahead of anything derived; in practice the two never + // compete, because no VScript name is also a declared name (measured: zero overlap). + // + // Read BEFORE the gate below, not after: a registry-declared return is on its own enough to + // have something to say about a function, so a name carrying one must not be skipped for + // having no parameter list. That is precisely the `return-only` case. + let vs_ret = vscript_ret.and_then(|m| m.get(name)).cloned(); + let has_vs_ret = vs_ret.is_some(); + + if decls.is_empty() && !is_contract && !has_vs_ret { bump(&format!("{tier}:none")); continue; } @@ -413,6 +482,7 @@ pub fn build_manifest( any_ret .clone() .or(contract) + .or(vs_ret) .or_else(|| sh.map(|s| s.ret.clone())) }; let mut provenance: Vec = decls @@ -424,6 +494,9 @@ pub fn build_manifest( if is_contract { provenance.push(ENGINE_CONTRACT.to_string()); } + if has_vs_ret { + provenance.push(VALVE_VSCRIPT.to_string()); + } // The contract goes in FIRST, so that where it and a declaration both fit the measurement, // `most_specific` reports the one that names its receiver — which the contract always does @@ -440,8 +513,14 @@ pub fn build_manifest( }); } collect_candidates(decls, &mut cands); + // `bare-name` is a CLAIM — "one declaration bears this method name and the measurement could + // adjudicate" — so it must not be the fallback for an entry that was never name-matched at + // all. A registry-declared return with no declaration behind it is neither exact nor + // bare-name; it is the script VM stating its own contract, and it says so. let matched_by = if exact.is_some() { "exact" + } else if decls.is_empty() && has_vs_ret { + VALVE_VSCRIPT } else { "bare-name" }; @@ -567,46 +646,9 @@ pub fn build_manifest( // former mismatches were the former, reported as "does not describe this build". if status == model::AbiStatus::Mismatch { let s = sh.expect("a mismatch is only reachable with a measurement"); - let (i, f) = footprint(chosen.params, types); - // The direction has to be read through the SAME allowance the verdict was, or the - // invisible `this` reads as an over-count on its own: `CGameEvent::GetFloat` is - // declared `(char const*, float)` and measures `int=2 float=0`, where the extra - // integer register is the receiver and the only real disagreement is the float. - let i = if chosen.complete { - i - } else { - (i..=i + 1) - .min_by_key(|d| d.abs_diff(s.int as usize)) - .expect("the range always has two elements") - }; - let (i, f) = (i.min(6), f.min(8)); - let measured_over = s.int as usize > i || s.float as usize > f; - let declared_over = i > s.int as usize || f > s.float as usize; - // Only an over-read refutes the declaration. `both` stays a mismatch: a class where the - // callee reads more is unsafe regardless of another class where it reads fewer. - if declared_over && !measured_over { - status = model::AbiStatus::LowerBound; - } - note = Some( - match (measured_over, declared_over) { - (true, true) => { - "measured and declared footprints disagree in BOTH directions, in different \ - register classes: the callee reads a register the declaration does not \ - mention AND the declaration passes one the callee never reads" - } - (false, true) => { - "the declaration passes registers the callee never reads, and contradicts it \ - in no register class — the measured footprint is a documented LOWER bound, \ - so this is expected rather than evidence against the declaration" - } - (true, false) => { - "measured footprint EXCEEDS declared: the callee reads a register the \ - declaration does not mention, so this declaration does not describe this build" - } - _ => "the footprints disagree in neither direction, which a mismatch cannot be", - } - .to_string(), - ); + let (verdict, why) = adjudicate_mismatch(&chosen, s, types); + status = verdict; + note = Some(why.to_string()); } // A BARE-NAME claim that the measurement CONTRADICTS is withdrawn, not reported. The gate // admits a bare name only when a measurement exists to adjudicate it — and adjudicating @@ -645,6 +687,9 @@ pub fn build_manifest( note, overloads: (cands.len() > 1).then_some(all_sigs), vtable, + // Prose belongs to the function record, not to a prototype; the merge attaches it + // there and `Rosetta::abi_manifest` joins it back on for the emitters. + doc: None, }, ); } @@ -834,36 +879,28 @@ mod tests { } /// The verdict AND the note, for one declaration against one measurement. + /// CALLS the shipped rule rather than restating it. It used to re-implement `build_manifest`'s + /// direction logic, which made the assertions below unfalsifiable: only an edit that changed both + /// copies the same wrong way could fail them, and that is the one edit nobody makes by accident. + /// The direction is read back out of the shipped note text, so the mapping from direction to prose + /// is under test too. fn judge(params: &[&str], sh: &model::AbiShape, complete: bool) -> (model::AbiStatus, String) { let ps = p(params); let c = cand(&ps, complete); if agrees(&c, sh, None) { return (model::AbiStatus::Verified, String::new()); } - let (i, f) = footprint(c.params, None); - let i = if complete { - i + let (status, note) = adjudicate_mismatch(&c, sh, None); + let direction = if note.starts_with("measured and declared") { + "both" + } else if note.starts_with("measured footprint EXCEEDS") { + "measured-exceeds" + } else if note.starts_with("the declaration passes") { + "declared-exceeds" } else { - (i..=i + 1) - .min_by_key(|d| d.abs_diff(sh.int as usize)) - .unwrap() + "neither" }; - let (i, f) = (i.min(6), f.min(8)); - let over = sh.int as usize > i || sh.float as usize > f; - let under = i > sh.int as usize || f > sh.float as usize; - ( - if under && !over { - model::AbiStatus::LowerBound - } else { - model::AbiStatus::Mismatch - }, - match (over, under) { - (true, true) => "both", - (true, false) => "measured-exceeds", - _ => "declared-exceeds", - } - .to_string(), - ) + (status, direction.to_string()) } #[test] diff --git a/src/pulse.rs b/src/pulse.rs index 40dcac2..bbb500c 100644 --- a/src/pulse.rs +++ b/src/pulse.rs @@ -24,9 +24,12 @@ //! declares. A layout change yields FEWER signatures, never wrong ones, and the profile floor turns //! "fewer" into a failed release. +// Registers whose value a call destroys. The ONE list in `abi`, not a second copy of it — both loops +// below that invalidate across a call read it directly. +use crate::abi::CALLER_SAVED; use crate::elf::CodeImage; use iced_x86::{Decoder, DecoderOptions, FlowControl, Instruction, Mnemonic, OpKind, Register}; -use std::collections::{BTreeMap, HashMap}; +use std::collections::{BTreeMap, HashMap, HashSet}; /// Highest `PulseValueType_t` enumerator (`PVAL_COUNT`) plus headroom for a build that adds a few. The /// enum is schema-registered, so the DERIVED values are what a caller should validate against — this is @@ -83,41 +86,26 @@ struct Trace { ret: Option<(u64, u64)>, } -/// Registers whose value a call destroys. Anything else the pass cannot evaluate is invalidated as the -/// instruction that writes it is seen, so the default is always "unknown" rather than "stale". -const CALLER_SAVED: [Register; 9] = [ - Register::RAX, - Register::RCX, - Register::RDX, - Register::RSI, - Register::RDI, - Register::R8, - Register::R9, - Register::R10, - Register::R11, -]; - fn full(r: Register) -> Register { if r.is_gpr() { r.full_register() } else { r } } -/// Constant-propagate through the accessor, recording every fixed-address store, every call's argument -/// registers, and the vector the fast path returns. +/// Every instruction address reachable from `entry` inside `[entry, entry+code.len())`, in ADDRESS order. /// -/// Deliberately a single ADDRESS-ORDER pass rather than a CFG walk: the guard-protected initializer is -/// straight-line, and a pass that only ever believes values it computed itself cannot invent one. Every -/// instruction it does not model invalidates what it writes. -fn trace(img: &CodeImage, entry: u64, seed_rdi: Option) -> Option { - let code = img.code_at(entry)?; - let cap = code.len().min(MAX_SPAN); - let in_span = |t: u64| t >= entry && ((t - entry) as usize) < cap; - - // Reachable instruction addresses, then walked in address order. - let mut seen: HashMap = HashMap::new(); +/// One walk, two callers: the descriptor trace and the shim's liveness read need exactly the same thing — +/// flow-reachable addresses rather than a linear sweep, so a jump table or an interleaved neighbour cannot +/// contribute instructions the function never executes. They differ only in how far they are willing to +/// walk, which is the `cap`. +/// +/// `cap` bounds the SET, not the span: a crafted image can present a small span with pathological branch +/// density, and this is on the fuzz surface. +fn reachable(code: &[u8], entry: u64, cap: usize) -> Vec { + let end = entry.saturating_add(code.len() as u64); + let mut seen: HashSet = HashSet::new(); let mut work = vec![entry]; let mut insn = Instruction::default(); while let Some(at) = work.pop() { - if seen.contains_key(&at) || !in_span(at) || seen.len() > 4000 { + if at < entry || at >= end || seen.contains(&at) || seen.len() > cap { continue; } let mut dec = @@ -129,7 +117,7 @@ fn trace(img: &CodeImage, entry: u64, seed_rdi: Option) -> Option { if insn.is_invalid() || insn.len() == 0 { continue; } - seen.insert(at, insn.len()); + seen.insert(at); match insn.flow_control() { FlowControl::Return | FlowControl::IndirectBranch @@ -143,9 +131,22 @@ fn trace(img: &CodeImage, entry: u64, seed_rdi: Option) -> Option { _ => work.push(at + insn.len() as u64), } } - - let mut addrs: Vec = seen.keys().copied().collect(); + let mut addrs: Vec = seen.into_iter().collect(); addrs.sort_unstable(); + addrs +} + +/// Constant-propagate through the accessor, recording every fixed-address store, every call's argument +/// registers, and the vector the fast path returns. +/// +/// Deliberately a single ADDRESS-ORDER pass rather than a CFG walk: the guard-protected initializer is +/// straight-line, and a pass that only ever believes values it computed itself cannot invent one. Every +/// instruction it does not model invalidates what it writes. +fn trace(img: &CodeImage, entry: u64, seed_rdi: Option) -> Option { + let all = img.code_at(entry)?; + let code = &all[..all.len().min(MAX_SPAN)]; + let mut insn = Instruction::default(); + let addrs = reachable(code, entry, 4000); let mut out = Trace::default(); let mut regs: HashMap = HashMap::new(); @@ -350,26 +351,6 @@ fn record(img: &CodeImage, accessor: u64) -> Option { }) } -/// Every CODE pointer an accessor's initializer stores into its record region, with the region base: -/// `(base, [(address written, code address written)])`. -/// -/// A DIAGNOSTIC, and deliberately not part of any shipped artifact. The parameter records carry a -/// function pointer whose ROLE is not established — the record reader already has to look at these in -/// order to reject them as parameter names, so exposing them costs nothing and lets that question be -/// settled against evidence collected elsewhere (a runtime call-edge trace) rather than guessed. Nothing -/// here interprets them; they are raw measurements. -pub fn code_stores(img: &CodeImage, accessor: u64) -> Option<(u64, Vec<(u64, u64)>)> { - let r = record(img, accessor)?; - let stores = - r.t.writes - .iter() - .filter(|&(a, _)| *a >= r.base) - .filter(|&(_, p)| img.is_code(*p)) - .map(|(&a, &p)| (a, p)) - .collect(); - Some((r.base, stores)) -} - /// The spacings at which this record's `count` names could sit, given that element 0's name is at /// `base + 8` and the array is contiguous. Usually one; a record carrying a second identifier-shaped /// string of its own offers more, which is why the stride is settled per IMAGE and not per record. @@ -550,6 +531,196 @@ fn type_at(img: &CodeImage, t: &Trace, obj: u64) -> Option<(i32, Option) found } +/// How far past a shim's entry the read-measurement will follow. `.eh_frame_hdr` covers only a fraction of +/// these images' functions and none of the shims, so there is no exact extent available; flow-following ends +/// at every `ret` regardless, so this only bounds a runaway path. +const SHIM_SPAN: u64 = 0x1000; + +/// The seven integer arguments a Pulse invocation shim takes, in SysV order. The seventh is the first +/// STACK slot — measured, and the reason the shim's arity cannot be read off `abi_shape`, whose backward +/// liveness stops at the registers. +const SHIM_SLOTS: [Register; 6] = [ + Register::RDI, + Register::RSI, + Register::RDX, + Register::RCX, + Register::R8, + Register::R9, +]; + +/// What an invocation shim was measured to read, and therefore what a caller has to supply. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct ShimReads { + /// The argument slots actually read, named — `rcx`, `r8`, `stack0`. The argument array (`r8`) is + /// stated here and nowhere else: reading it is the ordinary case and constrains a caller in no way, + /// so it needs no flag of its own beside the three that do. + pub reads: Vec<&'static str>, + /// Does it read the output sink (the first stack slot)? True for exactly the bindings that declare a + /// return, measured across both games with no exceptions. + pub sink: bool, + /// Does it read the Pulse host-service context (`rcx`)? That object is VM-owned, so a host cannot + /// supply one. + pub context: bool, + /// Does it read any OTHER slot — `rdi`, `rsi`, `rdx`, `r9`? These are the slots a caller would + /// otherwise pass as null, so any read here means it cannot. + pub other: bool, +} + +impl ShimReads { + /// What a host must supply, as the artifact states it. + /// + /// `args-only` is the one that matters: everything such a shim reads is either the argument array a + /// caller builds or the game's own entity list, so the remaining slots may be null. That is not a + /// deduction — it was validated by calling every eligible binding in both games with a sentinel handle + /// (CS2 186 of 193 clean, Dota 211 of 211), and the exceptions are exactly the shims this reports as + /// reading another slot. + pub fn needs(&self) -> &'static str { + if self.context { + "pulse-context" + } else if self.other { + "other-slots" + } else if self.sink { + "output-sink" + } else { + "args-only" + } + } +} + +/// Where an accessor's descriptor region LIVES, and how many elements it holds: `(base, count)`. +/// +/// The signature reader reconstructs the region's CONTENTS by constant-propagating the initialiser, +/// because on disk the elements are zeroes — they are written at runtime. That reconstruction is the +/// only offline route, and it is also unverified: the multi-library duplicate check reports that CS2 +/// disagrees with itself on 331 of 419 repeat registrations, and nothing offline can say which account +/// is right. +/// +/// A running server can. The region is a plain static, so at `slide + base` a live process holds the +/// POPULATED elements, and reading them settles the question against the same build rather than against +/// a dump of a different one. This accessor exists for that oracle; the derivation itself never needs it. +pub fn record_region(img: &CodeImage, accessor: u64) -> Option<(u64, u64)> { + let r = record(img, accessor)?; + (r.base != 0).then_some((r.base, r.count)) +} + +/// What a read of one argument slot demands of a HOST caller. +/// +/// The argument array (`r8`) demands nothing — the caller builds it, so reading it is the ordinary case +/// and `reads` already states it. The Pulse context (`rcx`) is VM-owned and cannot be supplied at all. +/// Everything else is a slot the caller would otherwise pass null. +/// +/// A named arm rather than a fall-through for `r8` specifically: dropping it into the `_` catch-all would +/// mark every ordinary binding as needing a slot no host can fill, retiring the entire `args-only` +/// callable tier — a collapse that reads as "this build has no callable bindings", which is a legitimate +/// answer for a game and therefore invisible. +fn slot_need(r: Register, out: &mut ShimReads) { + match r { + Register::RCX => out.context = true, + Register::R8 => {} + _ => out.other = true, + } +} + +/// Measure which of a shim's seven arguments it reads. +/// +/// Reachable instructions in ADDRESS order, which needs two guards that cost real time to find: +/// +/// * `push`/`pop` must NOT update the alias map. The compiler lays the epilogue out BEFORE the +/// found-path block, so `pop r13` sits at a lower address than the `mov rax,[r13+0x10]` that reads the +/// second argument through a stashed `mov r13, r8` — and letting the pop clear the alias loses the read. +/// The same shape cost the ConCommand reader an epoch counter. +/// * `xor r, r` / `sub r, r` name the register in BOTH operands and read neither. Counted, they mark an +/// argument live that the shim never consumes; `xor edi, edi` alone accounted for 143 false positives. +pub fn shim_reads(img: &CodeImage, entry: u64) -> Option { + let all = img.code_at(entry)?; + let code = &all[..(all.len() as u64).min(SHIM_SPAN) as usize]; + let mut insn = Instruction::default(); + let addrs = reachable(code, entry, 20000); + + let mut live: BTreeMap = BTreeMap::new(); + let mut sink = false; + let mut fresh: Vec = SHIM_SLOTS.to_vec(); + + for at in addrs { + let mut dec = + Decoder::with_ip(64, &code[(at - entry) as usize..], at, DecoderOptions::NONE); + dec.decode_out(&mut insn); + + // The first stack slot is the output sink. Only `[rbp+0x10]` is ever read — no shim in either + // game touches a second — which is what pins the arity at seven. + // + // The displacement MUST be read as signed. `memory_displacement64` is unsigned, so a local at + // `[rbp-0x10]` comes back as `0xffff_ffff_ffff_fff0`, which passes an unsigned `>= 0x10` — and + // every shim with a stack local then looks as though it reads the output sink. That mistake + // reported 246 sink-readers against a true 201 and hid two bindings whose callability had already + // been demonstrated by a live call. + if (insn.op0_kind() == OpKind::Memory || insn.op1_kind() == OpKind::Memory) + && insn.memory_base() == Register::RBP + && insn.memory_index() == Register::None + && insn.memory_displacement64() as i64 >= 0x10 + { + sink = true; + } + let zeroing = matches!(insn.mnemonic(), Mnemonic::Xor | Mnemonic::Sub) + && insn.op0_kind() == OpKind::Register + && insn.op1_kind() == OpKind::Register + && insn.op0_register().full_register() == insn.op1_register().full_register(); + // A register named inside a MEMORY operand is read even though it is not a register operand. + if !zeroing { + for r in [insn.memory_base(), insn.memory_index()] { + if r != Register::None && r != Register::RIP && fresh.contains(&r.full_register()) { + live.insert(r.full_register(), true); + } + } + for i in 0..insn.op_count() { + if insn.op_kind(i) != OpKind::Register { + continue; + } + let pure_dst = i == 0 + && matches!( + insn.mnemonic(), + Mnemonic::Mov | Mnemonic::Lea | Mnemonic::Movzx | Mnemonic::Movsxd + ); + let r = insn.op_register(i).full_register(); + if !pure_dst && fresh.contains(&r) { + live.insert(r, true); + } + } + } + + if insn.op_count() > 0 + && insn.op0_kind() == OpKind::Register + && !matches!(insn.mnemonic(), Mnemonic::Push | Mnemonic::Pop) + { + let d = insn.op0_register().full_register(); + fresh.retain(|&r| r != d); + } + if insn.flow_control() == FlowControl::Call { + for r in CALLER_SAVED { + fresh.retain(|&x| x != r); + } + } + } + + let mut out = ShimReads { + sink, + ..Default::default() + }; + for (r, name) in SHIM_SLOTS + .iter() + .zip(["rdi", "rsi", "rdx", "rcx", "r8", "r9"]) + { + if live.contains_key(r) { + out.reads.push(name); + slot_need(*r, &mut out); + } + } + if sink { + out.reads.push("stack0"); + } + Some(out) +} + /// A `PulseValueType_t` value, `PVAL_VOID` (-1) included. fn valid_pval(v: u64) -> bool { let s = v as i64; @@ -606,6 +777,59 @@ mod tests { assert!(candidate_strides(&r).is_empty()); } + #[test] + fn needs_reports_the_most_restrictive_requirement_a_shim_has() { + // Precedence matters: a shim reading both the context and the sink is not "output-sink", because + // the context is the one a host cannot supply at all. Ordering it the other way would advertise + // a binding as merely needing a sink when it actually needs a live cursor. + let ctx = ShimReads { + context: true, + sink: true, + reads: vec!["rcx", "r8", "stack0"], + ..Default::default() + }; + assert_eq!(ctx.needs(), "pulse-context"); + let other = ShimReads { + other: true, + sink: true, + reads: vec!["rdi", "r8", "stack0"], + ..Default::default() + }; + assert_eq!(other.needs(), "other-slots"); + let sink = ShimReads { + sink: true, + reads: vec!["r8", "stack0"], + ..Default::default() + }; + assert_eq!(sink.needs(), "output-sink"); + // The callable tier: the argument array and nothing else. + let only = ShimReads { + reads: vec!["r8"], + ..Default::default() + }; + assert_eq!(only.needs(), "args-only"); + // A shim reading NOTHING is still args-only — a zero-argument binding reads no array either. + assert_eq!(ShimReads::default().needs(), "args-only"); + } + + #[test] + fn reading_the_argument_array_leaves_a_shim_host_callable() { + // Asserted against the shipped rule rather than a copy of it. `r8` is the argument array the + // CALLER builds, so a read of it must impose nothing; the arm exists only to keep it out of the + // catch-all, where it would mark every ordinary binding uncallable at once. + let mut r8 = ShimReads::default(); + slot_need(Register::R8, &mut r8); + assert_eq!(r8.needs(), "args-only"); + let mut rcx = ShimReads::default(); + slot_need(Register::RCX, &mut rcx); + assert_eq!(rcx.needs(), "pulse-context"); + for r in [Register::RDI, Register::RSI, Register::RDX, Register::R9] { + let mut o = ShimReads::default(); + slot_need(r, &mut o); + assert_eq!(o.needs(), "other-slots", "{r:?} is a slot a host must fill"); + } + } + #[test] fn pval_void_is_negative_one_and_still_a_type() { assert!(valid_pval(0)); // PVAL_BOOL diff --git a/src/rtti.rs b/src/rtti.rs index 7ae21b7..c2aabce 100644 --- a/src/rtti.rs +++ b/src/rtti.rs @@ -18,11 +18,9 @@ pub struct VTable { /// One vtable discovered by the whole-binary sweep — the class inventory row. pub struct ClassVtable { - pub mangled: String, // the raw `_ZTS` type name, e.g. "11CBaseEntity" pub name: String, // demangled, e.g. "CBaseEntity" pub vtable_va: u64, // vaddr of slot index 0 pub offset_to_top: i64, // 0 for the primary (complete-object) vtable; <0 for sub-object tables - pub typeinfo: u64, // vaddr of the Itanium typeinfo struct pub slots: Vec, // method vaddrs; a method's gamedata offset == its index here pub bases: Vec, // direct base classes (the is-a graph edges) } @@ -143,10 +141,10 @@ fn demangle_type(mangled: &str) -> String { .unwrap_or_else(|| mangled.to_string()) } -/// If `ti` addresses a valid Itanium typeinfo, return its `(mangled, demangled)` class name. +/// If `ti` addresses a valid Itanium typeinfo, return its DEMANGLED class name. /// A typeinfo is `[kind_vtable_ptr][name_ptr][ base-class data … ]`: `+0` points at one of the /// C++ runtime's type_info-kind vtables, `+8` at the `_ZTS` name string. -fn typeinfo_name(img: &CodeImage, ti: u64, kinds: &RttiKinds) -> Option<(String, String)> { +fn typeinfo_name(img: &CodeImage, ti: u64, kinds: &RttiKinds) -> Option { // +0 must be one of the three kind vtables. Prefer the symbol-name-derived tag (the only signal that // survives a DYNAMICALLY-linked C++ runtime, where the three kinds all resolve to the same offline // value); else fall back to the in-image value check (statically-linked / stripped builds). @@ -163,7 +161,7 @@ fn typeinfo_name(img: &CodeImage, ti: u64, kinds: &RttiKinds) -> Option<(String, if !(c0.is_ascii_digit() || matches!(c0, b'N' | b'I' | b'P' | b'K' | b'S')) { return None; } - Some((mangled.clone(), demangle_type(&mangled))) + Some(demangle_type(&mangled)) } /// Direct base classes of the typeinfo at `ti`, dispatched on its exact Itanium kind. @@ -187,7 +185,7 @@ fn typeinfo_bases(img: &CodeImage, ti: u64, kinds: &RttiKinds) -> Vec Some(KindTag::Si) => { // __si_class_type_info: one public, non-virtual base at offset 0; its typeinfo ptr at +16. if let Some(bp) = img.read_ptr(ti.wrapping_add(16)) - && let Some((_, name)) = typeinfo_name(img, bp, kinds) + && let Some(name) = typeinfo_name(img, bp, kinds) { return vec![BaseClass { name, @@ -199,7 +197,7 @@ fn typeinfo_bases(img: &CodeImage, ti: u64, kinds: &RttiKinds) -> Vec } Some(KindTag::Vmi) => { // __vmi_class_type_info: flags@+16, base_count@+20, then 16-byte {typeinfo_ptr, offset_flags}. - let Some(count) = img.read_u32(ti + 20) else { + let Some(count) = img.read_u32(ti.wrapping_add(20)) else { return Vec::new(); }; if count == 0 || count > 128 { @@ -211,7 +209,7 @@ fn typeinfo_bases(img: &CodeImage, ti: u64, kinds: &RttiKinds) -> Vec let Some(bp) = img.read_ptr(e) else { break; }; - if let Some((_, name)) = typeinfo_name(img, bp, kinds) { + if let Some(name) = typeinfo_name(img, bp, kinds) { let of = img.read_i64(e.wrapping_add(8)).unwrap_or(0); bases.push(BaseClass { name, @@ -239,7 +237,7 @@ pub fn enumerate_vtables(img: &CodeImage, max_slots: usize) -> Vec if slot < 8 { continue; } - let Some((mangled, name)) = typeinfo_name(img, val, &kinds) else { + let Some(name) = typeinfo_name(img, val, &kinds) else { continue; }; // No de-dup guard: `reloc_slots` iterates a map KEYED by slot vaddr, so every slot — and hence @@ -259,11 +257,9 @@ pub fn enumerate_vtables(img: &CodeImage, max_slots: usize) -> Vec } let bases = typeinfo_bases(img, val, &kinds); out.push(ClassVtable { - mangled, name, vtable_va, offset_to_top: ott, - typeinfo: val, slots, bases, }); diff --git a/src/schema.rs b/src/schema.rs index 90da873..b2dece6 100644 --- a/src/schema.rs +++ b/src/schema.rs @@ -60,6 +60,10 @@ pub const CURRENT_LAYOUT: SchemaLayout = SchemaLayout { ci_base_count: 41, ci_fields: 48, ci_bases: 56, + // Every displacement below is added to a FILE-CONTROLLED pointer, so each use wraps rather than + // panicking under the overflow-checked fuzz build. That includes the ones that are 0 today: they are + // layout values, revised when Valve reshapes the struct, and "safe because this constant happens to + // be zero" is a trap that springs on the revision rather than on the code that introduced it. f_name: 0, f_offset: 16, f_stride: 32, @@ -157,7 +161,10 @@ pub fn enumerate_schema(img: &CodeImage) -> Vec { out.push(cls); } } - out.sort_by(|a, b| a.name.cmp(&b.name)); + // By NAME, then by the record's own address. The walk iterates `reloc_slots()`, which is a HashMap, + // so the collection order is hash order; a sort on name alone is stable and therefore leaves ties — + // two libraries registering one class — resolved by that hash order, in a byte-reproducible artifact. + out.sort_by(|a, b| (&a.name, a.class_info).cmp(&(&b.name, b.class_info))); out } @@ -185,11 +192,49 @@ const EV_VALUE: u64 = 8; /// field that isn't a count at all before it drives an allocation. const EB_MAX_VALUES: u32 = 4096; -/// Enumerate every registered enum in `img`, alongside [`enumerate_schema`]'s classes. Same reloc-driven -/// discovery: an enum binding is found by the slot holding its type-name pointer, then accepted only if -/// the width/count word and the enumerator array both read as what they claim to be — so a layout change -/// yields fewer enums, never wrong ones. Sorted by name. -pub fn enumerate_enums(img: &CodeImage) -> Vec { +/// Enumerate every registered enum in `img`, given the classes [`enumerate_schema`] already recovered. +/// Same reloc-driven discovery: an enum binding is found by the slot holding its type-name pointer, then +/// accepted only if the width/count word and the enumerator array both read as what they claim to be — +/// so a layout change yields fewer enums, never wrong ones. Sorted by name. +/// +/// **A class's FIELD descriptor is byte-compatible with an enum binding**, which is why `classes` is a +/// parameter rather than a convenience. `SchemaClassFieldData_t` is `{ name, type, offset, metadataCount, +/// metadata }`: read as an enum binding, the name reads as a type name, the low bytes of the offset read +/// as a plausible size/alignment, the metadata count reads as an enumerator count, and the metadata array +/// — `{ name, data }` pairs — reads as enumerators. Every field carrying exactly one metadata tag at a +/// field offset whose low two bytes are both powers of two therefore fits, and the result would be an +/// enum that does not exist, named after a member, whose one "value" is the ADDRESS of a documentation +/// string and therefore differs between runs of the same build. +/// +/// Two independent structural facts reject them, and both are needed — measured over 1,016 CS2 and 1,490 +/// Dota candidates, they catch 40 apiece with zero real enums lost, and neither catches all 40 alone: +/// +/// 1. **The record sits inside a class's field array**, at a `F_STRIDE` boundary. That is not a heuristic +/// — the SchemaSystem states that this address is that class's Nth field. +/// 2. **An enumerator's value is a relocation.** An enum value is a compile-time literal, so it is never +/// relocated; a metadata entry's second word is a pointer, so it always is. This is what catches a +/// field whose owning class the class walk itself rejected, leaving no array to fall inside. +pub fn enumerate_enums(img: &CodeImage, classes: &[SchemaClass]) -> Vec { + // The address ranges class field descriptors occupy, sorted so membership is a binary search. + let mut spans: Vec<(u64, u64)> = classes + .iter() + .filter_map(|c| { + let fp = img.read_ptr(c.class_info.wrapping_add(CI_FIELDS))?; + (fp != 0).then(|| (fp, fp.wrapping_add(F_STRIDE * c.fields.len() as u64))) + }) + .collect(); + spans.sort_unstable(); + // Each class owns its own array, so the ranges are disjoint and the last one starting at or before + // `a` is the only one that can contain it. If that ever stopped holding, the miss would be a fake + // enum surviving rather than a real one dropped — the same direction every other guard here errs in. + let in_field_array = |a: u64| { + let i = spans.partition_point(|&(s, _)| s <= a); + i > 0 && { + let (s, e) = spans[i - 1]; + a < e && (a - s).is_multiple_of(F_STRIDE) + } + }; + let mut out = Vec::new(); for (slot, val) in img.reloc_slots() { let Some(name) = img.read_c_string(val) else { @@ -201,6 +246,10 @@ pub fn enumerate_enums(img: &CodeImage) -> Vec { continue; } let base = slot.wrapping_sub(EB_TYPE_NAME); + // Clause 1: the SchemaSystem states this address is a class's field descriptor, so it is one. + if in_field_array(base) { + continue; + } let Some(w) = img.read_ptr(base.wrapping_add(EB_WIDTH)) else { continue; }; @@ -228,7 +277,10 @@ pub fn enumerate_enums(img: &CodeImage) -> Vec { ) else { break; }; - if n.is_empty() { + // Clause 2: a relocated "value" is a pointer, so these are `{ name, data }` metadata + // entries and not enumerators. Rejects the whole record — one pointer among the values + // means the array is the wrong kind, not that one enumerator is odd. + if n.is_empty() || img.is_reloc_slot(rec.wrapping_add(EV_VALUE)) { break; } values.push((n, v)); @@ -242,7 +294,13 @@ pub fn enumerate_enums(img: &CodeImage) -> Vec { }); } } - out.sort_by(|a, b| a.name.cmp(&b.name)); + // Same reason as `enumerate_schema`, and it matters MORE here because the `dedup_by` below then keeps + // whichever row sorted first: with a name-only sort that survivor was picked by hash order. Enums have + // no record address on the struct, so the tiebreak is the content that distinguishes two accounts of + // one name — width, alignment, then the enumerator list. + out.sort_by(|a, b| { + (&a.name, a.size, a.align, &a.values).cmp(&(&b.name, b.size, b.align, &b.values)) + }); out.dedup_by(|a, b| a.name == b.name); // one binding per name; libs re-register shared enums out } @@ -272,10 +330,13 @@ fn parse_class(img: &CodeImage, base: u64, name: &str, name_ptr: u64) -> Option< let mut fields = Vec::with_capacity(field_count as usize); for i in 0..field_count as u64 { let fe = fields_ptr.wrapping_add(i.wrapping_mul(F_STRIDE)); - let Some(fname) = img.read_ptr(fe + F_NAME).and_then(|p| img.read_c_string(p)) else { + let Some(fname) = img + .read_ptr(fe.wrapping_add(F_NAME)) + .and_then(|p| img.read_c_string(p)) + else { break; }; - let offset = img.read_i32(fe + F_OFFSET).unwrap_or(0); + let offset = img.read_i32(fe.wrapping_add(F_OFFSET)).unwrap_or(0); fields.push(SchemaField { name: fname, offset, @@ -288,13 +349,13 @@ fn parse_class(img: &CodeImage, base: u64, name: &str, name_ptr: u64) -> Option< if bases_ptr != 0 { for i in 0..base_count as u64 { let be = bases_ptr.wrapping_add(i.wrapping_mul(B_STRIDE)); - let offset = img.read_u32(be + B_OFFSET).unwrap_or(0); - let bcls = img.read_ptr(be + B_CLASS).unwrap_or(0); + let offset = img.read_u32(be.wrapping_add(B_OFFSET)).unwrap_or(0); + let bcls = img.read_ptr(be.wrapping_add(B_CLASS)).unwrap_or(0); if bcls == 0 { continue; } if let Some(bn) = img - .read_ptr(bcls + CI_NAME) + .read_ptr(bcls.wrapping_add(CI_NAME)) .and_then(|p| img.read_c_string(p)) { bases.push(SchemaBase { name: bn, offset }); @@ -316,7 +377,7 @@ fn parse_class(img: &CodeImage, base: u64, name: &str, name_ptr: u64) -> Option< // The offline reader above recovers class layouts (names + field offsets) from the static reflection // tables. Field *types* are runtime-resolved (each record's `m_pType` is a null pointer on disk), so // `live_schema` attaches to a running process, reads the types back, and builds the typed -// `netvars-.json` (`model::Schema`) directly — no `sdk.json` intermediate. +// the artifact's `schema` section (`model::Schema`) directly — no `sdk.json` intermediate. /// FNV-1a (32-bit). The Source-2 schema field/class name hash: a field's runtime lookup key is /// `(fnv1a32(class_name) << 32) | fnv1a32(field_name)` (field name keeps its `m_` prefix). Confirmed @@ -344,7 +405,7 @@ fn builtin_size(t: &str) -> i32 { /// Walk a running process's schema across every server-mapped library (`profile.libs`) and build the typed /// netvars (`model::Schema`) DIRECTLY — no `sdk.json` round-trip: field layout is read offline from each /// image, the runtime `m_pType` from the live process. Shared classes (compiled into many libs) de-dupe -/// precedence-first (the earlier lib in `libs` wins). This is `netvars-.json` — the shipped SDK +/// precedence-first (the earlier lib in `libs` wins). This is the artifact's `schema` section — the shipped SDK /// material (`source2rosetta-gen` renders it on demand). pub(crate) fn live_schema( prof: &GameProfile, @@ -370,9 +431,13 @@ pub(crate) fn live_schema( }; let Some(base) = live.base(lib) else { continue }; // lib not mapped in the process -> skip nlibs += 1; + // ONE class walk per library, shared by both consumers below — the enum walk needs it to tell a + // field descriptor from an enum binding, and walking the reflection tables twice per image is + // what a large game's memory ceiling notices first. + let schema_classes = enumerate_schema(&img); // Enum bindings are static, so they come from the IMAGE — no process read, unlike field types. // First library wins, matching the class precedence: a shared enum has one definition. - for e in enumerate_enums(&img) { + for e in enumerate_enums(&img, &schema_classes) { enums.entry(e.name).or_insert_with(|| model::EnumDef { size: e.size, values: e @@ -382,7 +447,7 @@ pub(crate) fn live_schema( .collect(), }); } - for c in &enumerate_schema(&img) { + for c in &schema_classes { // a shared class already taken from an earlier (higher-precedence) lib — identical layout, skip if !seen.insert(c.name.clone()) { continue; diff --git a/src/valvetab.rs b/src/valvetab.rs index 67ae48a..6ddab5f 100644 --- a/src/valvetab.rs +++ b/src/valvetab.rs @@ -46,6 +46,19 @@ pub struct PulseBinding { pub descriptor: u64, /// A second accessor of the same shape, for the binding's argument descriptor. pub arg_descriptor: u64, + /// The binding's own INVOCATION shim — the one code pointer in the record that is an entry point + /// rather than a descriptor accessor. Zero when the slot holds no executable code (8 of 485 on CS2). + /// + /// Measured as a fixed-signature marshalling stub: seven integer arguments returning int, where the + /// fifth is an array of pointers to the argument values (element *k* at `+8+8k`) and the seventh is an + /// output sink read by exactly the bindings that declare a return. + /// + /// It IS emitted, and the measurement above is not the reason to trust it — the live oracle is. The + /// address and its measured read-set ship as `surfaces.pulse[].shim` / `.call`; `verify_pulse_shims` + /// actually CALLS every `args-only` shim on a running server each build (CS2 186 of 193 clean, Dota + /// 211 of 211); and `GameProfile::min_pulse_callable` floors the population that survives. A locator + /// nobody has exercised would be a claim — this one is exercised every derive. + pub shim: u64, pub flags: PulseFlags, } @@ -302,6 +315,10 @@ pub fn pulse_bindings(img: &CodeImage) -> Vec { description: img.read_ptr(at + 16).and_then(|p| table_string(img, p)), descriptor, arg_descriptor, + shim: img + .read_ptr(at + 72) + .filter(|&p| img.is_code(p)) + .unwrap_or(0), flags: PulseFlags::decode( img.read_u32(at + 56).unwrap_or(0), img.read_u32(at + 60).unwrap_or(0), diff --git a/src/vscript.rs b/src/vscript.rs new file mode 100644 index 0000000..50d3793 --- /dev/null +++ b/src/vscript.rs @@ -0,0 +1,558 @@ +//! The VScript binding registry — the fourth surface a Source-2 module documents about itself, and the +//! only one that states a function's PARAMETER NAMES. +//! +//! Valve exposes a subset of the C++ surface to script (Lua in Dota's custom games, and a smaller set in +//! CS2). Every exposed method is registered with the script VM through a descriptor carrying its +//! script-facing name, its C++ name, an English description, a return type, and a pointer to the +//! implementation. That is a locator AND a prototype AND documentation, all stated by Valve, which makes +//! it the same kind of find as the Pulse registry and the console-command registration. +//! +//! # Why this is not a table walk +//! +//! The obvious route — find a static array of descriptors and read it — does not work, and the reason is +//! worth stating because it costs a day to rediscover. The descriptors are built at RUNTIME: a scan of +//! Dota's `libserver.so` finds 2,268,664 `R_X86_64_RELATIVE` relocations and **not one** points at a +//! description string. On disk the descriptor array is zeroes. +//! +//! What is static is the CODE that fills it in, and every field is a constant in the instruction stream. +//! This is the same shape the Pulse parameter records turned out to have, and the same answer applies: +//! constant-propagate through the initialiser rather than read the table. +//! +//! ```text +//! movq xmm0, [rip+slot] ; the script-facing name, via a relocated .data.rel.ro slot +//! lea rdx, [rip+"Script_TakeDamage"] +//! pinsrq xmm0, rdx, 1 ; pack both names into one 16-byte store +//! lea rsi, [rip+"Applies damage to this entity."] +//! lea rax, [rax+rax*4] ; index * 5 +//! shl rax, 4 ; * 16 -> stride 80 +//! add rax, [rbx+0x28] ; base = owning class descriptor's function array +//! mov [rax+0x30], rbx ; owner +//! mov [rax+0x10], rsi ; description +//! movups [rax], xmm0 ; +0x00 script name, +0x08 C++ name +//! mov [rax+0x18], r11w ; return type +//! ``` +//! +//! # The record +//! +//! **80 bytes**, derived rather than assumed — the `lea r,[r+r*4]` / `shl r,4` pair states it in the +//! instruction stream, so a stride change is a decode failure rather than silent corruption. +//! +//! | offset | field | +//! |---|---| +//! | `+0x00` | script-facing name (`TakeDamage`) | +//! | `+0x08` | C++ binding name (`Script_TakeDamage`) | +//! | `+0x10` | Valve's English description | +//! | `+0x18` | return type, a `u16` | +//! | `+0x28` | a name string — the return value's, where one is given | +//! | `+0x30` | the owning class descriptor | +//! | `+0x38` | the marshalling thunk, SHARED by every binding of the same shape | +//! | `+0x40` | pointer-to-member: the implementation | +//! | `+0x48` | a `u32` count | +//! +//! `+0x40` is an Itanium pointer-to-member, which is convenient rather than awkward: a non-virtual +//! member is a plain address and a virtual one is `slot * 8 + 1`. Those are exactly the two locator +//! forms the rest of this crate already emits, so a VScript binding lands in `gamedata` as either a +//! signature or a vtable offset with no new concept. +//! +//! Do not confuse `+0x38` with `+0x40`. The thunk at `+0x38` is a compiler-generated trampoline shared +//! across every binding with the same signature; folding it would ship dozens of distinct names all +//! pointing at one address. That is the same mistake the Pulse `+24`/`+32` accessors invite, and it is +//! caught here the same way — by the sharing itself, since a real implementation is referenced once. +//! +//! # Shape-driven, so a layout change yields FEWER bindings and never wrong ones +//! +//! Nothing here is anchored on an address, a symbol or a fixed offset into the image. A record is +//! recognised by what the initialiser DOES — a 16-byte store of two plausible name strings, a +//! description or nothing at `+0x10`, a small return type, and a `+0x40` that is either executable code +//! or a small odd integer. A build that reshapes the descriptor fails those tests and produces nothing, +//! which the release floor then catches. + +use crate::elf::CodeImage; +use iced_x86::{Decoder, DecoderOptions, FlowControl, Instruction, Mnemonic, OpKind, Register}; +use std::collections::{BTreeMap, HashMap}; + +/// The record stride, in bytes. Stated by the initialiser's own `idx*5 << 4`; kept as a constant only to +/// validate what is decoded. +/// +/// `pub(crate)` because the LIVE class walk in `produce` steps the same records and must step them by +/// the same number. Unlike the Pulse element stride this one is NOT derived by consensus — the +/// initialiser states it in the instruction stream, so there is nothing to vote on — and a build that +/// changes it shows up as decoded records failing validation here, not as a mis-strided live walk. +pub(crate) const STRIDE: i64 = 80; + +/// Field displacements within the record. +const F_NAME: i64 = 0x00; +const F_CPP: i64 = 0x08; +const F_DESC: i64 = 0x10; +const F_RET: i64 = 0x18; +const F_IMPL: i64 = 0x40; + +/// Longest accepted name/description, so a mis-decoded pointer into the middle of a blob cannot produce a +/// megabyte "name". +const MAX_NAME: usize = 128; +const MAX_DESC: usize = 512; + +/// `ScriptDataType_t`, DERIVED by joining recovered bindings against Valve's own published VScript dump +/// rather than assumed from Source's historical ordering. +/// +/// The distinction matters, and the first attempt at this table is the reason it is spelled out. Two +/// anchors were available by inspection — a binding returning `float` stores `1`, one returning `int` +/// stores `5` — and they fit Source 1's long-standing `FIELD_*` ordering, in which `5` is `BOOLEAN`. That +/// reading was WRONG: joined against 389 bindings whose return type Valve states, `5` is `int` and `6` is +/// `bool`. Two points are enough to fit a plausible table and not enough to check one. +/// +/// Agreement on the derived table is total where a comparison is meaningful. The apparent disagreements +/// are Valve naming a SEMANTIC type over the same ABI type: `5` also covers `modifierpriority` and +/// `UnitFilterResult` (enums, which are ints), and `31` also covers `CDOTA_BaseNPC` and `CBaseEntity` +/// (entity handles, which are handles). +/// +/// The raw word ships beside the decoded name regardless — the rule `flags_raw` already follows — so a +/// build that renumbers this can be re-read rather than silently mislabelled. +const RET_TYPES: [(u16, &str); 13] = [ + (0, "void"), + (1, "float"), + (3, "Vector"), + (5, "int"), + (6, "bool"), + (13, "ehandle"), + (14, "Vector"), + (29, "unknown"), + (30, "string"), + (31, "handle"), + (32, "table"), + (37, "uint"), + (39, "QAngle"), +]; + +/// Decode a return-type word, or `None` when the value is outside what is corroborated. +pub fn ret_type_name(raw: u16) -> Option<&'static str> { + RET_TYPES.iter().find(|(v, _)| *v == raw).map(|(_, n)| *n) +} + +/// Where a binding's implementation lives, decoded from the pointer-to-member at `+0x40`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Impl { + /// A non-virtual member: the address itself. + Addr(u64), + /// A virtual member: `(pmf - 1) / 8` is the vtable slot index. + Slot(u64), +} + +/// One registered VScript binding. +#[derive(Clone, Debug)] +pub struct VScriptFunc { + /// The script-facing name a Lua author calls (`TakeDamage`). + pub name: String, + /// The C++ binding name (`Script_TakeDamage`). Often but not always the script name with a prefix. + pub cpp_name: String, + /// Valve's own English description, where the registration supplies one. + pub description: Option, + /// The return type as stored, undecoded. + pub ret_raw: u16, + /// The return type decoded, or `None` if the value is outside the corroborated set. + pub ret: Option<&'static str>, + /// The implementation, as an address or a vtable slot. + pub imp: Option, +} + +/// What a register provably holds — CONSTANTS only, which is where this parts company with `concmd`'s +/// tracker. +/// +/// There is no symbolic-base variant here and none is needed: a store is credited to a record through +/// `recid`, propagated across `mov rD,rS`, rather than through a `(register, epoch)` pair. That is why +/// the base survives being copied between registers, and why this tracker needs no epoch counter. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +enum V { + Unknown, + Const(u64), +} + +impl V { + fn konst(self) -> Option { + match self { + V::Const(c) => Some(c), + V::Unknown => None, + } + } +} + +/// The 64-bit parent register as a slot index. Thin wrapper over [`crate::abi::gp_slot`] — the mapping is a +/// fixed SysV fact, and this file only narrows it to the `u8` its `[_; 16]` arrays index by. +fn gpr(r: Register) -> Option { + crate::abi::gp_slot(r).map(|s| s as u8) +} + +fn xmm(r: Register) -> Option { + r.is_xmm() + .then(|| (r as usize - Register::XMM0 as usize) as u8) + .filter(|i| *i < 16) +} + +/// A field of a particular record: which record, and the displacement within it. +type Slot = (u32, i64); + +/// Read a NUL-terminated string, rejecting anything that is not plausibly a name. +fn text(img: &CodeImage, va: u64, max: usize) -> Option { + let s = img.read_c_string(va)?; + if s.is_empty() || s.len() > max { + return None; + } + s.chars() + .all(|c| c.is_ascii_graphic() || c == ' ') + .then_some(s) +} + +/// An identifier-shaped string — what a script-facing or C++ name must look like. Deliberately strict: +/// a mis-decoded pointer usually lands on prose or a path, and both fail this. +fn ident(img: &CodeImage, va: u64) -> Option { + let s = text(img, va, MAX_NAME)?; + let ok = s + .chars() + .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == ':') + && s.chars() + .next() + .is_some_and(|c| c.is_ascii_alphabetic() || c == '_'); + ok.then_some(s) +} + +/// Decode the pointer-to-member at `+0x40`. +/// +/// The two forms are distinguished by the low bit, per the Itanium ABI. Both are validated: an address +/// has to land in executable code, and a slot index has to be small enough to be a real vtable position. +/// Anything else means the field is not what this reader thinks it is, and yields `None` rather than a +/// confident wrong locator. +fn decode_pmf(img: &CodeImage, pmf: u64) -> Option { + if pmf == 0 { + return None; + } + if pmf & 1 == 1 { + let slot = (pmf - 1) / 8; + // 2048 is the same ceiling `rtti` reads vtables to; past it this is not a slot index. + (slot < 2048 && (pmf - 1).is_multiple_of(8)).then_some(Impl::Slot(slot)) + } else { + img.is_code(pmf).then_some(Impl::Addr(pmf)) + } +} + +/// Recover every VScript binding the image registers. +/// +/// One pass over the candidate functions, tracking what each register and XMM half provably holds and +/// collecting stores to record-relative slots. A group of stores is accepted as a binding only if it +/// presents the full shape, so partial or coincidental matches are dropped rather than guessed at. +pub fn vscript_functions(img: &CodeImage) -> Vec { + let entries = crate::locate::function_entries(img); + + let mut out: Vec = Vec::new(); + let mut insn = Instruction::default(); + + for (i, &start) in entries.iter().enumerate() { + let end = entries.get(i + 1).copied().unwrap_or(u64::MAX); + let Some(code) = img.code_range(start, end) else { + continue; + }; + + let mut val = [V::Unknown; 16]; + // Which registers currently hold a RECORD BASE, and which hold the half-built `idx*80` on the way + // to one. This is the structural anchor: a store is only collected when its base was computed by + // the initialiser's own `idx*5 << 4 + [class+0x28]`. Without it the pass collects any struct with + // two string pointers at +0x00/+0x08, and `libserver` has at least one other table of that shape + // (the network field serialisers) which then contributes records whose "name" is a netvar. + let mut scaled = [false; 16]; + // Which RECORD each register currently points at, not merely whether it points at one. Keying on + // identity rather than on (register, epoch) is what lets a base survive `mov rcx,rax` — the + // compiler routinely copies the base and then reuses the original for something else, writing + // half a record through each. Keyed by register, those two halves land in different groups and + // neither is complete. + let mut recid: [Option; 16] = [None; 16]; + let mut next_rec: u32 = 0; + // Each XMM tracked as its two 64-bit halves, which is the only way the packed name store is + // readable: both names reach the record through one 16-byte write. + let mut xr = [(V::Unknown, V::Unknown); 16]; + let mut stores: HashMap = HashMap::new(); + + let mut dec = Decoder::with_ip(64, code, start, DecoderOptions::NONE); + while dec.can_decode() { + dec.decode_out(&mut insn); + + if insn.flow_control() == FlowControl::Call { + // Registers a call clobbers, so a value cannot survive one and be attributed to the wrong + // record. Taken from `abi`, not transcribed as raw GPR indices — a second copy of a fixed + // SysV fact is a copy that can drift. + for c in crate::abi::caller_saved_slots() { + val[c] = V::Unknown; + scaled[c] = false; + recid[c] = None; + } + xr = [(V::Unknown, V::Unknown); 16]; + // MEASURED DEAD END, recorded so it is not re-attempted: treating `rax` as a speculative + // record base after every call — on the theory that some registrations allocate a record + // and fill it through the returned pointer — reintroduces precisely the network-field + // serialisers the record-base anchor exists to reject (`CBaseEntity`/`m_fFlags`, + // `CNetworkOriginCellCoordQuantizedVector`/`m_cellX`, the `*ChangedCompat` callbacks) and + // recovers no additional binding. The structure built through a call's return here is the + // CLASS descriptor, not a function record: its `+0x00`/`+0x08` hold the class name twice. + continue; + } + + match insn.mnemonic() { + // `lea r,[rip+d]` — a string or global address. `lea rD,[rS+rS*4]` is something else + // entirely: the first half of the record-base computation, `idx * 5`. + Mnemonic::Lea => { + if let Some(d) = gpr(insn.op0_register()) { + let times_five = insn.memory_index() != Register::None + && insn.memory_base() == insn.memory_index() + && insn.memory_index_scale() == 4 + && insn.memory_displacement64() == 0; + val[d as usize] = if insn.is_ip_rel_memory_operand() { + V::Const(insn.ip_rel_memory_address()) + } else { + V::Unknown + }; + scaled[d as usize] = times_five; + recid[d as usize] = None; + } + } + + // `xor rD,rD` is the zeroing idiom, not an arithmetic unknown. It matters more here than + // it looks: a `void` binding sets its return type with `xor r11d,r11d` and then stores + // `r11w`, so treating this as an unknown loses every void-returning binding — which on + // Dota is most of them. + Mnemonic::Xor => { + if let (Some(d), Some(s)) = (gpr(insn.op0_register()), gpr(insn.op1_register())) + { + val[d as usize] = if d == s { V::Const(0) } else { V::Unknown }; + scaled[d as usize] = false; + recid[d as usize] = None; + } + } + + // `shl rD,4` completes `idx * 80`. Any other shift of a scaled register means this is + // not the idiom and the candidate is dropped. + Mnemonic::Shl => { + if let Some(d) = gpr(insn.op0_register()) { + let keep = scaled[d as usize] + && insn.op1_kind() == OpKind::Immediate8 + && insn.immediate8() == 4; + val[d as usize] = V::Unknown; + scaled[d as usize] = keep; + recid[d as usize] = None; + } + } + + // `add rD,[class+0x28]` turns `idx * 80` into the record's own address. From here every + // store through `rD` is a field of one binding. + Mnemonic::Add => { + if let Some(d) = gpr(insn.op0_register()) { + let base = scaled[d as usize] && insn.op1_kind() == OpKind::Memory; + val[d as usize] = V::Unknown; + scaled[d as usize] = false; + recid[d as usize] = base.then(|| { + next_rec += 1; + next_rec + }); + } + } + + // `movq xmm,[rip+slot]` loads a RELOCATED pointer — the script-facing name arrives this + // way rather than as a `lea`, and reading it needs the relocation applied, which + // `read_ptr` does. `movq xmm,r64` and the reverse also appear. + Mnemonic::Movq | Mnemonic::Movd => { + if let Some(x) = xmm(insn.op0_register()) { + let lo = if insn.op1_kind() == OpKind::Memory { + if insn.is_ip_rel_memory_operand() { + img.read_ptr(insn.ip_rel_memory_address()) + .map_or(V::Unknown, V::Const) + } else { + V::Unknown + } + } else if let Some(s) = gpr(insn.op1_register()) { + val[s as usize] + } else { + V::Unknown + }; + // `movq` zeroes the upper half; that matters because the high name is inserted + // afterwards and must not inherit a stale value. + xr[x as usize] = (lo, V::Const(0)); + } + } + + // `pinsrq xmm,r64,1` — the second name packed into the high half. + Mnemonic::Pinsrq => { + if let (Some(x), Some(s)) = (xmm(insn.op0_register()), gpr(insn.op1_register())) + && insn.op2_kind() == OpKind::Immediate8 + { + let v = val[s as usize]; + if insn.immediate8() == 1 { + xr[x as usize].1 = v; + } else { + xr[x as usize].0 = v; + } + } + } + + // `movddup xmm,[rip+slot]` — ONE pointer written into both halves. This is the form the + // compiler picks when the script-facing name and the C++ name are the SAME string, which + // is the common case: only the bindings that need a distinct C++ name (usually a + // `Script_`-prefixed wrapper) load two pointers. Missing this mnemonic costs roughly + // four fifths of the registry on Dota, so it is not an edge case. + Mnemonic::Movddup => { + if let Some(x) = xmm(insn.op0_register()) { + let v = if insn.is_ip_rel_memory_operand() { + img.read_ptr(insn.ip_rel_memory_address()) + .map_or(V::Unknown, V::Const) + } else { + V::Unknown + }; + xr[x as usize] = (v, v); + } + } + + // `punpcklqdq x0,x1` — the same pack, reached the other way. + Mnemonic::Punpcklqdq => { + if let (Some(a), Some(b)) = (xmm(insn.op0_register()), xmm(insn.op1_register())) + { + xr[a as usize] = (xr[a as usize].0, xr[b as usize].0); + } + } + + // The 16-byte store that lands both names. + Mnemonic::Movups | Mnemonic::Movaps | Mnemonic::Movdqu | Mnemonic::Movdqa => { + if insn.op0_kind() == OpKind::Memory + && let Some(x) = xmm(insn.op1_register()) + && let Some(b) = gpr(insn.memory_base()) + && insn.memory_index() == Register::None + && let Some(rec) = recid[b as usize] + { + let d = insn.memory_displacement64() as i64; + if let Some(v) = xr[x as usize].0.konst() { + stores.insert((rec, d), v); + } + if let Some(v) = xr[x as usize].1.konst() { + stores.insert((rec, d + 8), v); + } + } + } + + Mnemonic::Mov => { + // Store to a record-relative slot: `mov [base+d], reg` or `mov [base+d], imm`. + if insn.op0_kind() == OpKind::Memory + && insn.memory_index() == Register::None + && let Some(b) = gpr(insn.memory_base()) + && let Some(rec) = recid[b as usize] + { + let d = insn.memory_displacement64() as i64; + let v = match insn.op1_kind() { + // A 16-bit store carries the return type. The tracker follows full + // registers, so `mov [rec+0x18], r11w` reads back through `r11`. + OpKind::Register => { + gpr(insn.op1_register()).and_then(|s| val[s as usize].konst()) + } + OpKind::Immediate8 | OpKind::Immediate16 | OpKind::Immediate32 => { + Some(insn.immediate32to64() as u64) + } + OpKind::Immediate32to64 | OpKind::Immediate8to64 => { + Some(insn.immediate64()) + } + _ => None, + }; + if let Some(v) = v { + stores.insert((rec, d), v); + } + continue; + } + // Register-to-register and immediate loads feed the tracker. + if let Some(d) = gpr(insn.op0_register()) { + // A plain `mov rD,rS` carries the RECORD IDENTITY across, not just the value. + // This is the whole reason identity is tracked instead of a per-register flag: + // the compiler routinely computes the base in one register, copies it to a + // second, and then reuses the first — writing half the record through each. + // Without this the second half is attributed to no record and the binding is + // lost. `CBaseEntity::AddNewModifier` is the case that exposed it. + recid[d as usize] = match insn.op1_kind() { + OpKind::Register => { + gpr(insn.op1_register()).and_then(|s| recid[s as usize]) + } + _ => None, + }; + scaled[d as usize] = false; + val[d as usize] = match insn.op1_kind() { + OpKind::Register => { + gpr(insn.op1_register()).map_or(V::Unknown, |s| val[s as usize]) + } + OpKind::Immediate8 + | OpKind::Immediate16 + | OpKind::Immediate32 + | OpKind::Immediate32to64 + | OpKind::Immediate8to64 => V::Const(insn.immediate64()), + _ => V::Unknown, + }; + } + } + + _ => { + // Any other write invalidates the destination, so a stale constant cannot be + // attributed to a record it never reached. + if let Some(d) = gpr(insn.op0_register()) { + val[d as usize] = V::Unknown; + scaled[d as usize] = false; + recid[d as usize] = None; + } + if let Some(x) = xmm(insn.op0_register()) { + xr[x as usize] = (V::Unknown, V::Unknown); + } + } + } + } + + // Group the collected stores by the record they were written to, then keep the groups that + // present the full binding shape. + // BTreeMap, and it is not a style choice: the emit order below decides which row survives the + // `(name, cpp_name)` dedup at the end, so a HashMap made that a hash-order coin flip in a + // byte-reproducible artifact. Record ids are minted in ascending address order by the `Add` arm, + // so ordering by id is the natural reading order and changes nothing outside a tie. + let mut groups: BTreeMap> = BTreeMap::new(); + for ((rec, d), v) in stores { + groups.entry(rec).or_default().insert(d, v); + } + for g in groups.values() { + // The initialiser writes the name pair at the record's own `+0`, so a group without both is + // not a binding — a partial match on some other structure, or a record whose construction + // the tracker only saw half of. + let (Some(&n), Some(&c)) = (g.get(&F_NAME), g.get(&F_CPP)) else { + continue; + }; + let (Some(name), Some(cpp_name)) = (ident(img, n), ident(img, c)) else { + continue; + }; + let ret_raw = g.get(&F_RET).copied().unwrap_or(u64::MAX); + if ret_raw > u16::MAX as u64 { + continue; + } + let ret_raw = ret_raw as u16; + // The implementation is recorded when present but NOT required. It is written at the top of + // the initialiser's next loop iteration, so whether it lands in this record's group depends + // on which register the compiler happened to reuse — a binding whose fields are otherwise + // complete must not be dropped over a scheduling accident. (The shared marshalling thunk at + // `+0x38` is read past for the same reason and no longer recorded: nothing consumed it, and + // the record-layout table in this module's header is where that offset is documented.) + // + // An earlier revision did require both, on the reasoning that `libserver` holds another table + // of similar stride (the network field serialisers) whose records carry no code pointer. That + // was treating a symptom: the record-base anchor above rejects those structurally, because + // they are not built by `idx*5 << 4 + [class+0x28]`. Requiring the pair on top of that cost + // real bindings — `CBaseEntity::EmitSound` among them — for no additional safety. + out.push(VScriptFunc { + name, + cpp_name, + description: g.get(&F_DESC).and_then(|&v| text(img, v, MAX_DESC)), + ret_raw, + ret: ret_type_name(ret_raw), + imp: g.get(&F_IMPL).and_then(|&v| decode_pmf(img, v)), + }); + } + } + + out.sort_by(|a, b| (&a.name, &a.cpp_name).cmp(&(&b.name, &b.cpp_name))); + out.dedup_by(|a, b| a.name == b.name && a.cpp_name == b.cpp_name); + out +} diff --git a/src/xref.rs b/src/xref.rs index 03ec418..66a6983 100644 --- a/src/xref.rs +++ b/src/xref.rs @@ -13,56 +13,45 @@ //! the next avoids the misalignment a blind section-wide linear sweep suffers on data/padding. use crate::elf::CodeImage; -use iced_x86::{Decoder, DecoderOptions, FlowControl, Instruction, OpKind}; +use iced_x86::{Decoder, DecoderOptions, Instruction, OpKind}; use std::collections::HashMap; pub struct XrefIndex { entries: Vec, // sorted, de-duped function entry addresses refs: HashMap>, // referenced VA -> source instruction VAs - call_targets: Vec, // sorted, de-duped near-call targets } impl XrefIndex { pub fn build(img: &CodeImage) -> Self { // Reliable gameplay entries (vtable slots + fn-pointers via relocations, plus call targets), // then add the eh_frame starts (the runtime tail). Union = coverage of the whole binary. - let mut entries = crate::locate::candidate_entries(img); - entries.extend(img.eh_frame_functions().into_iter().map(|(s, _)| s)); - entries.sort_unstable(); - entries.dedup(); + let entries = crate::locate::function_entries(img); // Disassemble each function's [start, next) range independently across threads — this is the // single biggest decode in the tool and the ranges vary wildly in size, so the atomic work - // scheduler load-balances them. Each task returns its (ref-pair, call-target) deltas; merging - // them in entry order (parallel_map preserves input order) reproduces the serial build - // byte-for-byte: refs[t] receives its srcs in the same (ascending entry, then instruction) - // order and call_targets is sorted afterwards. - type EntryData = (Vec<(u64, u64)>, Vec); + // scheduler load-balances them. Each task returns its ref-pair deltas; merging them in entry + // order (parallel_map preserves input order) reproduces the serial build byte-for-byte, because + // refs[t] receives its srcs in the same (ascending entry, then instruction) order. let idxs: Vec = (0..entries.len()).collect(); - let per_entry: Vec = + let per_entry: Vec> = crate::par::parallel_map(&idxs, crate::par::default_threads(None), |&i| { let start = entries[i]; let end = entries.get(i + 1).copied().unwrap_or(u64::MAX); let Some(code) = img.code_range(start, end) else { - return (Vec::new(), Vec::new()); + return Vec::new(); }; let mut ref_pairs: Vec<(u64, u64)> = Vec::new(); - let mut call_targets: Vec = Vec::new(); let mut insn = Instruction::default(); let mut dec = Decoder::with_ip(64, code, start, DecoderOptions::NONE); while dec.can_decode() { dec.decode_out(&mut insn); let src = insn.ip(); - // Near call/jmp: the target is code; call targets double as function entries. + // Near call/jmp: the target is code. if matches!( insn.op0_kind(), OpKind::NearBranch16 | OpKind::NearBranch32 | OpKind::NearBranch64 ) { - let t = insn.near_branch_target(); - ref_pairs.push((t, src)); - if insn.flow_control() == FlowControl::Call { - call_targets.push(t); - } + ref_pairs.push((insn.near_branch_target(), src)); } // RIP-relative memory operand: a reference to a string / global / code pointer. if insn.is_ip_rel_memory_operand() { @@ -70,24 +59,16 @@ impl XrefIndex { ref_pairs.push((t, src)); } } - (ref_pairs, call_targets) + ref_pairs }); let mut refs: HashMap> = HashMap::new(); - let mut call_targets = Vec::new(); - for (ref_pairs, cts) in per_entry { + for ref_pairs in per_entry { for (t, src) in ref_pairs { refs.entry(t).or_default().push(src); } - call_targets.extend(cts); - } - call_targets.sort_unstable(); - call_targets.dedup(); - Self { - entries, - refs, - call_targets, } + Self { entries, refs } } /// The entry (function start) that contains `va`: the nearest entry at or below `va`. @@ -114,8 +95,11 @@ impl XrefIndex { fs } - pub fn call_targets(&self) -> &[u64] { - &self.call_targets + /// The function entries this index was built over, ascending — the union `locate::function_entries` + /// computes. Exposed because it is the domain of `containing_func`: a caller enumerating functions + /// should read it here rather than recompute the union and risk a different one. + pub fn entries(&self) -> &[u64] { + &self.entries } }