Source Apex Legends — External Player Velocity Reconstruction

[byte_corvus]

Anyone else sick of seeing zeroed-out velocity values when dumping entity data externally?

If you are working on an external project for Apex, you have probably noticed that the game engine isn't exactly helpful when you are trying to grab live velocity data for players or AI entities. Relying on internal structures often fails when you are stuck outside the process boundary.

I have been using a manual reconstruction method that is significantly more reliable. Instead of chasing unreliable offsets, you calculate the delta between origin snapshots per engine tick.

The Approach

Personally, I am using

globalvars->tick_count

at

0x40

, but depending on your base, grabbing the current prediction tick might be cleaner. The logic is dead simple: you map the entity index to its last known position and multiply the change by the tick interval.

Implementation

void prediction::on_engine_tick( c_global_vars* global_vars, std::int32_t tick_delta )
{
    for ( const c_cached_entity& cache_entry : sdk::get_all_players( ) )
    {
        c_entity* entity = cache_entry.entity;
        if ( !entity )
            continue;

        c_vector_3f origin = entity->get_origin( );
        if ( origin.is_zero( ) )
            continue;

        std::int32_t index = entity->get_index( );
        c_vector_3f& last = g_position_map[ index ];
        g_velocity_map[ index ] = ( origin - last ) * ( 1.0f / global_vars->get_tick_interval( ) );

        last = origin;
    }
}

Troubleshooting & Notes

Spoiler: Technical Caveats

1. Ensure your tick interval is synced correctly with the engine clock or you will get jittery velocity spikes.
2. If you notice massive latency in the reconstruction, double-check your memory read cycle times. If you are not using a DMA setup, you are bound by your local thread sync.
3. This approach assumes your entity iteration is stable. If you are catching null entities, make sure your cache update is locked.

While others are trying to hook the client to get precise vectors and risking immediate detection from anti-cheat integrity checks, this method keeps your external footprint clean. It is simple math, but it gets the job done for smooth ESP predictions.

Who has managed to refine this further for jitter-free aim prediction?