Shift Bar / Shift Indicator upshift thresholds are unreachable in Forza Horizon 6

[HBbrody]

Version: Race Element 2.7.1.4
Game: Forza Horizon 6
HUDs: Shift Bar, Shift Indicator

Description

In Forza, EngineMaxRpm from the Data Out packet is the top of the in-game tachometer scale, not the rev limiter. The engine hits the limiter well below it, so the Early and Redline color states never trigger and Redline Flash never fires.

GetUpShiftPercentages() in ShiftBarOverlay.cs gates the real shift point behind a game whitelist:

Game upshiftSupportedGames = Game.RaceRoom | Game.iRacing;

Outside that set the configured percentages are applied to MaxRpm directly, which in Forza means percentages of a value the engine never reaches. ShiftIndicatorOverlay.UpdateColorDictionary() has the same pattern with an even narrower check (Game.RaceRoom only, and no divide-by-zero guard).

Measurements

Car: Fiat 124 Spider Abarth. Settings: Visible Rpm Amount 4000, Early 93.000, Redline 97.300, Redline Marker On.

From one frame with the Shift RPM HUD enabled:

• Shift RPM HUD: 7234
• Shift Bar fill: 78.4% of bar width
• Redline marker: 94.5% of bar width

Solving GetAdjustedPercentToHideRpm backwards for max rpm, with a 4000 rpm window:

• from fill: 7234 - (M - 4000) = 0.784 * 4000 gives M = 8098
• from marker: 0.973 * M - (M - 4000) = 0.945 * 4000 gives M = 8148

Both agree with the tachometer scale, which ends at 8. The bar scales correctly against EngineMaxRpm ~8100. The thresholds land at 7533 and 7881, and the engine limits below both, so the bar stays in the normal color for the whole rev range.

Suggested fix

Forza does not send a shift point. The packet only carries EngineMaxRpm, EngineIdleRpm and CurrentEngineRpm (ForzaUDP/ForzaMotorsportsData.cs), and ForzaDataProvider.cs leaves localCar.Engine.ShiftUpRpm at 0, so adding Forza to the whitelist alone would fail the upshiftRpm > 0 guard.

The limiter can be derived instead: track the peak observed CurrentEngineRpm for the current car and publish it as ShiftUpRpm. The existing branch in GetUpShiftPercentages() then works unchanged, with no new user-facing settings.

Notes on that approach:

• Reset the peak when EngineMaxRpm changes, which already signals a car change and is what MaxRpmDetectionJob watches for.
• The peak needs a few seconds of driving to converge. Until then, falling back to the configured percentages is reasonable.

Also

• ShiftIndicatorOverlay.UpdateColorDictionary() needs the same treatment. The logic is duplicated in both HUDs and could be shared.
• The Draw Upshift Data panel in ShiftBarOverlay.Render() computes _model.MaxRpm * _config.Upshift.EarlyPercentage / 100d directly instead of calling GetUpShiftPercentages(), so on RaceRoom and iRacing the panel reports different numbers than the bar actually uses.
• CVT vehicles (for example the Polaris RZR in FH6) hold rpm roughly constant under acceleration and never approach the limiter at all. No threshold setting helps there. Mentioning it only in case it affects how a learned peak is validated.

[RiddleTime]

How will you handle an automated system when the driver is shifting manually?

[HBbrody]

Yeah, that kills the version I described. If I just take the highest rpm I've seen, then for someone who upshifts early the reference ends up being wherever they happen to shift, and the HUD just agrees with their existing habit. The 60%-of-scale check I put in wouldn't catch that either, it would accept the number as valid.

So the peak is the wrong thing to look at. Better to look for the limiter itself: full throttle, gear unchanged, rpm stops climbing. That only happens in one place.

private const int PlateauSamples = 5;
private const float MinLimiterFractionOfScale = 0.5f;
private const float FullThrottle = 0.98f;

private int _confirmedLimiterRpm;
private int _scaleMaxRpm = -1;
private int _lastGear = int.MinValue;
private int _lastRpm;
private int _plateauSamples;
private bool _wasRaceOn;

private int TrackShiftUpRpm(in ForzaMotorsportsData.SledData sled, in ForzaMotorsportsData.DashData dash)
{
    int scaleMaxRpm = (int)sled.EngineMaxRpm;
    if (scaleMaxRpm <= 0) return 0;

    bool isRaceOn = sled.IsRaceOn > 0;
    if (scaleMaxRpm != _scaleMaxRpm || (isRaceOn && !_wasRaceOn))
    {
        _scaleMaxRpm = scaleMaxRpm;
        _confirmedLimiterRpm = 0;
        _plateauSamples = 0;
    }
    _wasRaceOn = isRaceOn;

    int rpm = (int)sled.CurrentEngineRpm;
    int gear = dash.Gear;
    float throttle = dash.Accelerator / 255f;

    // the limiter is the only place where rpm stops climbing under full throttle in a fixed gear
    bool shouldBeClimbing = throttle >= FullThrottle
        && gear == _lastGear
        && gear > 0
        && rpm >= scaleMaxRpm * MinLimiterFractionOfScale;

    _plateauSamples = shouldBeClimbing && rpm <= _lastRpm ? _plateauSamples + 1 : 0;

    if (_plateauSamples >= PlateauSamples && rpm > _confirmedLimiterRpm)
        _confirmedLimiterRpm = rpm;

    _lastGear = gear;
    _lastRpm = rpm;

    return _confirmedLimiterRpm;
}

Which answers the manual case: no limiter hit, no value, method returns 0, the upshiftRpm > 0 guard fails and the HUD stays on the configured percentages like it does now. Shifting early can't poison the number, it can only fail to produce one. Reset conditions unchanged, EngineMaxRpm moving for an engine swap and an IsRaceOn transition for a possible tune change.

Where it's still weak:

• top gear at Vmax gives a plateau too, below the limiter. Hence keeping the highest confirmed plateau rather than the latest one, a bad Vmax reading can only sit too low and gets overwritten the first time the car is revved out in a lower gear
• CVT cars never plateau at all, they'd stay on the fallback forever
• someone who never revs a car out gets nothing

For those last two, a plain Rev Limiter Percentage setting defaulting to 100 and overriding the detected value would cover it without depending on how anyone drives.

None of this is airtight. But right now on Forza the thresholds sit above what the engine can reach, so the colours and the redline flash never fire at all, which is worse than an estimate that's occasionally off.