Source APB Reloaded — Deprecated Gun Spread Prediction Logic

[byte_corvus]

Spent some time digging through old repo scraps. It seems the devs finally addressed the spread system after long denying it was ever broken, forcing a return to the old 100% RNG model which is just peak design, right?

Since the implementation is now deprecated due to backend changes, I am dropping the core logic I used to maintain about 80% spread prediction. It was solid while it lasted for those who prefer semi-predictable gunplay over coin-flipping your shots.

/// <summary>
/// Calculates the value between -1.0 and 1.0 depending on camera Yaw Rotation for NSEW in world
/// </summary>
/// <param name="yaw">degrees</param>
/// <returns></returns>
float APB_RecoilPredictionDirection(float yaw)
{
    // Normalize yaw to [0, 360)
    yaw = fmodf(yaw, 360.0f);
    if (yaw < 0.0f) yaw += 360.0f;
 
    // Determine the quadrant and calculate the output
    if (yaw <= 90.0f) {
        // 0° to 90°: Constant 1.0f (right)
        return 1.0f;
    }
    else if (yaw <= 180.0f) {
        // 90° to 180°: Linearly interpolate from 1.0f to -1.0f
        return 1.0f - 2.0f * ((yaw - 90.0f) / 90.0f); // Slope: (1 - (-1)) / 90 = -2/90
    }
    else if (yaw <= 270.0f) {
        // 180° to 270°: Constant -1.0f (left)
        return -1.0f;
    }
    else {
        // 270° to 360°: Linearly interpolate from -1.0f to 1.0f
        return -1.0f + 2.0f * ((yaw - 270.0f) / 90.0f); // Slope: (1 - (-1)) / 90 = 2/90
    }
}
 
/// <summary>
/// Predicts the offset to where the bullets are supose to go (Currently Deprecated)
/// </summary>
/// <param name="x">half of the screen width</param>
/// <param name="y">half of the screen height</param>
/// <returns></returns>
SDK::Unreal::Vector2 getRecoilPredMiddleScreen(float x, float y)
{
    // Normalize the yaw direction to a value between -1 and 1
    auto cameraData = SDK::Unreal::Camera::GetCameraEntry();
    float direction = APB_RecoilPredictionDirection(URadiansToDegree(URotationToRadians(cameraData.Rotation.Yaw)));
    // Map direction to an angle between -45 and +45 degrees
    float angle_degrees = direction * 45.0f; // -1 maps to -45°, 1 maps to +45°
    float angle_radians = angle_degrees * (M_PI / 180.0f); // Convert to radians
 
    // Define the radius, scaled by crosshair_size that is read from memory
    // using 0.5f as initial crosshair_radius_scale works quite good
    float scale = Cached.Game_HUD_CrosshairSize.load(); // gets current crosshair size (1.0 is default size)
    if (scale > 3)
        scale = 3;
    float radius = 0.01f * (scale / Configuration.crosshair_radius_scale.load()) * y; // Scale radius based on y and crosshair_size
 
    // Bottom of the circle is at 90° in standard polar coordinates
    // Add 90° to start at the bottom, then adjust by angle_radians
    float total_angle_radians = (-90.0f * (M_PI / 180.0f)) + angle_radians;
 
    // Calculate offsets using polar coordinates
    float offset_x = radius * cos(total_angle_radians); // x = r * cos(θ)
    float offset_y = -radius * sin(total_angle_radians); // y = -r * sin(θ) (negative due to screen Y-axis pointing down)
    // Return the new position by adding offsets to the input x, y
    return SDK::Unreal::Vector2(x + offset_x, y + offset_y);
}

Spoiler: Technical Implementation Details

The logic hinges on calculating the camera yaw to determine the directional quadrant, then mapping it to an offset range.

1. Normalized yaw normalization to [0, 360) range.
2. Used linear interpolation for quadrant transitions.
3. Derived bullet offset using polar coordinates, scaling based on the cached crosshair size in memory.
4. The radius scaling factor was originally tuned at 0.5f, though you can adjust that based on specific weapon recoil patterns if you're trying to revive this for a private build.

It is effectively a legacy snippet now, but the geometry logic remains a decent reference for anyone reverse-engineering similar Unreal Engine 3 based shooters where spread is tied to camera rotation.

Anyone else working on a custom spread predictor for this engine version?