24600145

6:13pm (EST) · updated 2026-08-06 22:20 UTC

Base globals

inline static constexpr uintptr_t il2cpphandle = 0x10CB56C0;

struct rust_globals {
    uintptr_t il2cpphandle             = 0x10CB56C0; // GameAssembly.dll RVA
    uintptr_t base_networkable_static  = 0x107CBBB8;  // static-fields base
    uintptr_t main_camera_c            = 0x107E04B0;  // static-fields base
};

base_networkable

struct base_networkable {
    uintptr_t base_networkable     = 0x107CBBB8;
    uintptr_t static_fields        =       0xB8;
    uintptr_t wrapper_class_ptr    =        0x8;
    uintptr_t parent_static_fields =       0x10;
    uintptr_t entities             =       0x10;
    uintptr_t hv_offset            =       0x18;
};

camera

struct camera {
    uintptr_t main_camera_c = 0x107E04B0;
    uintptr_t camera_static =       0xB8;
    uintptr_t camera_object =       0x10;
    uintptr_t entity        =       0x10;
    uintptr_t view_matrix   =      0x2FC; //Unity native camera state
    uintptr_t position      =      0x444; //Unity native camera state
    uintptr_t field_of_view =      0x170; //Unity native camera state
    uintptr_t culling_mask  =      0x3E8; //Unity native camera state
};

base_entity

struct base_entity {
    uintptr_t bounds = 0x18C;
    uintptr_t model  = 0x1B8;
    uintptr_t flags  = 0x1C0;
    // unresolved (omitted): triggers
};

base_combat_entity

struct base_combat_entity {
    uintptr_t lifestate             = 0x2A8;
    uintptr_t mark_attacker_hostile = 0x2AE;
    uintptr_t model                 = 0x1B8;
    uintptr_t _health               = 0x2B4;
    uintptr_t _maxHealth            = 0x2B8;
    uintptr_t skeleton_properties   = 0x230;
};

base_player

struct base_player {
    uintptr_t display_name     = 0x2E8;
    uintptr_t player_rigidbody = 0x340;
    uintptr_t player_input     = 0x490;
    uintptr_t player_inventory = 0x5D0;
    uintptr_t base_movement    = 0x3A0;
    uintptr_t current_team     = 0x550;
    uintptr_t cl_active_item   = 0x580;
    uintptr_t player_eyes      = 0x330;
    uintptr_t player_flags     = 0x6D0;
    uintptr_t held_entity      = 0x350;
    uintptr_t player_model     = 0x508;
    // unresolved (omitted): model_state, mounted
};

player_eyes

struct player_eyes {
    uintptr_t viewOffset   = 0x60;
    uintptr_t bodyRotation = 0x50;
    // unresolved (omitted): worldPosition
};

player_input

struct player_input {
    uintptr_t rotation   = 0x34;
    uintptr_t bodyAngles = 0x44;
};

player_walk_movement

struct player_walk_movement {
    uintptr_t GroundAngle       =  0x70; //hardcoded — reverify
    uintptr_t GroundAngleNew    =  0x78; //hardcoded — reverify
    uintptr_t GroundTime        =  0x80; //hardcoded — reverify
    uintptr_t JumpTime          =  0x88; //hardcoded — reverify
    uintptr_t LandTime          =  0x90; //hardcoded — reverify
    uintptr_t GravityMultiplier =  0x98; //hardcoded — reverify
    uintptr_t TargetMovement    = 0x128; //hardcoded — reverify
};

base_movement (obfuscated)

struct base_movement {
    uintptr_t owner     = 0x30; // obfuscated — BasePlayer backref
    uintptr_t vector3_0 = 0x38; // obfuscated — likely targetMovement / groundNormal
    uintptr_t vector3_1 = 0x44; // obfuscated — likely the second movement vector
    uintptr_t single_0  = 0x50; // obfuscated
    uintptr_t single_1  = 0x54; // obfuscated — first Single after the Vector3 pair
    uintptr_t single_2  = 0x58; // obfuscated
    uintptr_t single_3  = 0x5C; // obfuscated
    uintptr_t single_4  = 0x60; // obfuscated
    // unresolved (omitted): bool_0, single_5
};

