Welcome to hackvshack.net Forum!
Download Free HvH CS2/CS:GO Cheats, CFG, LUA/JS Scripts, and More!
Register

Article explanation about "defensive doubletap predict" why this is scam etc.

this is how does real defensive DT work and why this is unhittable:
1. simulation time (simtime): DT shifts simtime forward artificially
2. Backtrack Records: server stores entity positions over time for lag compensation
3. shot registration: when simtime is ahead of the shot time, backtrack records get skipped and your shot will be unregistered because for server theres nothing there!

so all "Corsa's" or other predictions is a scam
out of context so y'all will know other projects of those skids:

(Corsa resolver) is a total scam im pretty sure he turned on force bodyyaw 59 degress in a playerlist in gamesense so it will ALWAYS miss head imagine thinking that your resolver is better than gs resolver and selling it (imagine thinking cheat for 500 dollars cant resolve ts)
 
Last edited:
what i meant under math called extrapol. you extrapolate (based on movement, etc etc etc etc etc etc), because thats the only correct thing you can do other than not shooting / missing :D (only good cheats can do that, pastes well... cant.... some pastes like primordial, neverlose doesnt even have proper auto strafer, which doesnt require much math skill, YET some people expect something from the cheat, like extrapolation XD, but at least DucaRii said that hes bad in math so yeah, unlke soufiw)
only pasted cheats try to backtrack lc or those dont even shoot. thats what i meant bro
and fatal is a paste, philip is lil retarded, espc since cs2 came out :D
autistic shizo rambling
 
  • Like
Reactions: DrippyHvH
those misses were probably caused by a dogshit config or extreme high ping, or admin abuse on server xd
and what are you saying? what does prediction have to do with backtrack? its like saying "ill die tomorrow" (which is not possible to know) [prediction] and saying "i almost got hit by a car yesterday" (probably true, because happened) [backtrack]
and with the part of the "video is a scam" i could agree because there's NO chance that GS will miss that much on that, except with configs from "big namers" who uses 73 hc and 65 ps on gs XD
and another thing is, resolver doesn't really have to do anything with prediction in most cases
Ay persona you insulted me say sory
and also gs misses in this vid cus of lc0
 
this is how does real defensive DT work and why this is unhittable:
1. simulation time (simtime): DT shifts simtime forward artificially
2. Backtrack Records: server stores entity positions over time for lag compensation
3. shot registration: when simtime is ahead of the shot time, backtrack records get skipped and your shot will be unregistered because for server theres nothing there!

so all "Corsa's" or other predictions is a scam
out of context so y'all will know other projects of those skids:

(Corsa resolver) is a total scam im pretty sure he turned on force bodyyaw 59 degress in a playerlist in gamesense so it will ALWAYS miss head imagine thinking that your resolver is better than gs resolver and selling it (imagine thinking cheat for 500 dollars cant resolve ts)
basic bruteforce will be 1000x better than broken build free 2 times persona gs starts to gosh up byaw if ur fps is less than 100/ping is more than 10 AND gs' resolver is enabled
 
ur ping is prob like 9
ping doesnt do much tho, like i have 25-30 ping on de servers, but no ty, im not playing on pdf's server (femboy supremacy)
so i play on ru servers on like 80 ms, i hit every lc. the much difference is about peeking, and risky situations. because of ping, i like to miss to death (ez fix; dont push with 10 hp on a 100hp guy on 50+ ms XD)
 
when someone starts to shift tickbase and gradually charge it, the simtime stays frozen for about ~14 or how much they charged during shifting. the server never creates valid backtrackable records for shifted ticks
Charging just banks credits in m_nMovementTicksForUserCmdProcessingRemaining while we stop sending for 14 ticks, but once we move around charged we run 1-tick fakelag so simtime advances normally on every send and creates 100% valid backtrack records, otherwise AdjustPlayerTimeBase would flag too_slow_limit and snap our tickbase right back forward

cstrike15_src-2019->game/server/player.cpp#L3443:
Expand Collapse Copy
void CBasePlayer::PhysicsSimulate( void )
{
    // ...
    if ( m_nSimulationTick == gpGlobals->tickcount )
    {
        return;
    }
    m_nSimulationTick = gpGlobals->tickcount;

    // Grant the client some time buffer to execute user commands
    m_nMovementTicksForUserCmdProcessingRemaining++;

    int simulation_ticks = DetermineSimulationTicks();

    if ( simulation_ticks > 0 )
    {
        AdjustPlayerTimeBase( simulation_ticks );
    }

    // ...
    for ( int i = 0; i < commandsToRun; ++i )
    {
        PlayerRunCommand( &vecAvailCommands[ i ], MoveHelperServer() );
        // ...
    }
    // ...
}
cstrike15_src-2019->game/server/player.cpp#L3347:
Expand Collapse Copy
void CBasePlayer::AdjustPlayerTimeBase( int simulation_ticks )
{
    // ...
    else // multiplayer
    {
        // ...
        int    nIdealFinalTick = gpGlobals->tickcount + nCorrectionTicks;

        int nEstimatedFinalTick = m_nTickBase + simulation_ticks;

        // If client gets ahead of this, we'll need to correct
        int     too_fast_limit = nIdealFinalTick + nCorrectionTicks;
        // If client falls behind this, we'll also need to correct
        int     too_slow_limit = nIdealFinalTick - nCorrectionTicks;

        // See if we are too fast
        if ( nEstimatedFinalTick > too_fast_limit ||
             nEstimatedFinalTick < too_slow_limit )
        {
            int nCorrectedTick = nIdealFinalTick - simulation_ticks + gpGlobals->simTicksThisFrame;

            if ( pi )
            {
                pi->m_nTicksCorrected = nCorrectionTicks;
            }

            m_nTickBase = nCorrectedTick;
        }
    }
    // ...
}
the only valid tick they have after they charged is where they discharge and send the 14 ticks instantly back to the server
While forcing defensive, we don't only become valid when we discharge. The server forcibly snaps tickbase forward with AdjustPlayerTimeBase every ~16 ticks to catch up to real time, creating a completely valid, hittable frame.

