From c6ae82b61159608097c4ba6446f472712c2fa623 Mon Sep 17 00:00:00 2001 From: Jonathan G Rennison Date: Fri, 1 Jul 2022 23:39:02 +0100 Subject: [PATCH] Fix 9ff161e4 boosting lookahead braking stats but not actual brake forces --- src/ground_vehicle.cpp | 4 ++-- src/openttd.cpp | 3 ++- src/saveload/vehicle_sl.cpp | 4 ++++ src/table/newgrf_debug_data.h | 4 ++-- src/train.h | 1 + src/train_cmd.cpp | 9 +++++++-- 6 files changed, 18 insertions(+), 7 deletions(-) diff --git a/src/ground_vehicle.cpp b/src/ground_vehicle.cpp index 688b14cb0e..8bc2ae05a5 100644 --- a/src/ground_vehicle.cpp +++ b/src/ground_vehicle.cpp @@ -226,7 +226,7 @@ GroundVehicleAcceleration GroundVehicle::GetAcceleration() } if (Type == VEH_TRAIN && Train::From(this)->UsingRealisticBraking()) { - braking_power += (Train::From(this)->gcache.cached_total_length * (int64)RBC_BRAKE_POWER_PER_LENGTH); + braking_power += (Train::From(this)->tcache.cached_braking_length * (int64)RBC_BRAKE_POWER_PER_LENGTH); } /* If power is 0 because of a breakdown, we make the force 0 if accelerating */ @@ -269,7 +269,7 @@ GroundVehicleAcceleration GroundVehicle::GetAcceleration() /* Assume that every part of a train is braked, not just the engine. * Exceptionally heavy freight trains should still have a sensible braking distance. * The total braking force is generally larger than the total tractive force. */ - braking_accel = ClampToI32((-braking_force - resistance - (Train::From(this)->gcache.cached_total_length * (int64)RBC_BRAKE_FORCE_PER_LENGTH)) / (mass * 4)); + braking_accel = ClampToI32((-braking_force - resistance - (Train::From(this)->tcache.cached_braking_length * (int64)RBC_BRAKE_FORCE_PER_LENGTH)) / (mass * 4)); /* Defensive driving: prevent ridiculously fast deceleration. * -130 corresponds to a braking distance of about 6.2 tiles from 160 km/h. */ diff --git a/src/openttd.cpp b/src/openttd.cpp index 05bb2d4622..02629367f2 100644 --- a/src/openttd.cpp +++ b/src/openttd.cpp @@ -1695,12 +1695,13 @@ void CheckCaches(bool force_check, std::function log, CheckC print_gv_cache_diff("train", gro_cache[length], Train::From(u)->gcache); } if (memcmp(&tra_cache[length], &Train::From(u)->tcache, sizeof(TrainCache)) != 0) { - CCLOGV("train cache mismatch: %c%c%c%c%c%c%c%c%c%c", + CCLOGV("train cache mismatch: %c%c%c%c%c%c%c%c%c%c%c", tra_cache[length].cached_override != Train::From(u)->tcache.cached_override ? 'o' : '-', tra_cache[length].cached_curve_speed_mod != Train::From(u)->tcache.cached_curve_speed_mod ? 'C' : '-', tra_cache[length].cached_tflags != Train::From(u)->tcache.cached_tflags ? 'f' : '-', tra_cache[length].cached_num_engines != Train::From(u)->tcache.cached_num_engines ? 'e' : '-', tra_cache[length].cached_centre_mass != Train::From(u)->tcache.cached_centre_mass ? 'm' : '-', + tra_cache[length].cached_braking_length != Train::From(u)->tcache.cached_braking_length ? 'b' : '-', tra_cache[length].cached_veh_weight != Train::From(u)->tcache.cached_veh_weight ? 'w' : '-', tra_cache[length].cached_uncapped_decel != Train::From(u)->tcache.cached_uncapped_decel ? 'D' : '-', tra_cache[length].cached_deceleration != Train::From(u)->tcache.cached_deceleration ? 'd' : '-', diff --git a/src/saveload/vehicle_sl.cpp b/src/saveload/vehicle_sl.cpp index d61158266a..6a82e20e92 100644 --- a/src/saveload/vehicle_sl.cpp +++ b/src/saveload/vehicle_sl.cpp @@ -1137,6 +1137,7 @@ struct train_venc { uint8 cached_tflags; uint8 cached_num_engines; uint16 cached_centre_mass; + uint16 cached_braking_length; uint16 cached_veh_weight; uint16 cached_uncapped_decel; uint8 cached_deceleration; @@ -1206,6 +1207,7 @@ void Save_VENC() SlWriteByte(t->tcache.cached_tflags); SlWriteByte(t->tcache.cached_num_engines); SlWriteUint16(t->tcache.cached_centre_mass); + SlWriteUint16(t->tcache.cached_braking_length); SlWriteUint16(t->tcache.cached_veh_weight); SlWriteUint16(t->tcache.cached_uncapped_decel); SlWriteByte(t->tcache.cached_deceleration); @@ -1268,6 +1270,7 @@ void Load_VENC() venc.cached_tflags = SlReadByte(); venc.cached_num_engines = SlReadByte(); venc.cached_centre_mass = SlReadUint16(); + venc.cached_braking_length = SlReadUint16(); venc.cached_veh_weight = SlReadUint16(); venc.cached_uncapped_decel = SlReadUint16(); venc.cached_deceleration = SlReadByte(); @@ -1356,6 +1359,7 @@ void SlProcessVENC() CheckVehicleVENCProp(t->tcache.cached_tflags, (TrainCacheFlags)venc.cached_tflags, t, "cached_tflags"); CheckVehicleVENCProp(t->tcache.cached_num_engines, venc.cached_num_engines, t, "cached_num_engines"); CheckVehicleVENCProp(t->tcache.cached_centre_mass, venc.cached_centre_mass, t, "cached_centre_mass"); + CheckVehicleVENCProp(t->tcache.cached_braking_length, venc.cached_braking_length, t, "cached_braking_length"); CheckVehicleVENCProp(t->tcache.cached_veh_weight, venc.cached_veh_weight, t, "cached_veh_weight"); CheckVehicleVENCProp(t->tcache.cached_uncapped_decel, venc.cached_uncapped_decel, t, "cached_uncapped_decel"); CheckVehicleVENCProp(t->tcache.cached_deceleration, venc.cached_deceleration, t, "cached_deceleration"); diff --git a/src/table/newgrf_debug_data.h b/src/table/newgrf_debug_data.h index fcc480b3b3..b6a2e9f780 100644 --- a/src/table/newgrf_debug_data.h +++ b/src/table/newgrf_debug_data.h @@ -187,8 +187,8 @@ class NIHVehicle : public NIHelper { seprintf(buffer, lastof(buffer), " T cache: tilt: %d, speed varies by railtype: %d, curve speed mod: %d, engines: %u", (t->tcache.cached_tflags & TCF_TILT) ? 1 : 0, (t->tcache.cached_tflags & TCF_SPD_RAILTYPE) ? 1 : 0, t->tcache.cached_curve_speed_mod, t->tcache.cached_num_engines); output.print(buffer); - seprintf(buffer, lastof(buffer), " T cache: RL braking: %d, decel: %u, uncapped decel: %u, centre mass: %u", - (t->UsingRealisticBraking()) ? 1 : 0, t->tcache.cached_deceleration, t->tcache.cached_uncapped_decel, t->tcache.cached_centre_mass); + seprintf(buffer, lastof(buffer), " T cache: RL braking: %d, decel: %u, uncapped decel: %u, centre mass: %u, braking length: %u", + (t->UsingRealisticBraking()) ? 1 : 0, t->tcache.cached_deceleration, t->tcache.cached_uncapped_decel, t->tcache.cached_centre_mass, t->tcache.cached_braking_length); output.print(buffer); seprintf(buffer, lastof(buffer), " T cache: veh weight: %u, user data: %u, curve speed: %u", t->tcache.cached_veh_weight, t->tcache.user_def_data, t->tcache.cached_max_curve_speed); diff --git a/src/train.h b/src/train.h index 197bc2552b..c6cebeb728 100644 --- a/src/train.h +++ b/src/train.h @@ -116,6 +116,7 @@ struct TrainCache { TrainCacheFlags cached_tflags;///< train cached flags uint8 cached_num_engines; ///< total number of engines, including rear ends of multiheaded engines uint16 cached_centre_mass; ///< Cached position of the centre of mass, from the front + uint16 cached_braking_length; ///< Cached effective length used for deceleration force and power purposes uint16 cached_veh_weight; ///< Cached individual vehicle weight uint16 cached_uncapped_decel; ///< Uncapped cached deceleration for realistic braking lookahead purposes uint8 cached_deceleration; ///< Cached deceleration for realistic braking lookahead purposes diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp index fb07f853f8..fc975a0ae8 100644 --- a/src/train_cmd.cpp +++ b/src/train_cmd.cpp @@ -418,6 +418,7 @@ void Train::ConsistChanged(ConsistChangeFlags allowed_changes) u->gcache.cached_total_length = 0; u->tcache.cached_num_engines = 0; u->tcache.cached_centre_mass = 0; + u->tcache.cached_braking_length = 0; u->tcache.cached_deceleration = 0; u->tcache.cached_uncapped_decel = 0; u->tcache.cached_tflags = TCF_NONE; @@ -853,8 +854,8 @@ static int GetRealisticBrakingSpeedForDistance(const TrainDecelerationStats &sta /* calculate speed at which braking would be sufficient */ uint weight = stats.t->gcache.cached_weight; - int64 power_w = (stats.t->gcache.cached_power * 746ll) + (stats.t->gcache.cached_total_length * (int64)RBC_BRAKE_POWER_PER_LENGTH); - int64 min_braking_force = (stats.t->gcache.cached_total_length * (int64)RBC_BRAKE_FORCE_PER_LENGTH) + stats.t->gcache.cached_axle_resistance + (weight * 16); + int64 power_w = (stats.t->gcache.cached_power * 746ll) + (stats.t->tcache.cached_braking_length * (int64)RBC_BRAKE_POWER_PER_LENGTH); + int64 min_braking_force = (stats.t->tcache.cached_braking_length * (int64)RBC_BRAKE_FORCE_PER_LENGTH) + stats.t->gcache.cached_axle_resistance + (weight * 16); /* F = (7/8) * (F_min + ((power_w * 18) / (5 * v))) * v^2 = sloped_ke + F * s / (4 * m) @@ -1166,6 +1167,7 @@ void Train::UpdateAcceleration() default: NOT_REACHED(); case AM_ORIGINAL: this->tcache.cached_uncapped_decel = this->tcache.cached_deceleration = Clamp((this->acceleration * 7) / 2, 1, 200); + this->tcache.cached_braking_length = this->gcache.cached_total_length; break; case AM_REALISTIC: { @@ -1182,7 +1184,9 @@ void Train::UpdateAcceleration() length += ((u->gcache.cached_veh_length * adjust) + 1) / 2; } } + length = Clamp(length, 0, UINT16_MAX); } + this->tcache.cached_braking_length = length; int64 min_braking_force = (int64)length * (int64)RBC_BRAKE_FORCE_PER_LENGTH; if (!maglev) { @@ -1233,6 +1237,7 @@ void Train::UpdateAcceleration() this->tcache.cached_tflags &= ~TCF_RL_BRAKING; this->tcache.cached_deceleration = 0; this->tcache.cached_uncapped_decel = 0; + this->tcache.cached_braking_length = this->gcache.cached_total_length; } if (_settings_game.vehicle.improved_breakdowns) {