player_model

struct player_model {
    uintptr_t jawBone          =  0xE8;
    uintptr_t neckBone         =  0xF0;
    uintptr_t headBone         =  0xF8;
    uintptr_t skinnedMultiMesh = 0x3C8;
    uintptr_t position         = 0x31C; //heuristic — last-pair Vector3
    uintptr_t velocity         = 0x35C; //heuristic — last-pair Vector3
    uintptr_t heldEntity       = 0x3C0;
    uintptr_t isNpc            = 0x374;
};

model

struct model {
    uintptr_t collision      = 0x20;
    uintptr_t rootBone       = 0x28;
    uintptr_t headBone       = 0x30;
    uintptr_t eyeBone        = 0x38;
    uintptr_t animator       = 0x40;
    uintptr_t skeleton       = 0x48;
    uintptr_t boneTransforms = 0x50;
    uintptr_t boneNames      = 0x58;
};

skinned_multi_mesh

struct skinned_multi_mesh {
    uintptr_t renderers = 0x40;
    // unresolved (omitted): model
};

local_player_static

struct local_player_static {
    uintptr_t type_info     = 0x107E04B0;
    uintptr_t static_fields =       0xB8;
    uintptr_t entity        =       0xB0;
};

convar_graphics

struct convar_graphics {
    uintptr_t static_fields = 0xB8;
    // unresolved (omitted): type_info, fov
};

player_inventory + item_container

struct player_inventory {
    uintptr_t wear = 0x58;
    uintptr_t main = 0x60;
    uintptr_t loot = 0x48;
    uintptr_t belt = 0x78;
};

struct item_container {
    uintptr_t item_list = 0x18;
    uintptr_t flags     = 0x14;
};

struct item {
    uintptr_t definition = 0xD8;
    uintptr_t uid        = 0x18;
    // unresolved (omitted): amount, held_entity
};

struct item_id {
    uintptr_t value = 0x10;
};

struct item_definition {
    uintptr_t itemid      = 0x20;
    uintptr_t shortname   = 0x28;
    uintptr_t displayName = 0x40;
    uintptr_t category    = 0x58;
    uintptr_t stackable   = 0x78;
    uintptr_t iconSprite  = 0x50;
    uintptr_t rarity      = 0x94;
    uintptr_t condition   = 0xB8;
};

struct item_icon {
    uintptr_t static_fields = 0xB8;
    uintptr_t background    = 0xE8;
    uintptr_t iconImage     = 0xA8;
    // unresolved (omitted): type_info, itemRef
};

struct ammo_types {
    uintptr_t value = 0x10;
};

held_entity + world_item

struct held_entity {
    uintptr_t viewModel          = 0x250;
    uintptr_t worldModelAnimator = 0x218;
    uintptr_t handBone           = 0x260;
    uintptr_t holdInfo           = 0x270;
    uintptr_t isBuildingTool     = 0x28C;
    uintptr_t forcedOwner        = 0x290;
    uintptr_t hostileScore       = 0x2AC;
    uintptr_t item_owner         = 0x240;
    uintptr_t ownerItemUID       = 0x2E0;
};

struct world_item {
    uintptr_t allowPickup = 0x200;
    uintptr_t item        = 0x208;
};

base_projectile / recoil / magazine / projectile