cstrike15_src-2019->game/server/player_command.cpp#L318:
Expand Collapse Copy
void CPlayerMove::RunCommand ( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *moveHelper )
{
    const int nTicksAllowedForProcessing = player->ConsumeMovementTicksForUserCmdProcessing( 1 );
    if ( !player->IsBot() && !player->IsHLTV() && ( nTicksAllowedForProcessing < 1 ) )
    {
        // Make sure that the activity in command is erased because player cheated or dropped too many packets
        double dblWarningFrequencyThrottle = sv_maxusrcmdprocessticks_warning.GetFloat();
        if ( dblWarningFrequencyThrottle >= 0 )
        {
            // ...
            Warning( "sv_maxusrcmdprocessticks_warning at server tick %u: Ignored client %s usrcmd (more commands than available movement ticks)!\n", gpGlobals->tickcount, player->GetPlayerName() );
        }
        return; // Don't process this command
    }

    const float playerCurTime = player->m_nTickBase * TICK_INTERVAL;
    const float playerFrameTime = TICK_INTERVAL;

    // ...

    // Let the game do the movement.
    if ( !pVehicle )
    {
        VPROF( "g_pGameMovement->ProcessMovement()" );
        Assert( g_pGameMovement );
        g_pGameMovement->ProcessMovement( player, g_pMoveData );
    }
    else
    {
        VPROF( "pVehicle->ProcessMovement()" );
        pVehicle->ProcessMovement( player, g_pMoveData );
    }
           
    // ...

    FinishCommand( player );

    // Let time pass
    if ( gpGlobals->frametime > 0 )
    {
        player->m_nTickBase++;
    }
}
the server never records them
The server still records our ticks, but shots ghost cuz a -14 tick shift drops our simtime backwards (~-200 ms on 64tick) which then trips the server's 200ms sanity check (fabs(deltaTime) > 0.2f) and makes the server abort backtracking our hitboxes.
cstrike15_src-2019->game/server/player_lagcompensation.cpp#L205:
Expand Collapse Copy
void CLagCompensationManager::StartLagCompensation( CBasePlayer *player, LagCompensationType lagCompensationType, const Vector& weaponPos, const QAngle &weaponAngles, float weaponRange )
{
    // ...

    // correct is the amount of time we have to correct game time
    float correct = 0.0f;

    // Get true latency
    INetChannelInfo *nci = engine->GetPlayerNetInfo( player->entindex() );
    if ( nci )
    {
        // add network latency
        correct+= nci->GetLatency( FLOW_OUTGOING );
    }

    // NOTE:  do these computations in float time, not ticks, to avoid big roundoff error accumulations in the math
    // add view interpolation latency see C_BaseEntity::GetInterpolationAmount()
    correct += player->m_fLerpTime;
   
    // check bounds [0,sv_maxunlag]
    correct = clamp( correct, 0.0f, sv_maxunlag.GetFloat() );

    // correct tick send by player
    float flTargetTime = TICKS_TO_TIME( cmd->tick_count ) - player->m_fLerpTime;

    // calculate difference between tick sent by player and our latency based tick
    float deltaTime =  correct - ( gpGlobals->curtime - flTargetTime );

    if ( fabs( deltaTime ) > 0.2f )
    {
        // difference between cmd time and latency is too big > 200ms, use time correction based on latency
        // DevMsg("StartLagCompensation: delta too big (%.3f)\n", deltaTime );
        flTargetTime = gpGlobals->curtime - correct;
    }

    flTargetTime += TICKS_TO_TIME( sv_lagpushticks.GetInt() );

    // ...
}
if you teleport more that 64 units squared in 1 tick, the server considers it a big delta to track and erases all lagrecords and starts tracking you again after it erases them from the beginning. this means that all records you have are invalidated.
The server never erases our records, it returns false aka it just skips backtracking for that one single shot. Since lagcomp iterates newest to oldest, it only blocks older records behind the gap, but any newer records created after the break can still be backtracked completely fine.
cstrike15_src-2019->game/server/player_lagcompensation.cpp#L351:
Expand Collapse Copy
#define LAG_COMPENSATION_TELEPORTED_DISTANCE_SQR ( 64.0f * 64.0f )

// ...

bool CLagCompensationManager::BacktrackEntity( CBaseEntity *entity, float flTargetTime, LagRecordList *track, LagRecord *restore, LagRecord *change, bool wantsAnims )
{
    // ...

    Vector prevOrg = entity->GetAbsOrigin();
   
    // Walk context looking for any invalidating event
    while( track->IsValidIndex(curr) )
    {
        // remember last record
        prevRecord = record;

        // get next record
        record = &track->Element( curr );

        if ( !(record->m_fFlags & LC_ALIVE) )
        {
            // entity must be alive, lost track
            return false;
        }

        Vector delta = record->m_vecOrigin - prevOrg;
        if ( delta.LengthSqr() > LAG_COMPENSATION_TELEPORTED_DISTANCE_SQR )
        {
            // lost track, too much difference
            return false;
        }

        // did we find a context smaller than target time ?
        if ( record->m_flSimulationTime <= flTargetTime )
            break; // hurra, stop

        prevOrg = record->m_vecOrigin;

        // go one step back
        curr = track->Next( curr );
    }

    // ...
}
 

Similar threads

Who has read this thread (Total: 0) in last 1 hours View details