Исходник Semi-reversed runcommand

LagFixKing · 26 Апр 2025

C++:

void __fastcall CPlayer_MovementServices::RunCommand(_QWORD *a1, __int64 a2)
{
  __int64 pEntity; // rax
  __int64 pNextEntity; // rdi
  int m_nTickBase; // eax
  float v7; // xmm1_4
  __int64 ClockStart; // rax
  float v9; // xmm0_4
  int v10; // xmm7_4
  int m_nNextTickBase; // eax
  int v12; // ebx
  unsigned int v13; // eax
  unsigned int *v14; // rax
  int m_nEastimatedTickBase; // eax
  _QWORD *pNextGlobalVars; // rbx
  int m_nNextEastimatedTickBase; // ebp
  float m_nTickBaseMultiplied; // xmm8_4
  void (__fastcall *v19)(__int64); // rax
  int v20; // xmm6_4
  void (__fastcall *v21)(_QWORD); // rax
  int v22; // xmm9_4
  int v23; // r15d
  int v24; // xmm10_4
  int v25; // xmm11_4
  void (__fastcall *v26)(__int64); // rax
  void (__fastcall *v27)(_QWORD); // rax
  __int64 v28; // rdx
  __int64 i; // rbx
  int v30; // eax
  __int64 v31; // [rsp+20h] [rbp-D8h]
  double v32; // [rsp+30h] [rbp-C8h] BYREF
  float v33; // [rsp+38h] [rbp-C0h]
  int v34; // [rsp+3Ch] [rbp-BCh]
  __int64 v35; // [rsp+40h] [rbp-B8h] BYREF
  int v36; // [rsp+48h] [rbp-B0h]
  __int64 v37; // [rsp+50h] [rbp-A8h]
  int v38; // [rsp+58h] [rbp-A0h]
  int v39; // [rsp+5Ch] [rbp-9Ch]
  char v40; // [rsp+60h] [rbp-98h]
  char v41; // [rsp+100h] [rbp+8h] BYREF

  pEntity = ((__int64 (*)(void))GetEntity)();
  pNextEntity = pEntity;
  if ( pEntity )
    m_nTickBase = GetTickBase(pEntity);
  else
    m_nTickBase = *((_DWORD *)g_pGlobalVars + 0x12);
  DevMessage((__int64)&v35, 0i64, "runcommand:%04d,tick:%u", *(unsigned int *)(a2 + 8), m_nTickBase);
  if ( (*(unsigned int (__fastcall **)(__int64))(*(_QWORD *)qword_181BB5C08 + 200i64))(qword_181BB5C08) != -1 )
  {
    v7 = Plat_FloatTime();
    v33 = v7;
    ClockStart = Plat_GetClockStart();
    if ( ClockStart < 0 )
      v9 = (float)(ClockStart & 1 | (unsigned int)((unsigned __int64)ClockStart >> 1))
         + (float)(ClockStart & 1 | (unsigned int)((unsigned __int64)ClockStart >> 1));
    else
      v9 = (float)(int)ClockStart;
    v34 = 2;
    v32 = v9;
    (*(void (__fastcall **)(__int64, __int64, __int64, __int64, double *))(*(_QWORD *)qword_181BB5CE8 + 128i64))(
      qword_181BB5CE8,
      1095652422i64,
      1i64,
      16i64,
      &v32);
  }
  (*(void (__fastcall **)(_QWORD *, __int64))(*a1 + 288i64))(a1, a2);
  v10 = 0;
  if ( pNextEntity )
  {
    if ( *((float *)g_pGlobalVars + 12) != 0.0 )
    {
      m_nNextTickBase = GetTickBase(pNextEntity);
      SetTickBase(pNextEntity, (unsigned int)(m_nNextTickBase + 1));
      if ( CEngineClient::IsPaused(m_nProcessedTicks) )
      {
        if ( (unsigned __int8)LoggingSystem_IsChannelEnabled((unsigned int)dword_181A88710, 2i64) )
        {
          v12 = *(_DWORD *)(a2 + 8);
          v13 = GetTickBase(pNextEntity);
          LODWORD(v31) = v12;
          LoggingSystem_Log(
            (unsigned int)dword_181A88710,
            2i64,
            ":    client advancing tick base to %u for command %d\n",
            v13,
            v31);
        }
      }
    }
  }
  v14 = sub_18068CC10((__int64)a1, &v41);
  if ( sub_18047E480(*v14) )
  {
    if ( (*(unsigned __int8 (__fastcall **)(_QWORD *))(*a1 + 304i64))(a1) )
      goto LABEL_40;
  }
  else
  {
    v10 = 1015021568;
  }
  if ( pNextEntity )
  {
    m_nEastimatedTickBase = GetTickBase(pNextEntity);
    pNextGlobalVars = g_pGlobalVars;
    m_nNextEastimatedTickBase = m_nEastimatedTickBase;
  }
  else
  {
    pNextGlobalVars = g_pGlobalVars;
    m_nNextEastimatedTickBase = *((_DWORD *)g_pGlobalVars + 18);
  }
  m_nTickBaseMultiplied = (float)m_nNextEastimatedTickBase * 0.015625;
  if ( !*((_BYTE *)pNextGlobalVars + 69) && !*((_BYTE *)pNextGlobalVars + 68) )
  {
    v19 = (void (__fastcall *)(__int64))pNextGlobalVars[5];
    if ( v19 )
      v19(1i64);
  }
  v20 = *((_DWORD *)pNextGlobalVars + 13);
  if ( !*((_BYTE *)pNextGlobalVars + 69) )
  {
    if ( *((_BYTE *)pNextGlobalVars + 68) )
    {
      v21 = (void (__fastcall *)(_QWORD))pNextGlobalVars[5];
      if ( v21 )
        v21(0i64);
    }
  }
  v22 = *((_DWORD *)pNextGlobalVars + 14);
  v23 = *((_DWORD *)pNextGlobalVars + 18);
  v24 = *((_DWORD *)pNextGlobalVars + 21);
  v25 = *((_DWORD *)pNextGlobalVars + 12);
  *((float *)pNextGlobalVars + 14) = m_nTickBaseMultiplied;
  *((_DWORD *)pNextGlobalVars + 18) = m_nNextEastimatedTickBase;
  *((float *)pNextGlobalVars + 13) = m_nTickBaseMultiplied;
  *((_DWORD *)pNextGlobalVars + 12) = v10;
  *((_DWORD *)pNextGlobalVars + 21) = 0;
  if ( pNextEntity )
    CPlayer_Controller::PhysicsRunThink(pNextEntity);
  CPlayer_MovementServices::ProcessMovement(a1, a2);
  (*(void (__fastcall **)(_QWORD *))(*a1 + 296i64))(a1);
  if ( !*((_BYTE *)pNextGlobalVars + 69) )
  {
    if ( !*((_BYTE *)pNextGlobalVars + 68) )
    {
      v26 = (void (__fastcall *)(__int64))pNextGlobalVars[5];
      if ( v26 )
        v26(1i64);
    }
    if ( !*((_BYTE *)pNextGlobalVars + 0x45) )
    {
      if ( *((_BYTE *)pNextGlobalVars + 68) )
      {
        v27 = (void (__fastcall *)(_QWORD))pNextGlobalVars[5];
        if ( v27 )
          v27(0i64);
      }
    }
  }
  *((_DWORD *)pNextGlobalVars + 0xE) = v22;
  *((_DWORD *)pNextGlobalVars + 0xC) = v25;
  *((_DWORD *)pNextGlobalVars + 0x15) = v24;
  *((_DWORD *)pNextGlobalVars + 0x12) = v23;
  *((_DWORD *)pNextGlobalVars + 0xD) = v20;
LABEL_40:
  if ( v40 )
    CCSPlayerPawn::ProcessNextSubTick((__int64)m_nProcessedTicks, (const char **)&v35);
  v28 = v37;
  for ( i = v36 - 1; i >= 0; --i )
  {
    if ( *(_QWORD *)(v28 + 8 * i) )
    {
      CUtlString::FreeMemoryBlock((CUtlString *)(v28 + 8 * i));
      v28 = v37;
    }
  }
  v30 = v39;
  v36 = 0;
  if ( (v39 & 0xC0000000) == 0 )
  {
    if ( v28 )
    {
      (*(void (__fastcall **)(_QWORD))(*g_pMemAlloc + 24i64))(g_pMemAlloc);
      v30 = v39;
      v37 = 0i64;
    }
    v38 = 0;
    if ( (v30 & 0xC0000000) == 0 )
      v38 = 0;
  }
  if ( v35 )
    CUtlString::FreeMemoryBlock((CUtlString *)&v35);
}