struct base_projectile {
    uintptr_t projectileVelocityScale    = 0x38C;
    uintptr_t automatic                  = 0x390;
    uintptr_t reloadTime                 = 0x3D0;
    uintptr_t canUnloadAmmo              = 0x3D4;
    uintptr_t primaryMagazine            = 0x3D8;
    uintptr_t fractionalReload           = 0x3E0;
    uintptr_t aimSway                    = 0x3F8;
    uintptr_t aimSwaySpeed               = 0x3FC;
    uintptr_t recoil                     = 0x400;
    uintptr_t aimCone                    = 0x410;
    uintptr_t hipAimCone                 = 0x414;
    uintptr_t aimconePenaltyMax          = 0x41C;
    uintptr_t stancePenalty              = 0x428;
    uintptr_t hasADS                     = 0x42C;
    uintptr_t isBurstWeapon              = 0x437;
    uintptr_t canChangeFireModes         = 0x438;
    uintptr_t internalBurstFireRateScale = 0x440;
    uintptr_t sightAimConeScale          = 0x444;
    uintptr_t aimconePenaltyPerShot      = 0x418;
    uintptr_t internalBurstAimConeScale  = 0x444; //alias of sightAimConeScale
    // unresolved (omitted): aimconePenalty, aimconePenaltyPerShot_legacy
};

struct recoil_properties {
    uintptr_t recoilYawMin             = 0x18;
    uintptr_t recoilYawMax             = 0x1C;
    uintptr_t recoilPitchMin           = 0x20;
    uintptr_t recoilPitchMax           = 0x24;
    uintptr_t timeToTakeMin            = 0x28;
    uintptr_t timeToTakeMax            = 0x2C;
    uintptr_t ADSScale                 = 0x30;
    uintptr_t movementPenalty          = 0x34;
    uintptr_t clampPitch               = 0x38;
    uintptr_t pitchCurve               = 0x40;
    uintptr_t yawCurve                 = 0x48;
    uintptr_t useCurves                = 0x50;
    uintptr_t shotsUntilMax            = 0x54;
    uintptr_t maxRecoilRadius          = 0x58;
    uintptr_t overrideAimconeWithCurve = 0x5C;
    uintptr_t aimconeCurveScale        = 0x60;
    uintptr_t aimconeCurve             = 0x68;
    uintptr_t aimconeProbabilityCurve  = 0x70;
    uintptr_t newRecoilOverride        = 0x80;
};

struct magazine {
    uintptr_t capacity   = 0x18;
    uintptr_t contents   = 0x1C;
    uintptr_t ammoType   = 0x20;
    uintptr_t definition = 0x10;
};

struct projectile {
    uintptr_t initialVelocity          =  0x28;
    uintptr_t drag                     =  0x34;
    uintptr_t gravityModifier          =  0x38;
    uintptr_t thickness                =  0x3C;
    uintptr_t initialDistance          =  0x44;
    uintptr_t initialOrientation       =  0x48;
    uintptr_t changeInitialOrientation =  0x40;
    uintptr_t remainInWorld            =  0x54;
    uintptr_t stickProbability         =  0x58;
    uintptr_t breakProbability         =  0x5C;
    uintptr_t conditionLoss            =  0x60;
    uintptr_t ricochetChance           =  0x64;
    uintptr_t penetrationPower         =  0x68;
    uintptr_t penetratesVehicles       =  0x6D;
    uintptr_t waterIntegrityLoss       =  0x70;
    uintptr_t damageProperties         =  0x78;
    uintptr_t damageDistances          =  0x80;
    uintptr_t damageMultipliers        =  0x88;
    uintptr_t damageTypes              =  0x90;
    uintptr_t tumbleSpeed              =  0xCC;
    uintptr_t swimScale                =  0xF0;
    uintptr_t swimSpeed                =  0xFC;
    uintptr_t owner                    = 0x1E8; // obfuscated — BasePlayer backref, matched by type
    // unresolved (omitted): currentPosition, currentVelocity
};

Weapon subclasses

