From 292092a7aa63184f62c7ff619b7ea3c2385cceff Mon Sep 17 00:00:00 2001 From: pwarszawski Date: Sat, 7 Nov 2026 21:40:02 +0100 Subject: [PATCH] AI braking: take care of the Sonar remarks on the new braking code No change in what the AI does; only the structure of the code that came in with the braking changes: - S107: shaped_braking_demand() takes the consist brake table as a struct instead of four separate parameters; its lambdas capture explicitly. - S3358: brake_response_horizon() picks the BrakeDelay entry without a nested conditional operator. - S5276: the speed passed to braking_distance_multiplier() is converted to float explicitly, as it was implicitly before. - S134: the stop case of the proximity range is an else-if of its own, and its body a method of its own, adjust_desired_speed_for_final_approach(), with early returns instead of nested ifs. The cargo train threshold push is a conditional subtraction instead of a nested if. - S3776: pick_optimal_speed() hands the uncoupling stages and the uphill stand to set_velocity_for_uncoupling() and hold_train_coming_to_stand_uphill(). --- vehicle/Driver.cpp | 257 ++++++++++++++++++++++++--------------------- vehicle/Driver.h | 3 + 2 files changed, 141 insertions(+), 119 deletions(-) diff --git a/vehicle/Driver.cpp b/vehicle/Driver.cpp index 303560e98..cbdd97c62 100644 --- a/vehicle/Driver.cpp +++ b/vehicle/Driver.cpp @@ -7239,6 +7239,59 @@ TController::handle_orders() { UpdateChangeDirection(); } +// the stages of uncoupling: each one sets the speed for the next +void +TController::set_velocity_for_uncoupling() { + + if( iVehicleCount < 0 ) { + // 4th stage: restore initial direction + if( ( iDrivigFlags & movePress ) != 0 ) { + SetVelocity( 0, 0, stopJoin ); + } + return; + } + // 3rd stage: compress buffers and uncouple + if( ( iDrivigFlags & movePress ) != 0 && iDirection == iDirectionOrder ) { + SetVelocity( 2, 0 ); // jazda w ustawionym kierunku z prędkością 2 + return; + } + // 1st stage: bring it to stop + // 2nd stage: apply consist brakes and change direction + SetVelocity( 0, 0, stopJoin ); +} + +// uphill, the gradient alone brings a slow train to a stand within metres, far sooner than a released +// brake applies; so the train brake goes on while the train is coming to a stand, stays on while it +// stands, and is applied for real if the train has started to roll back +void +TController::hold_train_coming_to_stand_uphill() { + + if( ( false == is_train() ) + || ( ( OrderCurrentGet() & Obey_train ) == 0 ) + || ( VelNext != 0.0 ) + || ( ActualProximityDist > fMaxProximityDist ) + || ( fAccGravity >= -0.025 ) ) { + return; + } + auto const vel { DirectionalVel() }; + if( std::abs( vel ) < EU07_AI_NOMOVEMENT ) { + VelDesired = 0.0; + AccDesired = std::min( AccDesired, EU07_AI_NOACCELERATION ); + return; + } + if( ( vel < 0.0 ) + || ( ( vel < 5.0 ) && ( AccDesired < 0.0 ) ) + // rolling to a stand on the gradient alone, the brake has to be on its way before the train stops: + // once the time left to the stand is no longer than half of what the brake takes to apply, apply it; any + // sooner and the brake takes off more of the distance than the stop was planned with + || ( ( BrakeSystem == TBrakeSystem::Pneumatic ) + && ( vel / 3.6 / -fAccGravity <= 0.5 * brake_response_horizon( mvOccupied, BrakeSystem, 1.0, fBrake_a0[ 0 ] ) ) ) ) { + // the gradient alone already slows the train down nearly this much; ask for enough on top of it that + // the brake is applied for sure, not held back by the margin against small corrections + AccDesired = std::min( AccDesired, fAccGravity - std::max( 0.15, fBrake_a0[ 0 ] ) - brake_increase_margin() ); + } +} + void TController::pick_optimal_speed( double const Range ) { @@ -7274,23 +7327,7 @@ TController::pick_optimal_speed( double const Range ) { } // uncoupling mode changes velocity/acceleration between stages if( ( OrderCurrentGet() & Disconnect ) != 0 ) { - if( iVehicleCount >= 0 ) { - // 3rd stage: compress buffers and uncouple - if( (iDrivigFlags & movePress) != 0 && iDirection == iDirectionOrder ) { - SetVelocity( 2, 0 ); // jazda w ustawionym kierunku z prędkością 2 - } - // 1st stage: bring it to stop - // 2nd stage: apply consist brakes and change direction - else { - SetVelocity( 0, 0, stopJoin ); - } - } - else { - // 4th stage: restore initial direction - if( ( iDrivigFlags & movePress ) != 0 ) { - SetVelocity( 0, 0, stopJoin ); - } - } + set_velocity_for_uncoupling(); } VelLimitLastDist = { VelDesired, -1 }; @@ -7343,32 +7380,8 @@ TController::pick_optimal_speed( double const Range ) { is_car() ? -2.0 : -0.9, is_car() ? 2.0 : 0.9 ); - if( is_train() - && ( ( OrderCurrentGet() & Obey_train ) != 0 ) - && ( VelNext == 0.0 ) - && ( ActualProximityDist <= fMaxProximityDist ) - && ( fAccGravity < -0.025 ) ) { - // uphill, the gradient alone brings a slow train to a stand within metres, far sooner than a released - // brake applies; so the train brake goes on while the train is coming to a stand, stays on while it - // stands, and is applied for real if the train has started to roll back. done last, so that none of - // the adjustments above, made for a train moving forward, can undo it - auto const vel { DirectionalVel() }; - if( std::abs( vel ) < EU07_AI_NOMOVEMENT ) { - VelDesired = 0.0; - AccDesired = std::min( AccDesired, EU07_AI_NOACCELERATION ); - } - else if( ( vel < 0.0 ) - || ( ( vel < 5.0 ) && ( AccDesired < 0.0 ) ) - // rolling to a stand on the gradient alone, the brake has to be on its way before the train stops: - // once the time left to the stand is no longer than half of what the brake takes to apply, apply it; any - // sooner and the brake takes off more of the distance than the stop was planned with - || ( ( BrakeSystem == TBrakeSystem::Pneumatic ) - && ( vel / 3.6 / -fAccGravity <= 0.5 * brake_response_horizon( mvOccupied, BrakeSystem, 1.0, fBrake_a0[ 0 ] ) ) ) ) { - // the gradient alone already slows the train down nearly this much; ask for enough on top of it that - // the brake is applied for sure, not held back by the margin against small corrections - AccDesired = std::min( AccDesired, fAccGravity - std::max( 0.15, fBrake_a0[ 0 ] ) - brake_increase_margin() ); - } - } + // done last, so that none of the adjustments above, made for a train moving forward, can undo it + hold_train_coming_to_stand_uphill(); // if the route ahead is blocked we might need to head the other way check_route_behind( 1000 ); // NOTE: legacy scan range value @@ -7543,13 +7556,10 @@ brake_response_horizon( TMoverParameters const *Vehicle, TBrakeSystem const Brak auto horizon { ( 1.0 - Brakea0 ) * 30.0 / 3.6 }; if( Brakesystem == TBrakeSystem::Pneumatic ) { + // BrakeDelay holds the release and the application time in G, then the same two in P + auto const delays { Vehicle->BrakeDelayFlag > bdelay_G ? 0 : 2 }; auto const isrelease { Acceleration < 0.0 }; - horizon = std::max( - horizon, - 0.5 * ( - Vehicle->BrakeDelayFlag > bdelay_G ? - Vehicle->BrakeDelay[ isrelease ? 0 : 1 ] : - Vehicle->BrakeDelay[ isrelease ? 2 : 3 ] ) ); + horizon = std::max( horizon, 0.5 * Vehicle->BrakeDelay[ delays + ( isrelease ? 0 : 1 ) ] ); } return horizon; } @@ -7569,15 +7579,26 @@ uphill_coasting_speed( double const Distance, double const Gravity ) { // resultant acceleration [m/s2] to ask for now so that a steady application of the pneumatic brake takes the train // from Velocity down to Target [km/h] over Distance [m], with the brake force following the speed the way the // consist brake table says it does (cast iron blocks grip harder as the train slows) +struct consist_brake_table { + double const *a0; // deceleration at handle position 1, by speed + double const *a1; // deceleration added by each quarter of a position, by speed + int size; // entries, up to the vehicle's top speed + double vmax; // the vehicle's top speed [km/h] + + // deceleration [m/s2] of a full service application at Kmh + double full_braking( double const Kmh ) const { + auto const index { std::clamp( static_cast( size * Kmh / std::max( 1.0, vmax ) ), 1, size ) }; + return std::max( 0.01, a0[ index ] + 12.0 * a1[ index ] ); } +}; + static double shaped_braking_demand( double const Velocity, double const Target, double const Distance, double const Gravity, - double const Vmax, double const *Brakea0, double const *Brakea1, int const Tablesize ) { + consist_brake_table const &Table ) { - auto const fullbraking = [&]( double const Kmh ) { - auto const index { std::clamp( static_cast( Tablesize * Kmh / std::max( 1.0, Vmax ) ), 1, Tablesize ) }; - return std::max( 0.01, Brakea0[ index ] + 12.0 * Brakea1[ index ] ); }; - auto const travel = [&]( double const Ratio ) { + auto const fullbraking = [&Table]( double const Kmh ) { + return Table.full_braking( Kmh ); }; + auto const travel = [Velocity, Target, Gravity, &fullbraking]( double const Ratio ) { auto const steps { 24 }; auto const step { ( Velocity - Target ) / steps }; auto distance { 0.0 }; @@ -7603,6 +7624,53 @@ shaped_braking_demand( return Gravity - high * fullbraking( Velocity ); } +// the final approach to a stop, inside the proximity range: Vel is the present speed in the direction of travel +void +TController::adjust_desired_speed_for_final_approach( double const Vel ) { + + if( ( mvOccupied->CategoryFlag & 1 ) == 0 ) { + // for cars (and others) coast at low speed until we hit min proximity range + VelDesired = min_speed( VelDesired, 5.0 ); + return; + } + // trains + if( ( OrderCurrentGet() & ( Shunt | Connect ) ) + && ( Obstacle.distance < 50 ) ) { + // crude detection of edge case, if approaching another vehicle coast slowly until min distance + // this should allow to bunch up trainsets more on sidings + VelDesired = min_speed( 5.0, VelDesired ); + return; + } + // hamowanie tak, aby stanąć + if( ( OrderCurrentGet() & Obey_train ) == 0 ) { + VelDesired = VelNext; + AccDesired = ( VelNext * VelNext - Vel * Vel ) / ( 25.92 * ( ActualProximityDist + 0.1 - 0.5*fMinProximityDist ) ); + AccDesired = std::min( AccDesired, fAccThreshold ); + return; + } + // a train keeps its desired speed until the lower edge of the stopping window (a desired + // speed of 0 here asks for hard braking whatever the distance left), aims at the middle + // of the window, and asks only for what that takes + auto const stoppingroom { std::max( 0.5, ActualProximityDist - stopping_margin() ) }; + AccDesired = ( + BrakeSystem == TBrakeSystem::Pneumatic ? + // cast iron blocks grip harder as the train comes to a stand + shaped_braking_demand( + Vel, VelNext, stoppingroom, fAccGravity, + { fBrake_a0, fBrake_a1, BrakeAccTableSize, mvOccupied->Vmax } ) : + ( VelNext * VelNext - Vel * Vel ) / ( 25.92 * stoppingroom ) ); + if( ( fAccGravity < -0.025 ) + && ( AccDesired >= fAccGravity - 0.001 ) // no brake needed at all + && ( false == uphill_brake_committed( Vel ) ) + && ( ActualProximityDist - uphill_stopping_distance( Vel, fAccGravity ) > stopping_margin() ) ) { + // uphill the gradient alone would bring the train to a stand short of the + // middle of the stopping window; keep it rolling at the present speed until that changes, + // but no faster than the gradient alone can take off by the middle of the window + AccDesired = std::min( 0.0, AccPreferred ); + VelDesired = min_speed( VelDesired, uphill_coasting_speed( ActualProximityDist - stopping_margin(), fAccGravity ) ); + } +} + void TController::adjust_desired_speed_for_target_speed( double const Range ) { // ustalanie zadanego przyspieszenia @@ -7634,65 +7702,20 @@ TController::adjust_desired_speed_for_target_speed( double const Range ) { AccDesired = AccPreferred; } } + else if( ( ActualProximityDist > fMinProximityDist ) + // only a stop has a final approach of its own inside the proximity range; a lower speed ahead + // keeps the braking curve below right up to where it begins, or the train would stop braking + // (and even take power) that far out + && ( VelNext == 0.0 ) + && ( ActualProximityDist < fMaxProximityDist ) ) { + // jedzie szybciej, niż trzeba na końcu ActualProximityDist, ale jeszcze jest daleko + // jak minął już maksymalny dystans po prostu hamuj (niski stopień) + // ma stanąć, a jest w drodze hamowania albo ma jechać + adjust_desired_speed_for_final_approach( vel ); + AccDesired = std::min( AccDesired, AccPreferred ); + } else if (ActualProximityDist > fMinProximityDist) { // jedzie szybciej, niż trzeba na końcu ActualProximityDist, ale jeszcze jest daleko - // only a stop has a final approach of its own inside the proximity range; a lower speed ahead - // keeps the braking curve below right up to where it begins, or the train would stop braking - // (and even take power) that far out - if( ( VelNext == 0.0 ) && ( ActualProximityDist < fMaxProximityDist ) ) { - // jak minął już maksymalny dystans po prostu hamuj (niski stopień) - // ma stanąć, a jest w drodze hamowania albo ma jechać -/* - VelDesired = min_speed( VelDesired, VelNext ); -*/ - if( VelNext == 0.0 ) { - if( mvOccupied->CategoryFlag & 1 ) { - // trains - if( OrderCurrentGet() & (Shunt | Connect) - && Obstacle.distance < 50 ) { - // crude detection of edge case, if approaching another vehicle coast slowly until min distance - // this should allow to bunch up trainsets more on sidings - VelDesired = min_speed( 5.0, VelDesired ); - } - else { - // hamowanie tak, aby stanąć - if( ( OrderCurrentGet() & Obey_train ) == 0 ) { - VelDesired = VelNext; - AccDesired = ( VelNext * VelNext - vel * vel ) / ( 25.92 * ( ActualProximityDist + 0.1 - 0.5*fMinProximityDist ) ); - AccDesired = std::min( AccDesired, fAccThreshold ); - } - else { - // a train keeps its desired speed until the lower edge of the stopping window (a desired - // speed of 0 here asks for hard braking whatever the distance left), aims at the middle - // of the window, and asks only for what that takes - auto const stoppingroom { std::max( 0.5, ActualProximityDist - stopping_margin() ) }; - AccDesired = ( - BrakeSystem == TBrakeSystem::Pneumatic ? - // cast iron blocks grip harder as the train comes to a stand - shaped_braking_demand( - vel, VelNext, stoppingroom, fAccGravity, - mvOccupied->Vmax, fBrake_a0, fBrake_a1, BrakeAccTableSize ) : - ( VelNext * VelNext - vel * vel ) / ( 25.92 * stoppingroom ) ); - if( ( fAccGravity < -0.025 ) - && ( AccDesired >= fAccGravity - 0.001 ) // no brake needed at all - && ( false == uphill_brake_committed( vel ) ) - && ( ActualProximityDist - uphill_stopping_distance( vel, fAccGravity ) > stopping_margin() ) ) { - // uphill the gradient alone would bring the train to a stand short of the - // middle of the stopping window; keep it rolling at the present speed until that changes, - // but no faster than the gradient alone can take off by the middle of the window - AccDesired = std::min( 0.0, AccPreferred ); - VelDesired = min_speed( VelDesired, uphill_coasting_speed( ActualProximityDist - stopping_margin(), fAccGravity ) ); - } - } - } - } - else { - // for cars (and others) coast at low speed until we hit min proximity range - VelDesired = min_speed( VelDesired, 5.0 ); - } - } - } - else { // outside of max safe range AccDesired = AccPreferred; if( vel > min_speed( ActualProximityDist > 10.0 ? 10.0 : 5.0, VelDesired ) ) { @@ -7710,7 +7733,7 @@ TController::adjust_desired_speed_for_target_speed( double const Range ) { auto const brakingpointoffset = ( ( VelNext == 0.0 ) && is_train() && ( OrderCurrentGet() & Obey_train ) ? stopping_margin() : // the same stopping point as the final approach - VelNext * braking_distance_multiplier( VelNext ) ); + VelNext * braking_distance_multiplier( static_cast( VelNext ) ) ); // a pneumatic brake acts on the state the train will be in once it has responded; while the // train is still speeding up, plan the deceleration from there, so more is asked for at once auto velocity { vel }; @@ -7741,7 +7764,7 @@ TController::adjust_desired_speed_for_target_speed( double const Range ) { } deceleration = shaped_braking_demand( velocity, VelNext, room + 0.1 / 25.92, fAccGravity, - mvOccupied->Vmax, fBrake_a0, fBrake_a1, BrakeAccTableSize ); + { fBrake_a0, fBrake_a1, BrakeAccTableSize, mvOccupied->Vmax } ); } AccDesired = std::min( AccDesired, deceleration ); // najpierw hamuje mocniej, potem zluzuje if( vel > VelNext ) { @@ -7761,7 +7784,6 @@ TController::adjust_desired_speed_for_target_speed( double const Range ) { } } } - } AccDesired = std::min( AccDesired, AccPreferred ); } else { @@ -7885,11 +7907,8 @@ TController::adjust_desired_speed_for_current_speed() { -0.05 + fAccThreshold, std::max( EU07_AI_NOACCELERATION, AccPreferred ) ) ); // HACK: for cargo trains with high braking threshold ensure we cross that threshold - if( IsCargoTrain - && fBrake_a0[0] > 0.2 - && speedestimate > holdlimit ) { - AccDesired -= std::clamp( fBrake_a0[ 0 ] - 0.2, 0.0, 0.15 ); - } + auto const crossthreshold { IsCargoTrain && fBrake_a0[ 0 ] > 0.2 && speedestimate > holdlimit }; + AccDesired -= ( crossthreshold ? std::clamp( fBrake_a0[ 0 ] - 0.2, 0.0, 0.15 ) : 0.0 ); } // final tweaks if( vel > EU07_AI_NOMOVEMENT ) { diff --git a/vehicle/Driver.h b/vehicle/Driver.h index 895e638c5..846923df2 100644 --- a/vehicle/Driver.h +++ b/vehicle/Driver.h @@ -349,6 +349,9 @@ private: void pick_optimal_speed( double const Range ); void adjust_desired_speed_for_obstacles(); void adjust_desired_speed_for_limits(); + void set_velocity_for_uncoupling(); + void hold_train_coming_to_stand_uphill(); + void adjust_desired_speed_for_final_approach( double const Vel ); void adjust_desired_speed_for_target_speed( double const Range ); void adjust_desired_speed_for_current_speed(); void adjust_desired_speed_for_braking_test();