TayJlaur1337 · 26 Апр 2025

what's the point? when you can do it through a signature or rebuild it

LagFixKing · 26 Апр 2025

TayJlaur1337 написал(а):
what's the point? when you can do it through a signature or rebuild it

тебе не нужно его ребилдить
в целом он используется для того чтоб улучшить свой энджин предикшен

TayJlaur1337 · 26 Апр 2025

LagFixKing написал(а):
тебе не нужно его ребилдить
в целом он используется для того чтоб улучшить свой энджин предикшен

ну так а смысл? когда можно через сигнатуру

LagFixKing · 26 Апр 2025

TayJlaur1337 написал(а):
ну так а смысл? когда можно через сигнатуру

что через сигнатуру то
тебе его вызывать также не нужно
тебе нужно посмотреть что игра делает в некоторых моментах и вызывать эти куски кода в своем энджин предикшене

TayJlaur1337 · 26 Апр 2025

LagFixKing написал(а):
что через сигнатуру то
тебе его вызывать также не нужно
тебе нужно посмотреть что игра делает в некоторых моментах и вызывать эти куски кода в своем энджин предикшене

даже так, ну просто я вызываю run_command через сигнатуру и всё нормально работает, ну все ровно красава что заливаешь такое на юг

LagFixKing · 26 Апр 2025

