{ "build_id": "26144732", "tag": "2026-10-25_26144732", "count": 39, "signatures": [ { "id": "client_angle_vectors", "name": "AngleVectors", "binary": "client.dll", "category": "Rendering & Math", "baseline_rva": "0x017402a0", "baseline_va": "0x1817402a0", "pattern": "48 8B C4 48 89 58 08 55 48 8D 68 B8 48 81 EC 40 01 00 00 F3 0F 10 02", "pattern_type": "prologue", "description": "Trigonometric conversion from Euler view angles (deg * 0.017453292) to Forward/Right/Up basis vectors.", "explanation": "Converts Euler viewing angles (Pitch, Yaw, Roll in degrees) into orthogonal 3D Cartesian basis unit vectors (Forward, Right, Up). In Source 2 x64, Valve uses SIMD vectorized sine and cosine computations with the conversion factor pi / 180.0f (0.017453292519943295f) for camera orientation and ray generation.", "code_snippet": "void AngleVectors(const QAngle& angles, Vector* forward, Vector* right, Vector* up) {\n constexpr float DEG2RAD = 0.017453292519943295f;\n float sp, cp, sy, cy, sr, cr;\n\n DirectX::XMScalarSinCos(&sp, &cp, angles.pitch * DEG2RAD);\n DirectX::XMScalarSinCos(&sy, &cy, angles.yaw * DEG2RAD);\n DirectX::XMScalarSinCos(&sr, &cr, angles.roll * DEG2RAD);\n\n if (forward) {\n forward->x = cp * cy;\n forward->y = cp * sy;\n forward->z = -sp;\n }\n if (right) {\n right->x = -1.0f * sr * sp * cy + -1.0f * cr * -sy;\n right->y = -1.0f * sr * sp * sy + -1.0f * cr * cy;\n right->z = -1.0f * sr * cp;\n }\n if (up) {\n up->x = cr * sp * cy + -sr * -sy;\n up->y = cr * sp * sy + -sr * cy;\n up->z = cr * cp;\n }\n}", "reconstructed_file": "game/client/viewmatrix.cpp", "current_rva": "0x01742500", "current_va": "0x181742500", "delta_bytes": 8800, "delta_str": "+0x2260", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_calc_world_bones", "name": "CalculateWorldBones", "binary": "client.dll", "category": "Animation & Hitboxes", "baseline_rva": "0x00aa0f80", "baseline_va": "0x180aa0f80", "pattern": "48 89 4C 24 08 55 53 56 57 41 54 41 55 41 56 41 57 B8 98 42 00 00", "pattern_type": "prologue", "description": "Hierarchical forward kinematics loop propagating parent bone CTransforms to child hitboxes.", "explanation": "Executes hierarchical forward kinematics bone transform propagation on CSkeletonInstance. Traverses parent bone links in topological order and concatenates local joint matrices using SIMD Rodrigues quaternion multiplication and position offset addition.", "code_snippet": "void CSkeletonInstance::CalculateWorldBones(uint32_t boneMask) {\n CModelState* modelState = &this->m_modelState;\n CTransform* boneToWorld = modelState->m_pBoneTransforms;\n const int numBones = modelState->m_nBoneCount;\n\n for (int i = 0; i < numBones; ++i) {\n int parentIdx = modelState->m_pBoneParents[i];\n if (parentIdx == -1) {\n boneToWorld[i] = modelState->m_localTransforms[i];\n } else {\n // SIMD Rodrigues Quaternion concatenation + position translation\n CTransform::ConcatenateTransforms(boneToWorld[parentIdx], modelState->m_localTransforms[i], &boneToWorld[i]);\n }\n }\n this->m_nComputedBoneMask |= boneMask;\n}", "reconstructed_file": "game/client/viewmatrix.cpp", "current_rva": "0x00aa1dc0", "current_va": "0x180aa1dc0", "delta_bytes": 3648, "delta_str": "+0xe40", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_concatenate_transforms", "name": "CTransform::ConcatenateTransforms", "binary": "client.dll", "category": "Animation & Hitboxes", "baseline_rva": "0x01748480", "baseline_va": "0x181748480", "pattern": "48 8B C4 48 83 EC 68 0F 29 70 E8 0F 28 E9 0F 28 F0", "pattern_type": "prologue", "description": "SIMD quaternion rotation and vector translation concatenation for skeletal joint hierarchies.", "explanation": "High-performance SIMD routine concatenating two 32-byte Source 2 CTransform structures (Quaternion rot [XYZW] + Vector pos [XYZ] + padding). Rotates the child translation by the parent orientation quaternion before accumulating parent translation.", "code_snippet": "void CTransform::ConcatenateTransforms(const CTransform& parent, const CTransform& child, CTransform* out) {\n // 1. Quat Multiply: Q_out = Q_parent * Q_child\n __m128 qP = _mm_loadu_ps(&parent.rot.x);\n __m128 qC = _mm_loadu_ps(&child.rot.x);\n out->rot = QuatMultiplySIMD(qP, qC);\n\n // 2. Vector Translation: Pos_out = RotateVector(Q_parent, child.pos) + parent.pos\n Vector rotatedPos = RotateVectorQuat(parent.rot, child.pos);\n out->pos = parent.pos + rotatedPos;\n}", "reconstructed_file": "game/animationsystem/two_bone_ik.cpp", "current_rva": "0x0174a6e0", "current_va": "0x18174a6e0", "delta_bytes": 8800, "delta_str": "+0x2260", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_los_smoke", "name": "LineOfSightThroughSmoke", "binary": "server.dll", "category": "Volumetric & Smoke", "baseline_rva": "0x009b7f50", "baseline_va": "0x1809b7f50", "pattern": "48 8B C4 55 53 56 41 55 41 57 48 8D 68 A8 48 81 EC 30 01 00 00", "pattern_type": "prologue", "description": "Authoritative line-of-sight test traversing active volumetric smoke grids against 0.20 density threshold.", "explanation": "Authoritative server-side line-of-sight check. Traverses all active CSmokeGrenadeProjectile voxel volumes between start and end coordinates, stepping through the 3D Morton-indexed voxel grid via 3D DDA raymarching. If integrated optical smoke density exceeds 0.20, line of sight is obstructed.", "code_snippet": "bool LineOfSightThroughSmoke(const Vector& vStart, const Vector& vEnd, float flDensityThreshold) {\n CSmokeGrenadeProjectile* pActiveSmoke = g_pSmokeListHead;\n while (pActiveSmoke) {\n if (pActiveSmoke->m_bDidSmokeDetonate && !pActiveSmoke->m_bSmokeFading) {\n float density = pActiveSmoke->RaymarchVoxelGrid(vStart, vEnd);\n if (density >= flDensityThreshold) {\n return false; // Trajectory is occluded by volumetric smoke\n }\n }\n pActiveSmoke = pActiveSmoke->m_pNext;\n }\n return true; // Clear line of sight\n}", "reconstructed_file": "game/particles/smoke_voxels.cpp", "current_rva": "0x009c5610", "current_va": "0x1809c5610", "delta_bytes": 54976, "delta_str": "+0xd6c0", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_smoke_spawn", "name": "CSmokeGrenadeProjectile::Spawn", "binary": "server.dll", "category": "Volumetric & Smoke", "baseline_rva": "0x009cb810", "baseline_va": "0x1809cb810", "pattern": "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 48 89 7C 24 20 41 56 48 83 EC 20 48 8D B9 90 0B 00 00", "pattern_type": "prologue", "description": "Initializes smoke detonation volume, allocating 3,072-byte double-buffered 512-word occupancy bitmask.", "explanation": "Initializes a detonated smoke grenade on the server. Allocates a 3,072-byte double-buffered bitmask representing a 32x32x32 voxel grid (20-unit cell spacing), initializes the particle simulation volume, and activates network delta tracking.", "code_snippet": "void CSmokeGrenadeProjectile::Spawn() {\n BaseClass::Spawn();\n this->m_bDidSmokeDetonate = true;\n this->m_flSpawnTime = gpGlobals->curtime;\n // Allocate 32x32x32 voxel bitmask buffer (512 uint64 words = 4096 bytes)\n this->m_pVoxelGrid = (VoxelGrid_t*)MemAlloc(sizeof(VoxelGrid_t));\n memset(this->m_pVoxelGrid->occupancy, 0, sizeof(this->m_pVoxelGrid->occupancy));\n this->ExpandInitialSphere(this->GetAbsOrigin(), 144.0f /* radius */);\n}", "reconstructed_file": "game/particles/smoke_voxels.cpp", "current_rva": "0x009d8d50", "current_va": "0x1809d8d50", "delta_bytes": 54592, "delta_str": "+0xd540", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_smoke_tick_update", "name": "CSmokeGrenadeProjectile::TickUpdate", "binary": "server.dll", "category": "Volumetric & Smoke", "baseline_rva": "0x009cea90", "baseline_va": "0x1809cea90", "pattern": "40 53 41 55 48 83 EC 58 80 B9 6C 0B 00 00 00 4C", "pattern_type": "prologue", "description": "Executes per-tick smoke expansion, voxel dissipation timer evaluation, and delta serialization.", "explanation": "Tick-by-tick simulation loop for active volumetric smoke. Decrements smoke duration timer (18.0s), computes natural outward dissipation, checks explosive grenade shockwave radius to displace smoke voxels, and triggers SerializeSparseDelta if voxels are modified.", "code_snippet": "void CSmokeGrenadeProjectile::TickUpdate() {\n float flElapsed = gpGlobals->curtime - this->m_flSpawnTime;\n if (flElapsed > 18.0f) {\n this->StartFading();\n return;\n }\n // Update aerodynamic drag and blast wave displacement\n this->UpdateBlastDispersion();\n if (this->m_bGridDirty) {\n this->NetworkStateChanged();\n }\n}", "reconstructed_file": "game/particles/smoke_voxels.cpp", "current_rva": "0x009dbf40", "current_va": "0x1809dbf40", "delta_bytes": 54448, "delta_str": "+0xd4b0", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_voxel_raymarch", "name": "VoxelGrid_Raymarch", "binary": "server.dll", "category": "Volumetric & Smoke", "baseline_rva": "0x009cd500", "baseline_va": "0x1809cd500", "pattern": "48 8B C4 48 89 58 18 48 89 78 20 55 41 56 41 57 48 8D A8 28 FF FF FF", "pattern_type": "prologue", "description": "3D Digital Differential Analyzer (DDA) raymarching through 32x32x32 voxel occupancy bitmasks.", "explanation": "Core 3D Digital Differential Analyzer (DDA) raymarching loop through the 32x32x32 voxel grid. Traverses Morton Z-order interleaved cells along the ray vector and integrates accumulated optical density with early exit on maximum opacity.", "code_snippet": "float VoxelGrid_Raymarch(const VoxelGrid_t* grid, const Vector& start, const Vector& end) {\n Vector dir = (end - start).Normalized();\n float totalDist = (end - start).Length();\n float stepSize = 10.0f; // Half voxel spacing\n float accumulatedDensity = 0.0f;\n\n for (float dist = 0.0f; dist < totalDist; dist += stepSize) {\n Vector pt = start + dir * dist;\n int vx = (int)(pt.x / 20.0f) & 31;\n int vy = (int)(pt.y / 20.0f) & 31;\n int vz = (int)(pt.z / 20.0f) & 31;\n uint32_t mortonIdx = Morton3D(vx, vy, vz);\n if (grid->TestBit(mortonIdx)) {\n accumulatedDensity += 0.15f * (stepSize / 20.0f);\n if (accumulatedDensity >= 1.0f) return 1.0f;\n }\n }\n return accumulatedDensity;\n}", "reconstructed_file": "game/particles/smoke_voxels.cpp", "current_rva": "0x009da9b0", "current_va": "0x1809da9b0", "delta_bytes": 54448, "delta_str": "+0xd4b0", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_voxel_expand_carve", "name": "VoxelGrid_ExpandAndCarve", "binary": "server.dll", "category": "Volumetric & Smoke", "baseline_rva": "0x009c8e50", "baseline_va": "0x1809c8e50", "pattern": "40 55 53 56 57 41 54 41 55 41 56 41 57 48 8D 6C 24 C8 48 81 EC 38 01 00 00 80 79 08 00", "pattern_type": "prologue", "description": "3D Morton bit-dilation (Z-Order curve) and explosive shockwave radial displacement (+30.0 units).", "explanation": "Manipulates voxel grid occupancy bitmasks for bullet penetration and grenade explosions. A bullet carve clears a cylindrical tunnel along the bullet trajectory, while HE grenade shockwaves push smoke outward radially.", "code_snippet": "void VoxelGrid_ExpandAndCarve(VoxelGrid_t* grid, const Vector& origin, const Vector& dir, float radius, bool isCarve) {\n // 3D Bresenham cylinder traversal\n for (int z = -2; z <= 2; ++z) {\n for (int y = -2; y <= 2; ++y) {\n for (int x = -2; x <= 2; ++x) {\n Vector cellOffset(x * 20.0f, y * 20.0f, z * 20.0f);\n if (cellOffset.Length() <= radius) {\n uint32_t idx = Morton3DFromWorld(origin + cellOffset);\n if (isCarve) grid->ClearBit(idx);\n else grid->SetBit(idx);\n }\n }\n }\n }\n}", "reconstructed_file": "game/particles/smoke_voxels.cpp", "current_rva": "0x009d6390", "current_va": "0x1809d6390", "delta_bytes": 54592, "delta_str": "+0xd540", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_serialize_sparse_delta", "name": "SerializeSparseDelta", "binary": "server.dll", "category": "Volumetric & Smoke", "baseline_rva": "0x009b1bd0", "baseline_va": "0x1809b1bd0", "pattern": "40 53 55 56 57 41 54 41 55 41 56 41 57 48 83 EC 58 48 63 2A 4C 8D B1 D0 00 00 00", "pattern_type": "prologue", "description": "Serializes 10-byte sparse voxel delta packets (2-byte word index + 8-byte uint64 mask) over wire.", "explanation": "Serializes changed voxel words into a compact network bitstream. Instead of transmitting all 512 words (4,096 bytes) per tick, it writes an active dirty-word index followed by the 64-bit mask, reducing wire payload by over 80%.", "code_snippet": "void SerializeSparseDelta(bf_write* buf, const VoxelGrid_t* oldGrid, const VoxelGrid_t* newGrid) {\n for (int word = 0; word < 512; ++word) {\n uint64_t delta = oldGrid->words[word] ^ newGrid->words[word];\n if (delta != 0) {\n buf->WriteOneBit(1); // Has change flag\n buf->WriteUBitLong(word, 9); // Word index (0..511 = 9 bits)\n buf->WriteBytes(&newGrid->words[word], 8); // 8-byte payload\n }\n }\n buf->WriteOneBit(0); // End-of-stream terminator\n}", "reconstructed_file": "game/particles/smoke_voxels.cpp", "current_rva": "0x009bf550", "current_va": "0x1809bf550", "delta_bytes": 55680, "delta_str": "+0xd980", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_lag_compensation", "name": "CLagCompensationManager::StartLagCompensation", "binary": "server.dll", "category": "Gameplay & Physics", "baseline_rva": "0x0080f320", "baseline_va": "0x18080f320", "pattern": "CC FD FF FF 80 38 22 74 CE E9 C2 FD FF FF 40 80", "pattern_type": "signature", "description": "Rewinds entity bone transforms and hitbox bounds to continuous analog sub-tick sample timestamps.", "explanation": "Rolls back player hitboxes to their exact spatial coordinates at the time a client fired a shot. Computes interpolation fraction from sub-tick timestamp and samples the entity position history ring buffer.", "code_snippet": "void CLagCompensationManager::StartLagCompensation(CCSPlayerPawn* player, float flTargetTime) {\n for (CCSPlayerPawn* target : g_pActivePawns) {\n if (target == player || !target->IsAlive()) continue;\n // Sample tick history ring buffer at interpolated flTargetTime\n CPlayerStateRecord interpolatedRecord;\n if (target->m_pHistory->GetRecordAtTime(flTargetTime, &interpolatedRecord)) {\n target->SetupBonesFromRecord(interpolatedRecord);\n }\n }\n}", "reconstructed_file": "game/server/lagcompensation.cpp", "current_rva": "0x0081b770", "current_va": "0x18081b770", "delta_bytes": 50256, "delta_str": "+0xc450", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "pulse_instruction_dispatch", "name": "PulseInstructionDispatchLoop", "binary": "pulse_system.dll", "category": "Scripting & VM", "baseline_rva": "0x0008f810", "baseline_va": "0x18008f810", "pattern": "48 89 5C 24 20 56 48 83 EC 60 48 83 BA 40 01 00 00 00 48 8B DA", "pattern_type": "prologue", "description": "Main execution dispatcher processing fixed-size 56-byte PGDInstruction_t bytecode packets.", "explanation": "Virtual machine opcode execution loop for Valve's Pulse Visual Scripting System (pulse_system.dll). Dispatches 56-byte PGDInstruction_t instructions across 122 opcode types, manages the operand stack, and coordinates asynchronous coroutine fiber yielding.", "code_snippet": "PulseRuntimeState_t PulseInstructionDispatchLoop(CPulseCursor* pCursor, const PGDInstruction_t* pCode) {\n while (pCursor->m_pc < pCursor->m_nInstructionCount) {\n const PGDInstruction_t& inst = pCode[pCursor->m_pc++];\n switch (inst.opcode) {\n case OP_CALL_EXTERNAL:\n DispatchSchemaMethod(inst.targetSymbolHash, pCursor);\n break;\n case OP_YIELD:\n pCursor->m_state = PULSE_CURSOR_WAITING_ASYNC;\n return PULSE_SUSPENDED;\n case OP_JUMP_COND:\n if (pCursor->PopStackBool()) pCursor->m_pc = inst.jumpOffset;\n break;\n case OP_RETURN:\n return PULSE_COMPLETED;\n }\n }\n return PULSE_COMPLETED;\n}", "reconstructed_file": "game/pulse_system/pulse_interpreter.cpp", "current_rva": "0x0008f810", "current_va": "0x18008f810", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "tier0_cvar_findvar", "name": "CCvar::FindVar", "binary": "tier0.dll", "category": "Engine Core", "baseline_rva": "0x0006c6b0", "baseline_va": "0x18006c6b0", "pattern": "40 53 56 57 41 54 41 56 48 83 EC 30 33 DB 45 8B", "pattern_type": "prologue", "description": "Look up ConVar / ConCommand by hash or caseless name in tier0 CCvar registry (VEngineCvar007).", "explanation": "Hash-bucketed lookup into the Source 2 engine console variable registry (CCvar). Hashes the input variable name using caseless MurmurHash2 (seed 0x31415926) and walks the collision bucket linked list.", "code_snippet": "ConVar* CCvar::FindVar(const char* name) {\n uint32_t hash = HashStringCaseless(name);\n uint32_t bucket = hash % this->m_nBucketCount;\n for (ConVar* cvar = this->m_pBuckets[bucket]; cvar != nullptr; cvar = cvar->m_pNext) {\n if (cvar->m_hash == hash && _stricmp(cvar->m_pszName, name) == 0) {\n return cvar;\n }\n }\n return nullptr;\n}", "reconstructed_file": "game/engine2/cvar_engine.cpp", "current_rva": "0x0006c6b0", "current_va": "0x18006c6b0", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "tier0_hash_string_caseless", "name": "HashStringCaseless", "binary": "tier0.dll", "category": "Engine Core", "baseline_rva": "0x0006c8c0", "baseline_va": "0x18006c8c0", "pattern": "48 89 74 24 18 48 89 7C 24 20 41 56 48 83 EC 30 48 8B F2 48 8D B9 54 01 00 00", "pattern_type": "prologue", "description": "Caseless Murmur/FNV string hash algorithm utilizing seed 0x31415926 for ConVar bucket indexing.", "explanation": "Source 2 canonical caseless 32-bit MurmurHash2 implementation with seed 0x31415926. Converts characters to lowercase before mixing 4-byte chunks, ensuring consistent identifiers for schemas, cvars, and net messages.", "code_snippet": "uint32_t HashStringCaseless(const char* str) {\n if (!str) return 0;\n uint32_t len = (uint32_t)strlen(str);\n uint32_t h = (len ^ 0x31415926) >>> 0;\n const uint32_t m = 0x5bd1e995;\n while (len >= 4) {\n uint32_t k = (tolower(str[0])) | (tolower(str[1]) << 8) | (tolower(str[2]) << 16) | (tolower(str[3]) << 24);\n k *= m; k ^= k >> 24; k *= m;\n h *= m; h ^= k;\n str += 4; len -= 4;\n }\n // Final byte chunk mixing\n return h;\n}", "reconstructed_file": "game/schemasystem/schemasystem.cpp", "current_rva": "0x0006c8c0", "current_va": "0x18006c8c0", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "network_read_varbit_msg_id", "name": "ReadVariableBitMessageId", "binary": "networksystem.dll", "category": "Networking", "baseline_rva": "0x001bf5c0", "baseline_va": "0x1801bf5c0", "pattern": "40 53 56 41 57 44 8B 59 10 44 8B C2 41 C1 F8 04", "pattern_type": "prologue", "description": "Prefix tier bit reader decoding 6, 10, 14, or 34-bit variable-width Protobuf message type tokens.", "explanation": "Variable-bit message ID decoder from networksystem.dll. Inspects prefix bits to read 6-bit (ID 0..15), 10-bit (ID 16..255), 14-bit (ID 256..4095), or 34-bit token hashed message identifiers.", "code_snippet": "uint32_t ReadVariableBitMessageId(bf_read* buf) {\n if (buf->ReadOneBit() == 0) {\n return buf->ReadUBitLong(4); // Tier 0: 0..15 (6 bits total)\n }\n if (buf->ReadOneBit() == 0) {\n return buf->ReadUBitLong(8) + 16; // Tier 1: 16..255 (10 bits total)\n }\n if (buf->ReadOneBit() == 0) {\n return buf->ReadUBitLong(12) + 256; // Tier 2: 256..4095 (14 bits total)\n }\n return buf->ReadUBitLong(32); // Tier 3: 32-bit MurmurHash2 token (34 bits total)\n}", "reconstructed_file": "game/networksystem/netmessage_framing.cpp", "current_rva": "0x001bf5c0", "current_va": "0x1801bf5c0", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "network_serialize_net_message", "name": "SerializeNetMessage", "binary": "networksystem.dll", "category": "Networking", "baseline_rva": "0x000e23d0", "baseline_va": "0x1800e23d0", "pattern": "48 89 74 24 20 57 41 54 41 57 48 83 EC 20 C6 81", "pattern_type": "prologue", "description": "Serializes typed Protobuf messages into outgoing UDP bitstreams with prefix headers and byte alignment.", "explanation": "Serializes a network message object into an outgoing UDP packet buffer. Writes the variable-bit message ID prefix header, encodes the Protobuf payload length via VarInt32, and direct-blits the serialized Protobuf byte buffer.", "code_snippet": "void SerializeNetMessage(bf_write* buf, uint32_t msgId, const google::protobuf::Message& msg) {\n WriteVariableBitMessageId(buf, msgId);\n uint32_t byteSize = (uint32_t)msg.ByteSizeLong();\n WriteVarInt32(buf, byteSize);\n msg.SerializeWithCachedSizesToArray(buf->GetWritePtr());\n buf->SeekToBit(buf->GetNumBitsWritten() + byteSize * 8);\n}", "reconstructed_file": "game/networksystem/netmessage_framing.cpp", "current_rva": "0x000e23d0", "current_va": "0x1800e23d0", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "network_write_varint32", "name": "WriteVarInt32", "binary": "networksystem.dll", "category": "Networking", "baseline_rva": "0x001c0760", "baseline_va": "0x1801c0760", "pattern": "40 55 48 83 EC 10 4C 63 41 10 8B EA 8B 51 0C 48", "pattern_type": "prologue", "description": "LEB128 7-bit variable-length unsigned integer encoder for bitstream message payload lengths.", "explanation": "Encodes a 32-bit unsigned integer into LEB128 variable-length format. Emits 7 payload bits per byte with bit 7 set as continuation flag, serializing small integers (0..127) in a single byte.", "code_snippet": "void WriteVarInt32(bf_write* buf, uint32_t val) {\n while (val >= 0x80) {\n buf->WriteUBitLong((val & 0x7F) | 0x80, 8);\n val >>= 7;\n }\n buf->WriteUBitLong(val, 8);\n}", "reconstructed_file": "game/networksystem/netmessage_framing.cpp", "current_rva": "0x001c0760", "current_va": "0x1801c0760", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "network_read_varint32", "name": "ReadVarInt32", "binary": "networksystem.dll", "category": "Networking", "baseline_rva": "0x001bf770", "baseline_va": "0x1801bf770", "pattern": "48 89 5C 24 10 57 33 FF 48 89 74 24 10 8B DF 48", "pattern_type": "prologue", "description": "LEB128 7-bit variable-length unsigned integer decoder reading framed payload lengths.", "explanation": "Decodes a LEB128 variable-length unsigned 32-bit integer from a network bitstream. Accumulates 7-bit chunks while bit 7 is set, aborting after 5 bytes to prevent integer overflow.", "code_snippet": "uint32_t ReadVarInt32(bf_read* buf) {\n uint32_t result = 0, shift = 0;\n while (shift < 35) {\n uint8_t byte = (uint8_t)buf->ReadUBitLong(8);\n result |= (byte & 0x7F) << shift;\n if (!(byte & 0x80)) return result;\n shift += 7;\n }\n return result;\n}", "reconstructed_file": "game/networksystem/netmessage_framing.cpp", "current_rva": "0x001bf770", "current_va": "0x1801bf770", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "network_decode_fieldpaths", "name": "DecodeFieldPaths", "binary": "networksystem.dll", "category": "Delta Compression", "baseline_rva": "0x000835f8", "baseline_va": "0x1800835f8", "pattern": "4C 89 B4 24 38 0C 00 00 41 8B F3 44 89 5C 24 50", "pattern_type": "signature", "description": "Walks entity delta bitstreams using 40-operation Huffman bit-trees to update flattened serializer properties.", "explanation": "Traverses a 40-operation Huffman prefix tree to unpack active property paths for flattened entity delta updates (CSVCMsg_PacketEntities), mapping compressed bitstream tokens to schema fields.", "code_snippet": "void DecodeFieldPaths(bf_read* buf, std::vector* outPaths) {\n FieldPath_t fp = {0};\n while (true) {\n int op = ReadHuffmanOp(buf, g_pFieldPathHuffmanTree);\n if (op == OP_FINISH) break;\n ExecuteFieldPathOp(op, &fp, buf);\n outPaths->push_back(fp);\n }\n}", "reconstructed_file": "game/networksystem/flattened_serializers.cpp", "current_rva": "0x000835f8", "current_va": "0x1800835f8", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "vphysics2_convex_raycast", "name": "ConvexPolyhedronRaycast", "binary": "vphysics2.dll", "category": "Physics & Collision", "baseline_rva": "0x002544a0", "baseline_va": "0x1802544a0", "pattern": "48 8B C4 48 89 58 08 48 89 68 10 48 89 70 18 48 89 78 20 41 56 48 81 EC C0 00 00 00 49 8B 69 08", "pattern_type": "prologue", "description": "Clips ray segment against Rubikon polyhedral half-spaces (RnHull_t) with 0.03125 unit skin tolerance.", "explanation": "Raycasts against a convex polyhedron collision hull in Valve's Rubikon physics engine (vphysics2.dll). Computes entry/exit fractions across bounding half-spaces with a 1/32\" (0.03125 unit) skin tolerance.", "code_snippet": "bool ConvexPolyhedronRaycast(const RnPolyhedron_t* poly, const Vector& start, const Vector& delta, RaycastResult_t* result) {\n float enterFrac = 0.0f, exitFrac = 1.0f;\n Vector enterNormal = Vector(0, 0, 0);\n for (int i = 0; i < poly->m_nPlaneCount; ++i) {\n const Plane_t& plane = poly->m_pPlanes[i];\n float distStart = plane.Distance(start) - 0.03125f; // 1/32\" skin\n float distEnd = plane.Distance(start + delta) - 0.03125f;\n if (distStart > 0.0f && distEnd > 0.0f) return false; // Separating plane\n // Clip enter and exit fractions...\n }\n result->fraction = enterFrac;\n result->normal = enterNormal;\n return true;\n}", "reconstructed_file": "game/vphysics2/rubikon_collision.cpp", "current_rva": "0x002544a0", "current_va": "0x1802544a0", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "vphysics2_capsule_sweep", "name": "CapsuleSweepIntersection", "binary": "vphysics2.dll", "category": "Physics & Collision", "baseline_rva": "0x0016caf0", "baseline_va": "0x18016caf0", "pattern": "48 8B C4 48 89 58 08 48 89 70 18 55 57 41 56 48", "pattern_type": "prologue", "description": "Analytical finite cylinder and hemispherical endcap sweep intersection solver for player hitboxes.", "explanation": "Calculates the exact continuous collision sweep between a moving point/sphere and an oriented cylinder capsule with hemispherical endcaps in vphysics2.dll. Solves the closest point quadratic polynomial.", "code_snippet": "bool CapsuleSweepIntersection(const Capsule_t& capsule, const Vector& start, const Vector& delta, SweepHit_t* hit) {\n Vector segA = capsule.m_vCenter0, segB = capsule.m_vCenter1;\n float radius = capsule.m_flRadius;\n float tRay, tSeg;\n ClosestSegmentSegment(start, start + delta, segA, segB, &tRay, &tSeg);\n Vector ptRay = start + delta * tRay;\n Vector ptSeg = segA + (segB - segA) * tSeg;\n if ((ptRay - ptSeg).LengthSqr() <= radius * radius) {\n hit->fraction = tRay;\n hit->normal = (ptRay - ptSeg).Normalized();\n return true;\n }\n return false;\n}", "reconstructed_file": "game/vphysics2/rubikon_collision.cpp", "current_rva": "0x0016caf0", "current_va": "0x18016caf0", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "animationsystem_twobone_ik", "name": "CTwoBoneIK_LawOfCosines", "binary": "animationsystem.dll", "category": "Animation & Hitboxes", "baseline_rva": "0x002f9750", "baseline_va": "0x1802f9750", "pattern": "48 8B C4 48 89 58 08 55 56 57 48 8D A8 58 FE FF", "pattern_type": "prologue", "description": "Two-Bone inverse kinematics solver computing joint angle using the Law of Cosines: cos(a) = (L1^2 + d^2 - L2^2)/(2*L1*d).", "explanation": "Analytical two-bone inverse kinematics solver in animationsystem.dll. Applies the Law of Cosines to solve joint angles for player limbs (hip-to-knee or shoulder-to-elbow) toward an arbitrary IK target position.", "code_snippet": "bool CTwoBoneIK_LawOfCosines(float l1, float l2, float targetDist, float* outAngleA, float* outAngleB) {\n // Law of Cosines: c^2 = a^2 + b^2 - 2ab * cos(C)\n float clampedDist = std::clamp(targetDist, std::abs(l1 - l2) + 0.001f, (l1 + l2) - 0.001f);\n float cosB = (l1 * l1 + l2 * l2 - clampedDist * clampedDist) / (2.0f * l1 * l2);\n float cosA = (l1 * l1 + clampedDist * clampedDist - l2 * l2) / (2.0f * l1 * clampedDist);\n *outAngleB = std::acos(std::clamp(cosB, -1.0f, 1.0f)); // Knee / Elbow bend\n *outAngleA = std::acos(std::clamp(cosA, -1.0f, 1.0f)); // Shoulder / Hip bend\n return true;\n}", "reconstructed_file": "game/animationsystem/two_bone_ik.cpp", "current_rva": "0x002f9750", "current_va": "0x1802f9750", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "server_bullet_penetration", "name": "EvaluateBulletPenetration", "binary": "server.dll", "category": "Weapon & Penetration", "baseline_rva": "0x00a8fca0", "baseline_va": "0x180a8fca0", "pattern": "48 8B C4 44 89 48 20 48 89 50 10 48 89 48 08 55 57 41 57 48 8D A8 78 FE FF FF 48 81 EC 70 02 00 00", "pattern_type": "prologue", "description": "Authoritative surface penetration evaluator computing material absorption, penetration power reduction, and distance damage falloff.", "explanation": "Authoritative server-side bullet penetration and surface absorption pipeline in server.dll. Evaluates ray intervals through Rubikon physics surfaces (CGamePhysicsQueryInterface::TraceLineIntervals). For air intervals, evaluates exponential damage distance falloff: flDamage = baseDamage * pow(flRangeModifier, distance / 500.0f). For solid surface intervals, extracts Rubikon material modifiers (bulletPenetrationDistanceModifier, bulletPenetrationDamageModifier, bulletspenetrate). Penetration loss is calculated as: totalLost = (penetration_distance^2 * penModifierInv / 24.0f) + max(0.0f, (3.0f / penPower) * 1.25f) * (penModifierInv * 3.0f) + (damageModifier * currentDamage). If remaining damage drops below 1.0f or penetration count reaches 0, the bullet is stopped.", "code_snippet": "bool EvaluateBulletPenetration(BulletData_t& bullet, const SurfaceHitData_t& hit, bool ffBulletPenetration) {\n if (!(hit.flags & 1)) {\n float dist = (hit.tExit - hit.tEnter) * bullet.maxRange;\n bullet.currentDamage *= std::pow(bullet.rangeModifier, dist / 500.0f);\n return true;\n }\n float penMod = hit.enterSurface.bulletPenetrationDistanceModifier;\n if (hit.tExit * bullet.maxRange > 3000.0f || penMod < 0.1f || bullet.penetrationCount < 1) return false;\n float thickness = (hit.exitPoint - hit.enterPoint).Length();\n float penModInv = std::max(0.0f, 1.0f / penMod);\n float lostDist = (thickness * thickness * penModInv) / 24.0f;\n float lostEntry = std::max(0.0f, (3.0f / bullet.penetrationPower) * 1.25f) * (penModInv * 3.0f) + (0.16f * bullet.currentDamage);\n bullet.currentDamage -= (lostDist + lostEntry);\n if (bullet.currentDamage < 1.0f) return false;\n bullet.penetrationCount--;\n return true;\n}", "reconstructed_file": "game/server/bullet_penetration.cpp", "current_rva": "0x00a9d150", "current_va": "0x180a9d150", "delta_bytes": 54448, "delta_str": "+0xd4b0", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "navsystem_pathfind_build_path", "name": "NavAreaBuildPath", "binary": "navsystem.dll", "category": "Navigation & Pathfinding", "baseline_rva": "0x0003bdf0", "baseline_va": "0x18003bdf0", "pattern": "48 8B C4 48 89 48 08 55 53 56 57 48 8D A8 28 F7 FF FF 48 81 EC B8 09 00 00", "pattern_type": "prologue", "description": "Core Source 2 A* pathfinding search heuristic traversing CNavArea nodes with vertical elevation cost weighting.", "explanation": "Executes A* pathfinding search over the navigation mesh graph in navsystem.dll. Maintains an OpenList priority queue (min-heap) of CNavArea nodes, computing traversal g_costs and Euclidean heuristic h_costs modified by nav_pathfind_inadmissable_heuristic_factor and vertical elevation penalties.", "code_snippet": "bool CNavMesh::FindPath(const Vector3& startPos, const Vector3& goalPos, CNavArea* startArea, CNavArea* goalArea, const INavPathCost& costFunc, std::vector& outPathWaypoints, float maxPathLength, float inadmissibleHeuristicFactor) {\n // Priority queue of AStarNode pointers with 3D heuristic and 3.0x vertical elevation scaling\n return AStarSearch(startArea, goalArea, costFunc, outPathWaypoints);\n}", "reconstructed_file": "game/navsystem/navmesh.cpp", "current_rva": "0x0003bdf0", "current_va": "0x18003bdf0", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "client_weapon_update_accuracy_penalty", "name": "C_CSWeaponBase::UpdateAccuracyPenalty", "binary": "client.dll", "category": "Weapons & Ballistics", "baseline_rva": "0x00827be0", "baseline_va": "0x180827be0", "pattern": "40 57 41 56 48 83 EC 68 48 8B F9 E8 ? ? ? ? 4C 8B F0 48 85 C0 0F 84 ? ? ? ? 44 0F 29 44 24 30", "pattern_type": "prologue", "description": "Per-tick weapon inaccuracy penalty evaluator calculating recovery time decay, stances, jumping, and recoil index decay.", "explanation": "Executes per-tick weapon accuracy update for C_CSWeaponBase in client.dll. Determines target baseline inaccuracy based on player pawn posture (standing, ducking, jumping, ladder, or boost stack), applies exponential recovery time decay using exp(-(ln(10)/recoveryTime) * dt), updates turning delta inaccuracy, and decays rapid continuous firing recoil index.", "code_snippet": "void C_CSWeaponBase::UpdateAccuracyPenalty() {\n float target = GetTargetInaccuracy();\n if (m_fAccuracyPenalty >= target) {\n float recoveryTime = GetRecoveryTime();\n float decay = std::exp(-(std::log(10.0f) / recoveryTime) * dt);\n m_fAccuracyPenalty = target + (m_fAccuracyPenalty - target) * decay;\n } else {\n m_fAccuracyPenalty = target;\n }\n UpdateTurningInaccuracy();\n if (m_flRecoilIndex > 0.0f && curTime - m_fLastShotTime > m_flCycleTime + dt) {\n m_flRecoilIndex *= std::exp(-2.0f * std::log(10.0f) * dt);\n if (m_flRecoilIndex <= 0.1f) m_flRecoilIndex = 0.0f;\n }\n}", "reconstructed_file": "game/client/weapon_accuracy.cpp", "current_rva": "0x00828a10", "current_va": "0x180828a10", "delta_bytes": 3632, "delta_str": "+0xe30", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_aim_punch_decay", "name": "CPlayer_AimPunchServices::SimulateAimPunchDecay", "binary": "client.dll", "category": "Weapons & Ballistics", "baseline_rva": "0x0085dc60", "baseline_va": "0x18085dc60", "pattern": "48 8B C4 48 89 58 18 48 89 70 20 55 57 41 54 41 56 41 57 48 8D 68 A1 48 81 EC D0 00 00 00", "pattern_type": "prologue", "description": "Integrates damped spring recoil aim punch angles and velocities per tick.", "explanation": "Executes per-tick damped harmonic oscillation integration for recoil aim punch angles (m_predictableBaseAngle) and velocities (m_predictableBaseAngleVel) in CPlayer_AimPunchServices. Applies exponential velocity damping factor (-4.5f rate), integrates angle step, applies deadzone filtering at 0.140625 (0.375^2), and clamps view pitch within [-89 deg, +89 deg].", "code_snippet": "void CPlayer_AimPunchServices::SimulateAimPunchDecay(float dt) {\n float velDamping = std::exp(-4.5f * dt);\n m_aimPunchAngleVel *= velDamping;\n m_aimPunchAngle += m_aimPunchAngleVel * dt;\n float magSqr = m_aimPunchAngle.LengthSqr();\n if (magSqr <= 0.140625f) {\n m_aimPunchAngle.Init();\n m_aimPunchAngleVel.Init();\n } else {\n m_aimPunchAngle *= (1.0f - 0.140625f / magSqr);\n }\n m_aimPunchAngle.pitch = std::clamp(m_aimPunchAngle.pitch, -89.0f, 89.0f);\n}", "reconstructed_file": "game/client/weapon_accuracy.cpp", "current_rva": "0x0085ea90", "current_va": "0x18085ea90", "delta_bytes": 3632, "delta_str": "+0xe30", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_walk_move", "name": "CCSPlayer_MovementServices::WalkMove", "binary": "client.dll", "category": "Movement & Physics", "baseline_rva": "0x008e9380", "baseline_va": "0x1808e9380", "pattern": "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 57 48 83 EC 50 0F 29 7C 24 30 0F 28 FA 48 8B FA", "pattern_type": "prologue", "description": "Ground walking physics dispatcher executing friction, directional acceleration, obstacle stepping, and ground snapping.", "explanation": "Executes standard Source 2 ground locomotion on CCSPlayer_MovementServices in client.dll. Sets m_bHasWalkMovedSinceLastJump = true (+0x0439), projects horizontal view angles into wish velocity vector, calculates ground friction (sv_friction 5.2), applies sv_accelerate (5.5) with crouch (0.34) and walk (0.52) stance multipliers, resolves obstacle step-ups up to sv_stepsize (18.0 units), and snaps vertical origin to the contact floor via CategorizePosition.", "code_snippet": "void CPlayerMovement::WalkMove(PlayerMovementServices& services, PlayerMoveData& mv, float dt) {\n services.m_bHasWalkMovedSinceLastJump = true;\n QAngle moveAngles{0.0f, mv.viewAngles.y, 0.0f};\n Vector3 forward, right, up;\n CViewRender::AngleVectors(moveAngles, &forward, &right, &up);\n Vector3 wishvel = forward * mv.forwardMove + right * mv.sideMove;\n float wishspeed = wishvel.Length2D();\n Vector3 wishdir = (wishspeed > 0.0f) ? wishvel / wishspeed : Vector3{};\n wishspeed = std::min(wishspeed, mv.maxSpeed);\n Friction(services, mv, dt);\n Accelerate(services, mv, wishdir, wishspeed, SV_ACCELERATE, dt);\n mv.velocity.z = 0.0f;\n StepMove(services, mv, dt);\n CategorizePosition(services, mv, dt);\n}", "reconstructed_file": "game/client/movement.cpp", "current_rva": "0x008ea1b0", "current_va": "0x1808ea1b0", "delta_bytes": 3632, "delta_str": "+0xe30", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_air_accelerate", "name": "CCSPlayer_MovementServices::AirAccelerate", "binary": "client.dll", "category": "Movement & Physics", "baseline_rva": "0x008bfa30", "baseline_va": "0x1808bfa30", "pattern": "F3 0F 11 5C 24 20 53 56 57 48 83 EC 60 48 83 79 38 00 49 8B F0 0F 29 7C 24 40 48 8B DA", "pattern_type": "prologue", "description": "Airborne strafe acceleration routine enforcing sv_air_max_wishspeed (30.0f) clamp and surface friction integration.", "explanation": "Executes airborne strafe physics in client.dll. Clamps wishspeed to sv_air_max_wishspeed (30.0 units/s). Evaluates speed projection along wishdir, calculating addspeed = min(wishspeed, 30.0f) - currentspeed. If addspeed > 0, integrates accelspeed = min(addspeed, sv_airaccelerate * wishspeed * dt * m_flSurfaceFriction) and adds impulse to velocity.", "code_snippet": "void CPlayerMovement::AirAccelerate(PlayerMovementServices& services, PlayerMoveData& mv, const Vector3& wishdir, float wishspeed, float accel, float dt) {\n const float wishspd = std::min(wishspeed, SV_AIR_MAX_WISHSPEED);\n const float currentspeed = DotProduct(mv.velocity, wishdir);\n const float addspeed = wishspd - currentspeed;\n if (addspeed <= 0.0f) return;\n float accelspeed = accel * wishspeed * dt * services.m_flSurfaceFriction;\n if (accelspeed > addspeed) accelspeed = addspeed;\n mv.velocity += wishdir * accelspeed;\n}", "reconstructed_file": "game/client/movement.cpp", "current_rva": "0x008c0860", "current_va": "0x1808c0860", "delta_bytes": 3632, "delta_str": "+0xe30", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_subtick_move_step_parse", "name": "CSubtickMoveStep::_InternalParse", "binary": "client.dll", "category": "Sub-Tick & UserCmd", "baseline_rva": "0x004f4950", "baseline_va": "0x1804f4950", "pattern": "48 89 5C 24 18 48 89 6C 24 20 56 41 56 41 57 48 83 EC 60 49 8B F0 48 89 BC 24 88 00 00 00 48 8B DA 4C 8D 3D ? ? ? ? 48 8B E9 45 33 F6 66 90 48 3B 1E 72 32 8B C3 2B 46 08 3B 46 1C 0F 84 3D 02 00 00", "pattern_type": "prologue", "description": "Protobuf wire unmarshaling routine decoding CSubtickMoveStep fields (VarInt button, bool pressed, fixed32 when, analog deltas).", "explanation": "Iterates through protobuf wire tags for CSubtickMoveStep: field 1 (uint64 button, tag 0x08), field 2 (bool pressed, tag 0x10), field 3 (float when in [0, 1], tag 0x1D), field 4 (analog_forward_delta, tag 0x25), field 5 (analog_left_delta, tag 0x2D), field 8 (pitch delta, tag 0x45), and field 9 (yaw delta, tag 0x4D), updating _has_bits_ mask at +0x10.", "code_snippet": "bool CSubtickMoveStep::_InternalParse(CByteStreamReader& reader) {\n while (reader.HasMore()) {\n uint32_t tag;\n if (!reader.ReadVarInt32(tag)) return false;\n uint32_t fieldNumber = tag >> 3;\n WireType wireType = static_cast(tag & 7);\n switch (fieldNumber) {\n case 1: if (!reader.ReadVarInt64(m_nButton)) return false; m_nHasBits |= HAS_BUTTON; break;\n case 2: uint32_t val; if (!reader.ReadVarInt32(val)) return false; m_bPressed = (val != 0); m_nHasBits |= HAS_PRESSED; break;\n case 3: if (!reader.ReadFloat(m_flWhen)) return false; m_flWhen = std::clamp(m_flWhen, 0.0f, 1.0f); m_nHasBits |= HAS_WHEN; break;\n case 4: if (!reader.ReadFloat(m_flAnalogForwardDelta)) return false; m_nHasBits |= HAS_ANALOG_FORWARD_DELTA; break;\n case 5: if (!reader.ReadFloat(m_flAnalogLeftDelta)) return false; m_nHasBits |= HAS_ANALOG_LEFT_DELTA; break;\n default: if (!reader.SkipField(wireType)) return false; break;\n }\n }\n return true;\n}", "reconstructed_file": "game/client/usercmd_wire.cpp", "current_rva": "0x004f5640", "current_va": "0x1804f5640", "delta_bytes": 3312, "delta_str": "+0xcf0", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_base_usercmd_pb_serialize", "name": "CBaseUserCmdPB::_InternalSerialize", "binary": "client.dll", "category": "Sub-Tick & UserCmd", "baseline_rva": "0x004f63f0", "baseline_va": "0x1804f63f0", "pattern": "48 89 5C 24 10 48 89 6C 24 18 56 57 41 56 48 83 EC 30 8B 71 10 45 33 F6 49 8B D8 4C 8B CA 48 8B F9 40 F6 C6 10 74 61 49 3B 10 72 0B", "pattern_type": "prologue", "description": "Protobuf wire serialization for CBaseUserCmdPB, formatting repeated field 18 subtick_moves with 2-byte tag 0x92 0x01.", "explanation": "Marshals CBaseUserCmdPB fields into wire buffer: command_number (tag 0x08), client_tick (tag 0x10), buttons_pb (tag 0x1A), forwardmove (tag 0x2D), leftmove (tag 0x35), upmove (tag 0x3D), and repeated CSubtickMoveStep array using field 18 wire type 2 tag (0x92 0x01) followed by length-delimited payload.", "code_snippet": "void CBaseUserCmdPB::_InternalSerialize(CByteStreamWriter& writer) const {\n if (m_nHasBits & HAS_COMMAND_NUMBER) { writer.WriteTag(1, WireType::VarInt); writer.WriteVarInt32(m_nCommandNumber); }\n if (m_nHasBits & HAS_CLIENT_TICK) { writer.WriteTag(2, WireType::VarInt); writer.WriteVarInt32(m_nClientTick); }\n for (const auto& step : m_SubtickMoves) {\n CByteStreamWriter stepWriter;\n step._InternalSerialize(stepWriter);\n writer.WriteTag(18, WireType::LengthDelimited); // Tag bytes: 0x92 0x01\n writer.WriteLengthDelimited(stepWriter.GetData().data(), stepWriter.GetSize());\n }\n}", "reconstructed_file": "game/client/usercmd_wire.cpp", "current_rva": "0x004f70e0", "current_va": "0x1804f70e0", "delta_bytes": 3312, "delta_str": "+0xcf0", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_csgo_input_create_move", "name": "CSGOInput::CreateMove", "binary": "client.dll", "category": "Sub-Tick & UserCmd", "baseline_rva": "0x00cfa6b0", "baseline_va": "0x180cfa6b0", "pattern": "48 89 5C 24 18 55 57 41 56 48 8D 6C 24 C9 48 81 EC B0 00 00 00 8B 01 48 8B F9 81 4A 10 00 02 00 00", "pattern_type": "prologue", "description": "High-level input sampling routine calculating sub-tick fractional time w in [0, 1] and assembling CSGOUserCmdPB.", "explanation": "Samples player analog input and button transitions during tick frame. Normalizes hardware timestamp against tick start time (w = clamp((t_event - t_start) / dt, 0.0, 1.0)), populates CSubtickMoveStep entries into CBaseUserCmdPB, records weapon discharge timestamps in CSGOInputHistoryEntryPB, and schedules command for clc_Move transmission.", "code_snippet": "CSubtickMoveStep CSGOInputWireCodec::CreateSubtickMoveStep(uint64_t button, bool pressed, double eventTimestampSec, double tickStartTimestampSec, float tickInterval) {\n CSubtickMoveStep step;\n step.SetButton(button);\n step.SetPressed(pressed);\n double elapsed = eventTimestampSec - tickStartTimestampSec;\n step.SetWhen(static_cast(elapsed / tickInterval));\n return step;\n}", "reconstructed_file": "game/client/usercmd_wire.cpp", "current_rva": "0x00cfbd10", "current_va": "0x180cfbd10", "delta_bytes": 5728, "delta_str": "+0x1660", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_weapon_get_inaccuracy", "name": "C_CSWeaponBase::GetInaccuracy", "binary": "client.dll", "category": "Weapons & Ballistics", "baseline_rva": "0x0080c1a0", "baseline_va": "0x18080c1a0", "pattern": "48 89 5C 24 10 55 56 57 48 81 EC B0 00 00 00 44 0F 29 84 24 80 00 00 00 49 8B F0 48 8B EA 48 8B F9", "pattern_type": "prologue", "description": "Composite weapon inaccuracy evaluator synthesizing base penalty, posture, 2D movement speed power curve, airborne apex, strafing, and turning.", "explanation": "Evaluates total composite weapon inaccuracy scalar in range [0.0, 1.0]. Remaps 2D speed between 34% and 95% max weapon speed, applies 0.25 crouch power curve, evaluates vertical falling speed interpolation between apex (200 u/s) and initial jump penalty, and appends orthogonal strafing and view turning angular penalties.", "code_snippet": "float C_CSWeaponBase::GetInaccuracy(float* outSpread, float* outJumpInacc) {\n float total = m_fAccuracyPenalty;\n float speed2D = std::sqrt(vel.x * vel.x + vel.y * vel.y);\n float low = m_flMaxSpeed * 0.34f, high = m_flMaxSpeed * 0.95f;\n if (speed2D > low) {\n float frac = std::clamp((speed2D - low) / (high - low), 0.0f, 1.0f);\n if (ducking) frac = std::pow(frac, 0.25f);\n total += frac * m_flInaccuracyMove;\n }\n if (!onGround) total += GetJumpInaccuracy();\n total += CalculateStrafingInaccuracy() + m_flTurningInaccuracy;\n return std::clamp(total, 0.0f, 1.0f);\n}", "reconstructed_file": "game/client/weapon_accuracy.cpp", "current_rva": "0x0080cfd0", "current_va": "0x18080cfd0", "delta_bytes": 3632, "delta_str": "+0xe30", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "client_fx_calculate_spread", "name": "FX_CalculateSpread", "binary": "client.dll", "category": "Weapons & Ballistics", "baseline_rva": "0x00d23fe0", "baseline_va": "0x180d23fe0", "pattern": "48 8B C4 48 89 58 18 48 89 68 20 89 50 10 56 57 41 54 41 56 41 57 48 81 EC E0 00 00 00 44 8B 15 ? ? ? ? 41 8B F9 0F 29 78 B8 41 8B E8", "pattern_type": "prologue", "description": "Calculates 2D bullet/pellet spread deflection vector using dual uniform disk sampling (inaccuracy and intrinsic spread disks) and weapon distributions.", "explanation": "Executes bullet spread deflection calculations inside FX_FireBullets in client.dll. Samples two independent uniform disks: (r1, theta1) for inaccuracy and (r2, theta2) for intrinsic weapon spread. Applies non-linear transformations for R8 Revolver fan-the-hammer (r = 1 - r^2) and Negev continuous firing spin-up laser convergence, projecting the vector sum onto the view plane.", "code_snippet": "void FX_CalculateSpread(uint16_t itemDefIndex, int32_t numBullets, int32_t weaponMode, int32_t seed, float inacc, float spread, float recoilIdx, float* outX, float* outY) {\n RandomSeed(seed);\n float r1 = RandomFloat(0.0f, 1.0f), theta1 = RandomFloat(0.0f, 2.0f * PI);\n if (itemDefIndex == 64 && weaponMode == 1) r1 = 1.0f - r1 * r1;\n float R_inacc = r1 * inacc;\n float r2 = RandomFloat(0.0f, 1.0f), theta2 = RandomFloat(0.0f, 2.0f * PI);\n if (itemDefIndex == 64 && weaponMode == 1) r2 = 1.0f - r2 * r2;\n float R_spread = r2 * spread;\n *outX = std::cos(theta1) * R_inacc + std::cos(theta2) * R_spread;\n *outY = std::sin(theta1) * R_inacc + std::sin(theta2) * R_spread;\n}", "reconstructed_file": "game/client/weapon_accuracy.cpp", "current_rva": "0x00d25630", "current_va": "0x180d25630", "delta_bytes": 5712, "delta_str": "+0x1650", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_lag_compensation_finish", "name": "CLagCompensationManager::FinishLagCompensation", "binary": "server.dll", "category": "Gameplay & Physics", "baseline_rva": "0x00ebf350", "baseline_va": "0x180ebf350", "pattern": "40 53 57 41 57 48 83 EC 60 48 8D 05 ? ? ? ? 48 C7 44 24 28 59 06 00 00 48 8B F9 48 89 44 24 20", "pattern_type": "prologue", "description": "Restores all backtracked player pawns to authoritative current states after lag-compensated traces.", "explanation": "Iterates the tracked pawn collection in CLagCompensationManager, resolves 32-bit entity handles, and restores pre-rewind positions, bounds, and bone matrices via RestoreEntityTo.", "code_snippet": "void CLagCompensationManager::FinishLagCompensation() {\n if (!this->m_bLagCompensationActive || !this->m_bNeedRestore) return;\n for (int i = 0; i < this->m_nTrackedPawnCount; ++i) {\n TrackedEntity_t* entry = &this->m_pTrackedPawns[i];\n if (!entry->m_bIsBacktracked) continue;\n CBaseEntity* entity = ResolveEntityHandle(entry->m_hEntity);\n if (entity && entry->m_pRestoreRecord) {\n RestoreEntityTo(entity, entry->m_pRestoreRecord);\n }\n entry->m_bIsBacktracked = false;\n }\n this->m_bLagCompensationActive = false;\n}", "reconstructed_file": "game/server/lagcompensation.cpp", "current_rva": "0x00ecc690", "current_va": "0x180ecc690", "delta_bytes": 54080, "delta_str": "+0xd340", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_lag_compensation_restore", "name": "CLagCompensationManager::RestoreEntityTo", "binary": "server.dll", "category": "Gameplay & Physics", "baseline_rva": "0x00ed3f10", "baseline_va": "0x180ed3f10", "pattern": "48 89 5C 24 18 57 41 56 41 57 48 83 EC 40 45 33 F6 45 33 FF 49 8B D8 48 8B FA 45 38 70 01", "pattern_type": "prologue", "description": "Restores entity origin, angles, bounds, and bone matrix cache with 4096.0 sqr teleport distance breaker.", "explanation": "Per-entity state restoration helper. Validates displacement against 4096.0 sqr units (64.0 units) to prevent teleport snapping and reapplies cached skeleton transforms.", "code_snippet": "void CLagCompensationManager::RestoreEntityTo(CBaseEntity* entity, const LagRecord_t* record) {\n if (record->flags & LAG_RECORD_BOUNDS_CHANGED) entity->SetCollisionBounds(record->mins, record->maxs);\n if (record->flags & LAG_RECORD_ANGLES_CHANGED) entity->SetEyeAngles(record->eyeAngles);\n if (record->flags & LAG_RECORD_ORIGIN_CHANGED) {\n float distSqr = (entity->GetAbsOrigin() - record->preTeleportOrigin).LengthSqr();\n if (distSqr < 4096.0f) entity->SetAbsOrigin(record->origin);\n }\n if (record->flags & LAG_RECORD_BONES_CHANGED) entity->SetupBones(record->boneMatrices, record->boneCount);\n}", "reconstructed_file": "game/server/lagcompensation.cpp", "current_rva": "0x00ee1250", "current_va": "0x180ee1250", "delta_bytes": 54080, "delta_str": "+0xd340", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_apply_armor_damage", "name": "CCSPlayerPawn::ApplyArmorDamageCalculation", "binary": "server.dll", "category": "Weapons & Ballistics", "baseline_rva": "0x00a81050", "baseline_va": "0x180a81050", "pattern": "48 89 5C 24 20 55 56 57 41 56 41 57 48 83 EC 50 48 83 79 38 00 48 8B DA 48 8B F9 75 05 E8 ? ? ? ? 8B 4B 4C 4C 8B 77", "pattern_type": "prologue", "description": "Evaluates Kevlar and Helmet armor absorption, durability exhaustion overflow, and post-mitigation health loss.", "explanation": "Reconstructed from server.dll @ RVA 0x00a81050. Checks CCSPlayerPawn::IsArmored(hitGroup), scales incoming damage by weapon m_flArmorRatio * 0.5f, computes armor durability cost via flArmorBonus (0.5f), handles partial armor depletion overflow, and truncates final damage to int32.", "code_snippet": "if (flHealthDamage > 0.0f && IsArmored(info.m_nHitGroup)) {\n float flNewDamage = flHealthDamage * (info.m_flArmorPenetration * 0.5f);\n float flArmorDamage = std::max(1.0f, (flHealthDamage - flNewDamage) * 0.5f);\n if (flArmorDamage > m_ArmorValue) {\n flArmorDamage = static_cast(m_ArmorValue);\n flNewDamage = flHealthDamage - (flArmorDamage / 0.5f);\n }\n m_ArmorValue -= static_cast(flArmorDamage);\n flHealthDamage = flNewDamage;\n}\nm_iHealth = std::max(0, m_iHealth - static_cast(flHealthDamage));", "reconstructed_file": "game/server/hit_registration_damage.cpp", "current_rva": "0x00a8e500", "current_va": "0x180a8e500", "delta_bytes": 54448, "delta_str": "+0xd4b0", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "server_pawn_is_armored", "name": "CCSPlayerPawn::IsArmored", "binary": "server.dll", "category": "Weapons & Ballistics", "baseline_rva": "0x00aca700", "baseline_va": "0x180aca700", "pattern": "45 32 C0 83 B9 ? ? 00 00 00 7E 3C 83 FA 08 77 37 48 63 C2 4C 8D 0D ? ? ? ? 41 8B 94 81 ? ? ? ? 49 03 D1 FF E2", "pattern_type": "prologue", "description": "8-way HitGroup_t jump table verifying Kevlar vest coverage on torso/arms and m_bHasHelmet on head/neck.", "explanation": "Reconstructed from server.dll @ RVA 0x00aca700. Verifies m_ArmorValue > 0, then switches on HitGroup_t: returns true for Chest, Stomach, and Arms, checks m_pItemServices->m_bHasHelmet (+0xB18 -> +0x41) for Head/Neck, and returns false for Legs.", "code_snippet": "bool CCSPlayerPawn::IsArmored(HitGroup_t hitGroup) const {\n if (m_ArmorValue <= 0) return false;\n switch (hitGroup) {\n case HITGROUP_GENERIC: case HITGROUP_CHEST: case HITGROUP_STOMACH:\n case HITGROUP_LEFTARM: case HITGROUP_RIGHTARM:\n return true;\n case HITGROUP_HEAD: case HITGROUP_NECK:\n return m_pItemServices && m_pItemServices->m_bHasHelmet;\n default:\n return false;\n }\n}", "reconstructed_file": "game/server/hit_registration_damage.cpp", "current_rva": "0x00ad7ba0", "current_va": "0x180ad7ba0", "delta_bytes": 54432, "delta_str": "+0xd4a0", "last_verified_build": "26144732", "status": "SHIFTED" }, { "id": "animationsystem_blend_update_node_weights", "name": "CBlendUpdateNode_ComputeWeights", "binary": "animationsystem.dll", "category": "Animation & Hitboxes", "baseline_rva": "0x002d7a80", "baseline_va": "0x1802d7a80", "pattern": "48 8B C4 48 89 58 10 57 48 81 EC 80 00 00 00 0F 29 70 E8 41 8B F8 48 89 70 08 0F 57 F6", "pattern_type": "prologue", "description": "Evaluates parameter blend values and calculates normalized interpolation weights between adjacent child animation nodes in CBlendUpdateNode.", "explanation": "Reconstructed 1D blend parameter evaluator from animationsystem.dll @ FUN_1802d7a80. Computes floor(v), fractional delta, and assigns child weights wA = 1 - f, wB = f.", "code_snippet": "std::pair CBlendUpdateNode_ComputeWeights(float blendValue, int numChildren) {\n if (numChildren <= 1) return {{0, 1.0f}, {-1, 0.0f}};\n float clamped = std::clamp(blendValue, 0.0f, static_cast(numChildren - 1));\n int base = static_cast(std::floor(clamped));\n float frac = clamped - static_cast(base);\n return {{base, 1.0f - frac}, {base + 1, frac}};\n}", "reconstructed_file": "game/animationsystem/animgraph_blender.cpp", "current_rva": "0x002d7a80", "current_va": "0x1802d7a80", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "animationsystem_statemachine_evaluate_transitions", "name": "CStateMachineUpdateNode_EvaluateTransitions", "binary": "animationsystem.dll", "category": "Animation & Hitboxes", "baseline_rva": "0x002c82c0", "baseline_va": "0x1802c82c0", "pattern": "40 56 57 41 54 48 81 EC 80 00 00 00 48 8B F1 48 8B FA 48 83 C1 70 E8 ? ? ? ? 85 C0", "pattern_type": "prologue", "description": "Evaluates active animation state machine transitions, computes elapsed transition cross-fade weights, and drives state switching in CStateMachineUpdateNode.", "explanation": "Core state transition driver in animationsystem.dll @ FUN_1802c82c0. Evaluates elapsed transition progress t in [0, 1], drives Hermite smoothstep cubic cross-fade weighting (3t^2 - 2t^3), and commits target state upon completion.", "code_snippet": "void CStateMachineUpdateNode::Update(const CAnimUpdateContext& context) {\n if (!m_bIsTransitioning) return;\n float t = EvaluateTransitionProgress(context.m_flCurrentTime);\n if (t >= 1.0f) {\n m_nCurrentStateID = m_nTargetStateID;\n m_nTargetStateID = -1;\n m_bIsTransitioning = false;\n }\n}", "reconstructed_file": "game/animationsystem/animgraph_blender.cpp", "current_rva": "0x002c82c0", "current_va": "0x1802c82c0", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" }, { "id": "animationsystem_quaternion_angleaxis", "name": "Quaternion_FromAngleAxis", "binary": "animationsystem.dll", "category": "Animation & Hitboxes", "baseline_rva": "0x0038dcc0", "baseline_va": "0x18038dcc0", "pattern": "40 53 48 83 EC 30 F3 0F 10 5A 08 48 8B D9 0F 29 74 24 20 0F 57 E4 F2 0F 10 32", "pattern_type": "prologue", "description": "Converts a 3D unit axis and radian angle into a 4D unit quaternion (axis * sin(theta/2), cos(theta/2)).", "explanation": "Fast analytical quaternion generation routine from animationsystem.dll @ FUN_18038dcc0. Applied in procedural IK solvers and AnimGraph bone rotation modifiers.", "code_snippet": "Quaternion Quaternion::FromAngleAxis(const Vector3& axis, float angleRad) {\n float s = std::sin(angleRad * 0.5f);\n Vector3 norm = axis.Normalized();\n return {norm.x * s, norm.y * s, norm.z * s, std::cos(angleRad * 0.5f)};\n}", "reconstructed_file": "game/animationsystem/animgraph_blender.cpp", "current_rva": "0x0038dcc0", "current_va": "0x18038dcc0", "delta_bytes": 0, "delta_str": "+0x0", "last_verified_build": "26144732", "status": "UNCHANGED" } ] }