struct attack_entity {
    uintptr_t deployDelay             = 0x2E8;
    uintptr_t repeatDelay             = 0x2EC;
    uintptr_t animationDelay          = 0x2F0;
    uintptr_t effectiveRange          = 0x2F4;
    uintptr_t npcDamageScale          = 0x2F8;
    uintptr_t attackLengthMin         = 0x2FC;
    uintptr_t attackLengthMax         = 0x300;
    uintptr_t attackSpacing           = 0x304;
    uintptr_t aiAimSwayOffset         = 0x308;
    uintptr_t aiAimCone               = 0x30C;
    uintptr_t aiOnlyInRange           = 0x310;
    uintptr_t CloseRangeAddition      = 0x314;
    uintptr_t MediumRangeAddition     = 0x318;
    uintptr_t LongRangeAddition       = 0x31C;
    uintptr_t CanUseAtMediumRange     = 0x320;
    uintptr_t CanUseAtLongRange       = 0x321;
    uintptr_t recoilCompDelayOverride = 0x338;
    uintptr_t wantsRecoilComp         = 0x33C;
    uintptr_t noHeadshots             = 0x33E;
};

struct flint_strike {
    uintptr_t successFraction = 0x4A8;
    uintptr_t strikeRecoil    = 0x4B0;
    uintptr_t sparkFrame      = 0x4B8;
};

struct base_melee {
    uintptr_t canThrowAsProjectile      = 0x380;
    uintptr_t canThrowAsEntity          = 0x381;
    uintptr_t onlyThrowAsProjectile     = 0x384;
    uintptr_t ThrowFullStack            = 0x385;
    uintptr_t damageProperties          = 0x388;
    uintptr_t damageTypes               = 0x390;
    uintptr_t deployableDamageOverrides = 0x398;
    uintptr_t maxDistance               = 0x3A0;
    uintptr_t attackRadius              = 0x3A4;
    uintptr_t isAutomatic               = 0x3A8;
    uintptr_t blockSprintOnAttack       = 0x3A9;
    uintptr_t canUntieCrates            = 0x3AA;
    uintptr_t strikeFX                  = 0x3B8;
    uintptr_t useStandardHitEffects     = 0x3C0;
    uintptr_t aiStrikeDelay             = 0x3C4;
    uintptr_t swingEffect               = 0x3C8;
    uintptr_t materialStrikeFX          = 0x3D0;
    uintptr_t heartStress               = 0x3D8;
    uintptr_t gathering                 = 0x3E0;
};

struct base_launcher {
    uintptr_t initialSpeedMultiplier = 0x4B8;
};

struct item_mod_projectile {
    uintptr_t projectileObject         = 0x20;
    uintptr_t numProjectiles           = 0x38;
    uintptr_t projectileSpread         = 0x3C;
    uintptr_t projectileVelocity       = 0x40;
    uintptr_t projectileVelocitySpread = 0x44;
    uintptr_t ammoType                 = 0x30;
    uintptr_t ammoSubType              = 0x34;
    uintptr_t useCurve                 = 0x48;
    uintptr_t spreadScalar             = 0x50;
    uintptr_t attackEffectOverride     = 0x58;
    uintptr_t category                 = 0x68;
};

struct item_mod_container {
    uintptr_t capacity            = 0x30;
    uintptr_t maxStackSize        = 0x34;
    uintptr_t containerVolume     = 0x38;
    uintptr_t canLootInWorld      = 0x3C;
    uintptr_t maxWeight           = 0x44;
    uintptr_t containerFlags      = 0x4C;
    uintptr_t onlyAllowedContents = 0x50;
    uintptr_t onlyAllowedItemType = 0x58;
    uintptr_t availableSlots      = 0x60;
    uintptr_t validItemWhitelist  = 0x68;
};

Storage / loot / gather

struct storage_container {
    uintptr_t inventorySlots              = 0x320;
    uintptr_t panelName                   = 0x330;
    uintptr_t panelTitle                  = 0x338;
    uintptr_t isLootable                  = 0x32D;
    uintptr_t isLockable                  = 0x32E;
    uintptr_t isMonitorable               = 0x32F;
    uintptr_t dropsLoot                   = 0x324;
    uintptr_t dropLootDestroyPercent      = 0x328;
    uintptr_t allowedContents             = 0x340;
    uintptr_t allowedItem                 = 0x348;
    uintptr_t maxStackSize                = 0x368;
    uintptr_t needsBuildingPrivilegeToUse = 0x36C;
    uintptr_t onlyAcceptCategory          = 0x398;
    uintptr_t onlyOneUser                 = 0x39C;
    uintptr_t dropPosition                = 0x380;
    uintptr_t dropVelocity                = 0x38C;
    // unresolved (omitted): inventory
};

