18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-19 22:44:59 +01:00

AI: reduced signal speed ends at a marked end of the interlocking area (SignalAreaEnd) (#305)

* feat(ai): reduced signal speed ends at a marked end of the interlocking area

Ie-1 (from 17.01.2026, signals on colour light signals, par. 8): a reduced
speed shown by a signal (S10 "40, then Vmax" and the like) holds to the end
of the interlocking area the signal guards. Only on secondary main tracks
does it hold for the whole route, and on semaphore signals (Sr3) at an entry
or route signal 40 holds for the whole route as well.

The AI kept the speed of the passed signal (VelSignalLast) until it passed
the next signal, or until no signal, switch or W4 was left in the scan. On a
station the exit signal, the far switches and the W4 are always in the scan,
so after S10 at the entry signal onto the principal main track the AI ran 40
all the way to the exit signal.

A scenery can now mark where the interlocking area ends, with a putvalues
event read by the scan like a signal:

  event <name> putvalues 0 none x y z SignalAreaEnd 0 0 endevent

attached to event1/event2 of the track (the direction the train runs), past
the last switch of the area, on the principal main track only. In train mode
the reduced speed of the passed signal ends once the rear of the train is
past the marker, i.e. the whole train has left the switches. A signal at
stop passed (speed 0) is not lifted. The marker sends no command and is not
treated as a signal or a speed limit: it does not end the restricted run on
sight after S1 on automatic block, and it means nothing in shunting. The
driver hint for the end of the speed limit uses the marker when there is one
instead of the farthest switch in the scan.

Where the marker is left out (secondary main tracks, stations with semaphore
signals, every existing scenery) the speed holds as before.

Game data: nothing has to change in the SVN for this to work. Sceneries may
add the marker; a release without this change does not read SignalAreaEnd
(an unknown putvalues command is not scanned), so it ignores it.

* fix(ai): a marker behind the last passed signal does not end its speed

The marker acted on whatever speed the last passed signal had left when the
rear of the train passed it. A train longer than the way from the marker to
the next signal, or one which started standing over the marker (scenario
start at a platform, a direction change), had its head past the next signal
before its rear was past the marker of the previous area, and the marker
then lifted the 40 of the new signal while the head ran through its
switches. Passing a signal now drops the markers that lie before it in the
scan table: they end the area of an earlier signal.

In shunting the marker is no longer thrown away when the rear passes it, so
a train order given before the next signal still finds it.

A note to the previous commit: a release without SignalAreaEnd does not scan
the marker, it runs it as an ordinary putvalues event when a vehicle passes,
which logs it and sends the mover a command it does not know, to no effect.

* AI: a higher road speed (W27/W27a) takes effect once the rear is past the sign (#306)

* fix(ai): a higher road speed (W27) holds only once the rear is past the sign

The road speed of a RoadVelocity event (W27/W27a) took effect as soon as
the head of the train passed the sign, both a lower and a higher one, and
the entry left the scan table in the same pass. A lower speed from the head
is right: the AI brakes before the sign, it is in the scan. A higher one let
the AI speed up while the rest of the train was still on the stretch of the
lower speed.

Now a higher road speed (compared through min_speed, so -1 is no limit)
holds once the whole train is past the sign. Until then the entry stays in
the table and is left out of the rest of the table update, which would have
dropped it. What the update did to a passed passive event when it dropped
it (command, VelSignal, the end of the restricted run on sight) now happens
when the rear passes the sign instead of the head. One-way signs and 2w27
stay as they were: the scan reads only the event of the running direction.

The comments of the road speed and section speed branches named them W6
and W27; they are W27/W27a and W9.

* fix(ai): road speed of cars from the head, W27 does not end the run on sight

Two faults of the previous commit, found in review:

A car's passed events leave the scan table at the latest when its rear
passes them (TableCheck), before the table update could see the rear past
the sign, so an AI car never took a higher road speed and kept the lowest
one for good. A car takes the road speed from the head again, as before.

With the sign now kept in the table until the rear passes it, the generic
handling of a passed passive event ran only then, and it ends the run on
sight after S1 on automatic block. A train which stopped at S1 with its rear
not yet past a W27 lying shortly before the signal would, once on the move,
end the run on sight and run into the occupied block at road speed. A road
speed sign is no signal: it no longer ends the run on sight at all, which
also ends the same thing happening, before this branch, to a train whose
head passed a W27 while running on sight.

* fix(ai): a passed road speed sign is handled when the head passes it, as before

The previous commit left a road speed sign out of the table update until
the rear passed it, so the generic handling of a passed passive event (the
SetVelocity command, VelSignal, the end of the run on sight) ran up to one
train length later than before. By then the order may have changed: a
train standing over a W27 at its last station, with Shunt as its next
order, would be switched back to Obey_train by that command once its rear
passed the sign on the next forward move.

Now the sign is handled as before in the first pass after the head passes
it. In place of dropping it from the table it is then marked as held
(spRoadVelHeld) and only waits for the rear, left out of the rest of the
update. So everything but the moment a higher road speed takes effect is as
it was, and the change of the previous commit that kept a W27 from ending
the run on sight is undone: it is not needed any more.

A car is told by CategoryFlag == 2, the same test TableCheck drops its
passed events by, so a unimog (rail and road) holds the sign for its rear
like a train.

* fix(ai): a road speed released by the rear doesn't exceed a lower sign after it the head has passed

A train longer than the distance between two road speed signs, as W27a
120 and then W27a 60, passes the 60 with its head before its rear is
past the 120. Releasing the 120 then set the road speed to 120, and only
the held 60 handled later in the same table pass brought it back down,
so the result depended on the order of the table and on the loop
reaching that entry (it stops at the first point that orders a stop).

When the rear passes a sign, the road speed is now the lowest of that
sign and of the signs after it that the head has passed and the rear
not yet. Without such a sign it is set as before.

* fix(ai): a passed road speed sign not yet marked as held caps the released one too

The sign after the released one may have been passed by the head in
the very tick the rear passes the released one, before the table update
marks it as held. It is now taken into the lowest speed as well (an
enabled road speed entry behind the head), so the result doesn't depend
on the table update reaching it in that tick.

---------

Co-authored-by: maj00r <maj00r@host>

---------

Co-authored-by: maj00r <maj00r@host>
Co-authored-by: jerrrrycho <jurek.pakula@gmail.com>
This commit is contained in:
maj00r
2026-11-11 10:44:42 +01:00
committed by GitHub
parent 5bac4e1cf1
commit 10c7527a64
4 changed files with 147 additions and 8 deletions

View File

@@ -92,6 +92,7 @@ enum class TCommandType
// cm_Shunt, // unused?
cm_EmergencyBrake,
cm_SecuritySystemMagnet,
cm_SignalAreaEnd, // end of the interlocking area of the signal passed last
cm_Command // komenda pobierana z komórki
};

View File

@@ -32,7 +32,9 @@ http://mozilla.org/MPL/2.0/.
#include "world/station.h"
#include "input/keyboardinput.h"
#include <algorithm>
#include <format>
#include <ranges>
#define LOGVELOCITY 0
#define LOGORDERS 1
@@ -293,6 +295,11 @@ void TSpeedPos::CommandCheck()
case TCommandType::cm_SecuritySystemMagnet:
fVelNext = -1;
break;
case TCommandType::cm_SignalAreaEnd:
// imposes no speed of its own, it only ends the reduced speed of the signal passed last
fVelNext = -1;
iFlags |= spSignalAreaEnd;
break;
default:
// inna komenda w evencie skanowanym powoduje zatrzymanie i wysłanie tej komendy
// nie manewrowa, nie przystanek, nie zatrzymać na SBL
@@ -861,6 +868,13 @@ bool is_signal_at_stop( TSpeedPos const &Point )
&& Point.evEvent != nullptr;
}
void clear_signal_area_end( TSpeedPos &Point )
{
if( TestFlag( Point.iFlags, spSignalAreaEnd ) ) {
Point.Clear();
}
}
// the position is a signal, a main or a shunting one: the aspect comes from its memory cell. putvalues events
// set speed limits by the track, and the flags they get don't make them signals
bool is_signal( TSpeedPos const &Point )
@@ -970,6 +984,7 @@ TCommandType TController::TableUpdate(double &fVelDes, double &fDist, double &fN
mvOccupied->SecuritySystem.set_cabsignal_lock(false);
// te flagi są ustawiane tutaj, w razie potrzeby
iDrivigFlags &= ~(moveTrackEnd | moveSwitchFound | moveSignalFound | /*moveSpeedLimitFound*/ moveStopPointFound );
SignalAreaEndDist = -1.0;
update_point_limits();
for( std::size_t idx = 0; idx < sSpeedTable.size(); ++idx ) {
@@ -1156,8 +1171,10 @@ TCommandType TController::TableUpdate(double &fVelDes, double &fDist, double &fN
VelLimitLastDist.second = EU07_AI_SPEEDLIMITEXTENDSBEYONDSCANRANGE;
}
// take into account the effect switches have on duration of signal-imposed speed limit, in calculation of speed limit end point
if( VelSignalLast >= 0.0 && SwitchClearDist >= 0.0 ) {
VelLimitLastDist.second = std::max( VelLimitLastDist.second, SwitchClearDist );
// a reduced speed ends where the interlocking area does, if that is marked, and not past the switches farther on
if( auto const signallimitend { VelSignalLast > 0.0 && SignalAreaEndDist >= 0.0 ? SignalAreaEndDist : SwitchClearDist };
VelSignalLast >= 0.0 && signallimitend >= 0.0 ) {
VelLimitLastDist.second = std::max( VelLimitLastDist.second, signallimitend );
}
//analiza spisanych z tabelki ograniczeń i nadpisanie aktualnego
@@ -1488,6 +1505,104 @@ TController::TableUpdateStopPoint( TCommandType &Command, TSpeedPos &Point, doub
return false; //
}
// a road speed sign (W27/W27a) passed by the head stays in the table until the rear is past it too. not for cars: their
// passed events leave the table at the latest when the rear passes them (TableCheck), before the table update sees that
bool
TController::is_road_velocity_held( TSpeedPos const &Point ) const {
return TestFlag( Point.iFlags, spRoadVel )
&& mvOccupied->CategoryFlag != 2
&& Point.fDist >= -fLength;
}
// a passed event is handled once and then dropped from the table, except a road speed sign held for the rear
void
TController::TableDropPassedEvent( TSpeedPos &Point ) const {
if( is_road_velocity_held( Point ) ) {
Point.iFlags |= spRoadVelHeld;
return;
}
Point.Clear();
}
// the lowest road speed of the signs past the given one that the head has passed: held until the rear is past them too,
// or passed in this very tick and not marked as held yet; -1 if there's none
double
TController::held_road_velocity_beyond( TSpeedPos const &Point ) const {
auto lowest { -1.0 };
for( auto const &held : sSpeedTable ) {
if( ( held.iFlags & ( spEnabled | spRoadVel ) ) != ( spEnabled | spRoadVel )
|| held.fDist >= 0.0
|| held.fDist <= Point.fDist ) {
continue;
}
lowest = min_speed( lowest, held.fVelNext );
}
return lowest;
}
// a road speed (W27/W27a) lower than the one in force holds once the head passes the sign, a higher one only once the
// whole train is past it (a car takes it from the head). the first pass after the head handles the sign as before, the
// entry is then only held for the rear: returns true for it, so the rest of the table update leaves it out
bool
TController::TableUpdateRoadVelocity( TSpeedPos &Point ) {
if( Point.fDist >= 0.0 ) { return false; }
if( mvOccupied->CategoryFlag == 2 ) {
VelRoad = Point.fVelNext;
return false;
}
auto const isrearpast { Point.fDist < -fLength };
if( isrearpast ) {
// the rear past it, but not past a sign after it the head has passed too: none of those may be exceeded, so a
// lower one (W27a 60 within a train's length after a 120) stays in force
VelRoad = min_speed( Point.fVelNext, held_road_velocity_beyond( Point ) );
}
else if( Point.fVelNext == min_speed( Point.fVelNext, VelRoad ) ) {
VelRoad = Point.fVelNext;
}
if( false == TestFlag( Point.iFlags, spRoadVelHeld ) ) {
return false;
}
if( isrearpast ) {
Point.Clear();
}
return true;
}
// a reduced speed shown by a signal holds to the end of the interlocking area the signal guards (Ie-1), and that end is
// marked on the main track with a SignalAreaEnd event. on a track without the marker the speed holds as it did before:
// until the next signal, or until no signal, switch or stop point is left in the scan
void
TController::TableUpdateSignalAreaEnd( TSpeedPos &Point ) {
// the switches lie in front of the marker, so the whole train has left them once its rear end is past it
if( Point.fDist >= -fLength ) {
if( SignalAreaEndDist < 0.0
&& TestFlag( OrderCurrentGet(), Obey_train ) ) {
// the table is sorted by distance, so the first marker is the nearest one
SignalAreaEndDist = Point.fDist + fLength;
}
return;
}
// in shunting the marker stays, a train order given before the next signal still finds it
if( false == TestFlag( OrderCurrentGet(), Obey_train ) ) { return; }
// a passed signal at stop (0) keeps holding the train, only a reduced speed ends here
if( VelSignalLast > 0.0 ) {
if( Global.iWriteLogEnabled & 8 ) {
WriteLog( "Speed table update for " + OwnerName() + ", left the interlocking area at " + Point.evEvent->m_name );
}
VelSignalLast = -1.0;
}
Point.Clear();
}
bool TController::point_limit_latched( basic_event const *Cell ) const {
return std::any_of(
@@ -1663,6 +1778,12 @@ glm::dvec3 TController::travel_direction() const {
bool
TController::TableUpdateEvent( double &Velocity, TCommandType &Command, TSpeedPos &Point, double &Signaldistance, int const Pointindex ) {
if( TestFlag( Point.iFlags, spSignalAreaEnd ) ) {
// not a signal: it neither sends a command nor counts as the end of a speed limit in the scan
TableUpdateSignalAreaEnd( Point );
return true;
}
if( TestFlag( Point.iFlags, spPointVelocity ) ) {
// PointVelocity: no signal, no command, only the limit at its point
// done once the head passes the point
@@ -1840,6 +1961,9 @@ TController::TableUpdateEvent( double &Velocity, TCommandType &Command, TSpeedPo
// for ai-driven vehicles always play by the rules
else {
VelSignalLast = Point.fVelNext; //minięty daje prędkość obowiązującą
// a marker before this signal ends the interlocking area of an earlier signal, not the area of this one
// (a train longer than the way between the two, or one which started standing over the marker)
std::ranges::for_each( sSpeedTable | std::views::take( Pointindex ), clear_signal_area_end );
}
}
else {
@@ -1865,12 +1989,13 @@ TController::TableUpdateEvent( double &Velocity, TCommandType &Command, TSpeedPo
}
}
else if ( Point.iFlags & spRoadVel)
{ // to W6
if ( Point.fDist < 0)
VelRoad = Point.fVelNext;
{ // to W27/W27a
if( TableUpdateRoadVelocity( Point ) ) {
return true;
}
}
else if ( Point.iFlags & spSectionVel && Point.fDist < 0)
{ // to W27
{ // to W9
// teraz trzeba sprawdzić inne warunki
if (Point.fSectionVelocityDist == 0.0)
{
@@ -1992,7 +2117,7 @@ TController::TableUpdateEvent( double &Velocity, TCommandType &Command, TSpeedPo
}
// jeśli nie jest ograniczeniem prędkości to można usunąć
// (nie mogą być usuwane w skanowaniu)
Point.Clear();
TableDropPassedEvent( Point );
}
}
else if (Point.evEvent->is_command())

View File

@@ -147,7 +147,9 @@ enum TSpeedPosFlag
spRoadVel = 0x8000, // zadanie prędkości drogowej
spSectionVel = 0x20000, // odcinek z ograniczeniem
spProximityVelocity = 0x40000, // odcinek z ograniczeniem i podaną jego długościa
spPointVelocity = 0x80000 // ograniczenie dla czoła w punkcie fPointDist za wpisem (PointVelocity)
spPointVelocity = 0x80000, // ograniczenie dla czoła w punkcie fPointDist za wpisem (PointVelocity)
spRoadVelHeld = 0x100000, // a road speed sign passed by the head, handled, kept until the rear is past it
spSignalAreaEnd = 0x200000 // end of the interlocking area of the signal passed last
// spDontApplySpeedLimit = 0x10000 // this point won't apply its speed limit. potentially set by the scanning vehicle
};
@@ -448,6 +450,7 @@ private:
double ActualProximityDist = 1.0; // odległość brana pod uwagę przy wyliczaniu prędkości i przyspieszenia
std::pair<double, double> VelLimitLastDist { 0.0, 0.0 }; // distance to velocity change point
double SwitchClearDist { 0.0 }; // distance to point after farthest detected switch
double SignalAreaEndDist { -1.0 }; // distance the train has to go to be past the nearest end of an interlocking area, -1 when none is in the scan
int iDirection = 0; // kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył)
int iDirectionOrder = 0; //żadany kierunek jazdy (służy do zmiany kierunku)
std::optional<int> iDirectionBackup; // consist direction to be restored after coupling/uncoupling and similar direction-changing operations
@@ -567,6 +570,11 @@ private:
TCommandType TableUpdate( double &fVelDes, double &fDist, double &fNext, double &fAcc );
bool TableUpdateStopPoint( TCommandType &Command, TSpeedPos &Point, double const Signaldistance );
bool TableUpdateEvent( double &Velocity, TCommandType &Command, TSpeedPos &Point, double &Signaldistance, int const Pointindex );
bool TableUpdateRoadVelocity( TSpeedPos &Point );
double held_road_velocity_beyond( TSpeedPos const &Point ) const;
bool is_road_velocity_held( TSpeedPos const &Point ) const;
void TableDropPassedEvent( TSpeedPos &Point ) const;
void TableUpdateSignalAreaEnd( TSpeedPos &Point );
// keeps the PointVelocity limit of a speed table entry whose cell the head has just passed
void latch_point_limit( TSpeedPos const &Point );
// moves the latched point limits by the movement of the consist, drops those passed and those read anew

View File

@@ -749,6 +749,11 @@ putvalues_event::deserialize_( cParser &Input, scene::scratch_data &Scratchpad )
m_input.command_type = TCommandType::cm_SecuritySystemMagnet;
m_passive = true;
}
else if( token == "SignalAreaEnd" ) {
// scanned, so the train sees where the interlocking area of the signal it passed ends
m_input.command_type = TCommandType::cm_SignalAreaEnd;
m_passive = true;
}
else {
m_input.command_type = TCommandType::cm_Unknown;
}