TayJlaur1337 написал(а):
даже так, ну просто я вызываю run_command через сигнатуру и всё нормально работает, ну все ровно красава что заливаешь такое на юг

красавчик, у ранкоманда есть свой индекс так как он находится в виртуальной таблице в классе CPlayer_MovementServices и таким мувом ты вызываешь куча лишнего мусора который не нужен

TayJlaur1337 · 26 Апр 2025

LagFixKing написал(а):
красавчик, у ранкоманда есть свой индекс так как он находится в виртуальной таблице в классе CPlayer_MovementServices и таким мувом ты вызываешь куча лишнего мусора который не нужен

не спорю что куча мусора, но главное что работает

_or_75 · 26 Апр 2025

блять просто команады в таймиг отправляйте и будет вам счастье

sjscsgos · 26 Апр 2025

hate to be a downer but this is pretty useless as anyone who might know how to use this can fully reverse it themselves.

laithcool · 26 Апр 2025

C++:

void CPlayer_MovementServices::RunCommand(CPlayer_MovementServices* this, CMoveData* pMoveData)
{
    CBaseEntity* pPlayer = GetEntity();
    int currentTickBase;
    
    if (pPlayer)
        currentTickBase = pPlayer->GetTickBase();
    else
        currentTickBase = g_pGlobalVars->m_nTickCount;
    
    // Debug logging for the run command execution
    DevMessage("runcommand:%04d,tick:%u", pMoveData->m_nCommandNumber, currentTickBase);

    // Performance tracking if developer mode is enabled
    if (developer->GetInt() != -1)
    {
        float startTime = Plat_FloatTime();
        int clockStart = Plat_GetClockStart();
        float clockValue;
        
        if (clockStart < 0)
            clockValue = (float)(clockStart & 1 | (unsigned int)((unsigned __int64)clockStart >> 1)) * 2.0f;
        else
            clockValue = (float)clockStart;
            
        // Record start time for telemetry
        ETWBeginEvent(1095652422, 1, 16, &clockValue);
    }

    // Call pre-movement function (likely PreProcessMovement)
    this->PreProcessMovement(pMoveData);
    
    int frametime_override = 0; // Default frametime behavior
    
    // Handle tick base updates for prediction
    if (pPlayer)
    {
        if (g_pGlobalVars->frametime != 0.0f)
        {
            int nextTickBase = pPlayer->GetTickBase();
            pPlayer->SetTickBase(nextTickBase + 1);
            
            // Log if game is paused
            if (engine->IsPaused())
            {
                if (sv_logprediction.GetBool())
                {
                    int cmdNum = pMoveData->m_nCommandNumber;
                    unsigned int newTickBase = pPlayer->GetTickBase();
                    ConDMsg(":    client advancing tick base to %u for command %d\n", newTickBase, cmdNum);
                }
            }
        }
    }
    
    // Check for special movement conditions
    UserCmd* pCmd = GetUserCmd(pMoveData);
    if (IsValidUserCmd(pCmd->m_buttons))
    {
        if (!this->ShouldProcessMovement())
            goto MOVEMENT_DONE;
    }
    else
    {
        // Override frametime for specific conditions
        frametime_override = 1015021568; // Special value (likely 0.015625f in hex)
    }
    
    // Setup prediction environment
    int estimatedTickBase;
    if (pPlayer)
    {
        estimatedTickBase = pPlayer->GetTickBase();
    }
    else
    {
        estimatedTickBase = g_pGlobalVars->m_nSimulationTick;
    }
    
    int prevTickBase = estimatedTickBase;
    float tickInterval = estimatedTickBase * 0.015625f; // Convert ticks to time
    
    // Save global state
    CGlobalVarsBase* globals = g_pGlobalVars;
    bool inPrediction = globals->m_bInPrediction;
    bool firstPrediction = globals->m_bFirstTimePredicted;
    float oldCurrentTime = globals->curtime;
    float oldFrameTime = globals->frametime;
    int oldTickCount = globals->tickcount;
    int oldClientTickCount = globals->m_nSimulationTick;
    int oldSpecialClientTickCount = globals->m_nServerCommandsAcknowledged;
    
    // Setup prediction globals
    globals->curtime = tickInterval;
    globals->m_nSimulationTick = estimatedTickBase;
    globals->frametime = tickInterval;
    globals->frametime_override = frametime_override;
    globals->m_nServerCommandsAcknowledged = 0;
    
    // Run player think function if needed
    if (pPlayer)
        pPlayer->PhysicsRunThink();
    
    // Process actual movement
    this->ProcessMovement(pMoveData);
    
    // Call post-movement function (likely PostProcessMovement)
    this->PostProcessMovement();
    
    // Restore global state
    globals->curtime = oldCurrentTime;
    globals->frametime_override = 0;
    globals->m_nServerCommandsAcknowledged = oldSpecialClientTickCount;
    globals->m_nSimulationTick = oldClientTickCount;
    globals->frametime = oldFrameTime;
    
MOVEMENT_DONE:
    // Handle subtick processing for CS player pawns
    if (hasSubTicks)
        CCSPlayerPawn::ProcessNextSubTick(playerPawn, moveData);
    
    // Cleanup string resources
    if (stringResources)
    {
        for (int i = stringCount - 1; i >= 0; i--)
        {
            if (stringArray[i])
            {
                CUtlString::FreeMemoryBlock(&stringArray[i]);
            }
        }
        
        stringCount = 0;
        
        if (stringArray)
        {
            g_pMemAlloc->Free(stringArray);
            stringArray = NULL;
            stringCapacity = 0;
        }
    }
    
    // Free any allocated message memory
    if (messageBuffer)
        CUtlString::FreeMemoryBlock(&messageBuffer);
}

claude 3.7 premium 30$ a week

Исходник Semi-reversed runcommand

Похожие темы