struct loot_container {
    uintptr_t destroyOnEmpty               = 0x3A8;
    uintptr_t lootDefinition               = 0x3B0;
    uintptr_t maxDefinitionsToSpawn        = 0x3B8;
    uintptr_t minSecondsBetweenRefresh     = 0x3BC;
    uintptr_t maxSecondsBetweenRefresh     = 0x3C0;
    uintptr_t initialLootSpawn             = 0x3C4;
    uintptr_t xpLootedScale                = 0x3C8;
    uintptr_t scrapAmount                  = 0x3D4;
    uintptr_t LootSpawnSlots               = 0x3E0;
    uintptr_t SpawnType                    = 0x3E8;
    uintptr_t clanScoreEventForFirstLooter = 0x3EC;
    // unresolved (omitted): inventory
};

struct ore_resource_entity {
    uintptr_t bonusPrefab        = 0x258;
    uintptr_t finishEffect       = 0x260;
    uintptr_t bonusFailEffect    = 0x268;
    uintptr_t useHotspotMinigame = 0x270;
    uintptr_t bonusSound         = 0x278;
    uintptr_t heightOffset       = 0x280;
};

struct resource_entity {
    uintptr_t startHealth         = 0x200;
    uintptr_t baseProtection      = 0x208;
    uintptr_t skipDecorComponents = 0x214;
};

struct collectible_entity {
    uintptr_t itemName                     = 0x200;
    uintptr_t itemList                     = 0x208;
    uintptr_t pickupEffect                 = 0x210;
    uintptr_t xpScale                      = 0x218;
    uintptr_t suppressGatherRateMultiplier = 0x21C;
};

struct growable_entity {
    uintptr_t Properties    = 0x348;
    uintptr_t SourceItemDef = 0x350;
    uintptr_t state         = 0x358; // obfuscated name — matched by PlantProperties.State type
    uintptr_t plantSkin     = 0x320; // obfuscated name — matched by PlantSkin type
    // unresolved (omitted): genes
};

Traps / turrets / explosives

struct auto_turret {
    uintptr_t authorizedPlayers = 0x3A8; // obfuscated name — matched by HashSet<System.UInt64> type
    uintptr_t target            = 0x4A0;
    uintptr_t sightRange        = 0x4D8;
    uintptr_t aimCone           = 0x538;
    uintptr_t targetTrigger     = 0x480;
    uintptr_t gun_fire_effect   = 0x3F0;
    uintptr_t bulletEffect      = 0x3F8;
    uintptr_t bulletSpeed       = 0x400;
    uintptr_t laserBeam         = 0x420;
    uintptr_t playAmbientSounds = 0x410;
    // unresolved (omitted): booting, peacekeeper
};

struct gun_trap {
    uintptr_t gun_fire_effect = 0x3A8;
    uintptr_t bulletEffect    = 0x3B0;
    uintptr_t triggeredEffect = 0x3B8;
    uintptr_t muzzlePos       = 0x3C0;
    uintptr_t eyeTransform    = 0x3C8;
    uintptr_t numPellets      = 0x3D0;
    uintptr_t aimCone         = 0x3D4;
    uintptr_t sensorRadius    = 0x3D8;
    uintptr_t ammoType        = 0x3E0;
    uintptr_t trigger         = 0x3E8;
    // unresolved (omitted): inventory
};

struct flame_turret {
    uintptr_t upper             = 0x3A8;
    uintptr_t arc               = 0x3B0;
    uintptr_t triggeredDuration = 0x3B4;
    uintptr_t flameRange        = 0x3B8;
    uintptr_t flameRadius       = 0x3BC;
    uintptr_t fuelPerSec        = 0x3C0;
    uintptr_t eyeTransform      = 0x3C8;
    uintptr_t damagePerSec      = 0x3D0;
    uintptr_t trigger           = 0x3F0;
};

