mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-19 22:44:59 +01:00
* 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>