Skid Lounge

Pointer to UEngine. Root of the engine subsystem — you can reach GameViewport and the world through it.

Pointer to the active UWorld. Entry point for every actor / level / pawn walk. Decrypt with the UWorld decryption routine, then walk OwningGameInstance, GameState, PersistentLevel and Levels from it.

Pointer to FNamePool. Used to resolve FName indexes into readable strings. Required for any SDK dumper.

Pointer to the global UObject array. Iterate this to enumerate every live UObject in the process.

UObject::ProcessEvent vtable index / virtual call. Hooked for caller-side function dispatch.

UGameViewportClient — holds the world and the local player list for rendering.

TArray<ULocalPlayer*>. Index 0 is the local client.

Owns input + AcknowledgedPawn + PlayerCameraManager.

The pawn the server has acked for this controller — your local pawn.

Holds CameraCachePrivate / POV. Read this for true camera location+rotation.

Fortnite-specific — the pawn currently targeted by the local player (used for aim logic).

Replicated per-player info (team, name, etc.).

TArray<APlayerState*>. Iterate this for every player in the match — the ESP loop.

ULevel containing static actors. Iterate Actors to find world geometry / loot / vehicles.

USceneComponent root. Read RelativeLocation/Rotation off it for actor world transform.

USkeletalMeshComponent. Required for bone-based ESP.

Cached bone transforms array — where you read each bone's position for skeleton ESP.

FTransform matrix converting component-local coords to world space. Multiply bone positions by this.

FVector world position when component has no parent.

FRotator orientation. Drives world→screen and aim math.

Timestamp of the last frame this actor was rendered. Compare against world time for visibility checks.

Pointer to the currently equipped weapon — used to read ammo, spread and recoil data.

Base of the GameAssembly module handle. Every Unity class lookup for Rust starts from here.

BasePlayer type. Holds display_name, inventory, model, eyes, input and movement — the root of every player.

BaseCombatEntity. Contains _health / _maxHealth / lifestate — how you know if someone is alive.

Skinned mesh + bone transforms (headBone, jawBone, neckBone). Required for bone ESP in Rust.

Eyes component. bodyRotation and viewOffset give you the true view angles + camera position.

Splits into wear, main and belt containers. Iterate item_list on each to enumerate items.

Weapon class. Holds recoil, aimCone, spread and mag data — used to build no-recoil / no-spread.

Per-weapon recoil pattern (min/max pitch, yaw, curves). Zero these for recoil control.

MainCamera static — view_matrix and position live here. Feed view_matrix into world→screen.

CClientState — network state, level name, signon state, local player handle. The client-side hub.

Entity list base. Iterate 0..MAX_EDICTS to enumerate every C_BaseEntity in the world.

Pointer to the local C_Player. Everything you aim from is derived from this entity.

4x4 world→screen projection matrix. Multiply bone world positions by this for ESP.

Local view angles (pitch/yaw). Writing here rotates the camera — the basis of aimbots.

CGlobalVars — server tick, curtime, frametime, framecount. Needed for prediction math.

Glow controller table. Writing indices here toggles the built-in glow ESP on any entity.

Current HP. Read as an int; 0 or dead lifestate means skip.

Team ID. Compare against local player's team to skip friendlies.

Absolute world position (Vector3). Root position for distance + world→screen.

0 = alive, non-zero = dead/knocked. Filter your ESP loop with this.

Apex-specific knocked state. Non-zero = downed, still targetable but not fully dead.

Current shield HP. Combine with m_shieldHealthMax to draw shield bars.

Inventory handle table. Resolve indices back through cl_entitylist to read carried items.

Handle to the currently equipped primary — look up via cl_entitylist to get the CWeaponX.

Rounds left in the mag. Freeze for no-reload builds.

Health pattern sigs. Scan these in the game module, then resolve the RIP-relative displacement to get the current health data offset — Siege shifts it every patch.

Offset from the entity to its health block. Recovered by scanning the P1–P4 signatures rather than hardcoded.

Pointer to the physics world. Used for bone/skeleton reads since Siege keeps bone data in the physics representation.

Quaternion rotation on a bone node. Combine with the bone position to build a world transform.

Unencrypted bone list — each node holds a position in the physics VA. Root of Siege skeleton ESP.

Player/entity list base. Iterate to enumerate every operator in the round.

Encrypted UWorld pointer. Must be passed through the Decrypt routine before it points at a real world object.

PUBG's pointer decryption function. Every encrypted global (UWorld, GNames, actor pointers) goes through this.

FName pool base. Resolves FName indexes into readable class/actor names.

How many FName entries live per chunk in the name pool. Needed to index GNames correctly.

Active ULevel — iterate its actor array for players, vehicles and loot.

UGameInstance holding LocalPlayers. Path to the local controller and pawn.

Camera POV — location, rotation and FOV for world→screen projection.

Scene root; read RelativeLocation off it for the actor's world position.

Skeletal mesh component. Required for bone positions / skeleton ESP.

CPed world pointer. Dereference to reach the local ped — the start of every FiveM read.

Viewport struct containing the view matrix used for world→screen.

Camera manager — gives real camera position and rotation, more reliable than the ped's aim data.

Float health values on a ped. Filter dead peds out of your ESP with these.

Float armor value stacked on top of health.

Pointer to the ped's weapon manager — resolves the currently equipped weapon info.

Skeleton bone matrix pointer. Multiply bone entries by the entity matrix for world bone positions.

Player-specific data (name, wanted level, ped type) attached to a ped that represents a real player.