struct timed_explosive {
    uintptr_t timerAmountMin         = 0x200;
    uintptr_t timerAmountMax         = 0x204;
    uintptr_t minExplosionRadius     = 0x208;
    uintptr_t explosionRadius        = 0x20C;
    uintptr_t explodeOnContact       = 0x210;
    uintptr_t canStick               = 0x211;
    uintptr_t onlyDamageParent       = 0x213;
    uintptr_t damageTypes            = 0x278;
    uintptr_t explosionEffectOffset  = 0x224;
    uintptr_t explosionMatchesNormal = 0x230;
};

Building / locks / stability / decay

struct building_block {
    uintptr_t grade          = 0x350;
    uintptr_t gradeSecondary = 0x354; // obfuscated — second BuildingGrade.Enum slot
    uintptr_t construction   = 0x318; // obfuscated name — matched by exact Construction type
    uintptr_t cachedMesh     = 0x3B8; // obfuscated name — matched by MeshCollider type
    uintptr_t meshRenderer   = 0x360; // obfuscated name — matched by MeshRenderer type
    uintptr_t skin           = 0x370; // obfuscated name — matched by ConstructionSkin type
    uintptr_t CullBushes     = 0x378;
};

struct door {
    uintptr_t knockEffect    = 0x358;
    uintptr_t canTakeLock    = 0x360;
    uintptr_t hasHatch       = 0x361;
    uintptr_t canTakeCloser  = 0x362;
    uintptr_t canTakeKnocker = 0x363;
    uintptr_t canNpcOpen     = 0x364;
    uintptr_t canHandOpen    = 0x365;
    uintptr_t isSecurityDoor = 0x366;
    uintptr_t canReverseOpen = 0x367;
};

struct code_lock {
    uintptr_t keyEnterDialog    = 0x240;
    uintptr_t effectUnlocked    = 0x248;
    uintptr_t effectLocked      = 0x250;
    uintptr_t effectDenied      = 0x258;
    uintptr_t effectCodeChanged = 0x260;
    uintptr_t effectShock       = 0x268;
    uintptr_t keyCodeEntry      = 0x238; // obfuscated name — matched by KeyCodeEntry type
    uintptr_t hasCode           = 0x270; // obfuscated — first System.Boolean on CodeLock, VERIFY before use
    // unresolved (omitted): code
};

struct stability_entity {
    uintptr_t grounded        = 0x308;
    uintptr_t stability       = 0x30C; // obfuscated — only Single declared on StabilityEntity
    uintptr_t cachedStability = 0x310; // obfuscated — first Int32 declared on StabilityEntity
};

struct decay_entity {
    uintptr_t canBeDemolished      = 0x2D0;
    uintptr_t debrisPrefab         = 0x2D8;
    uintptr_t debrisRotationOffset = 0x2E0;
    uintptr_t DebrisPositions      = 0x2F0;
    uintptr_t timePlaced           = 0x2FC;
    uintptr_t upkeep               = 0x300; // obfuscated name — matched by Upkeep type (was 'decay'/'buildingPrivilege')
};

Corpses / sleeping bag

struct base_corpse {
    uintptr_t prefabRagdoll          = 0x2D0;
    uintptr_t parentEnt              = 0x2D8;
    uintptr_t blockDamageIfNotGather = 0x2F0;
    uintptr_t ragdoll                = 0x2F8; // obfuscated name — matched by Ragdoll type
    uintptr_t resourceDispenser      = 0x300; // obfuscated name — matched by ResourceDispenser type
};

struct lootable_corpse {
    uintptr_t playerName    = 0x308; // obfuscated — first System.String on LootableCorpse
    uintptr_t playerSteamID = 0x318; // obfuscated — first System.UInt64 on LootableCorpse
    // unresolved (omitted): containers
};

struct player_corpse {
    uintptr_t playerName    = 0x308; // obfuscated — first System.String on PlayerCorpse
    uintptr_t playerSteamID = 0x318; // obfuscated — first System.UInt64 on PlayerCorpse
    uintptr_t containers    = 0x350;
};

struct sleeping_bag {
    uintptr_t niceName                 = 0x368;
    uintptr_t renameDialog             = 0x348;
    uintptr_t assignDialog             = 0x350;
    uintptr_t secondsBetweenReuses     = 0x358;
    uintptr_t perPlayerRespawnCooldown = 0x35C;
    uintptr_t spawnOffset              = 0x370;
    uintptr_t respawnCooldowns         = 0x310; // obfuscated name — matched by Dictionary<UInt64,Single> type
    uintptr_t deployerUserID           = 0x3C0; // obfuscated — first System.UInt64 on SleepingBag
};

Vehicles

struct base_vehicle {
    uintptr_t mountPoints             = 0x3F0;
    uintptr_t shouldShowHudHealth     = 0x3B2;
    uintptr_t ignoreDamageFromOutside = 0x3E4;
    // unresolved (omitted): checkVehicleIsOnGround
};

struct patrol_helicopter {
    uintptr_t weakspots         = 0x2D0;
    uintptr_t rotorPivot        = 0x2D8;
    uintptr_t mainRotor         = 0x2E0;
    uintptr_t tailRotor         = 0x2F8;
    uintptr_t rocket_tube_left  = 0x310;
    uintptr_t rocket_tube_right = 0x318;
    uintptr_t left_gun_yaw      = 0x320;
    uintptr_t left_gun_pitch    = 0x328;
    uintptr_t spotlightTarget   = 0x408;
    uintptr_t myAI              = 0x438; // obfuscated name — matched by PatrolHelicopterAI type
};

struct bradley_apc {
    uintptr_t viewDistance          = 0x3C4;
    uintptr_t searchRange           = 0x3C8;
    uintptr_t engineSound           = 0x2D0;
    uintptr_t chasisLurchAngleDelta = 0x318;
    uintptr_t chasisLurchSpeedDelta = 0x31C;
    // unresolved (omitted): targetTrigger
};

Decryption routines

uintptr_t decryption::base_networkable_0(uint64_t a1) {
    std::uintptr_t rax = driver.read<std::uintptr_t>(a1 + 0x18);
    std::uint32_t* rdx = (std::uint32_t*)&rax;
    std::uint32_t r8d = 0x2;
    std::uint32_t eax, ecx;
    do {
        ecx = *(std::uint32_t*)(rdx);
        eax = *(std::uint32_t*)(rdx);
        rdx = (std::uint32_t*)((std::uint8_t*)rdx + 0x4);
        ecx = ecx - 0x2DC6D216;
        ecx = ecx ^ 0xF48C99C4;
        eax = ecx;
        ecx = ecx << 0xC;
        eax = eax >> 0x14;
        ecx = ecx | eax;
        ecx = ecx + 0x3B04A1BF;
        *((std::uint32_t*)rdx - 1) = ecx;
        --r8d;
    } while (r8d);
    return il2cpp_get_handle(rax);
}

uintptr_t decryption::base_networkable_1(uint64_t a1) {
    std::uintptr_t rax = driver.read<std::uintptr_t>(a1 + 0x18);
    std::uint32_t* rdx = (std::uint32_t*)&rax;
    std::uint32_t r8d = 0x2;
    std::uint32_t eax, ecx;
    do {
        ecx = *(std::uint32_t*)(rdx);
        eax = *(std::uint32_t*)(rdx);
        rdx = (std::uint32_t*)((std::uint8_t*)rdx + 0x4);
        ecx = ecx ^ 0xFEFC7ADC;
        eax = ecx;
        ecx = ecx << 0x7;
        eax = eax >> 0x19;
        ecx = ecx | eax;
        ecx = ecx + 0xC7C81A94;
        eax = ecx;
        ecx = ecx << 0x12;
        eax = eax >> 0xE;
        ecx = ecx | eax;
        *((std::uint32_t*)rdx - 1) = ecx;
        --r8d;
    } while (r8d);
    return il2cpp_get_handle(rax);
}