18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-19 23:55:00 +01:00
Files
maszyna/world/MemCell.cpp
maj00r 5c8cc6d9a5 feat(ai): PointVelocity, a speed limit for the head of the train at a point beyond the cell (#304)
* feat(ai): PointVelocity, a speed limit for the head of the train at a point beyond the cell

A memory cell (or putvalues) with "PointVelocity v d" tells the train that the head has to be at v km/h
at the point d metres beyond the cell (v -1: no limit). The cell is read by the speed table scan like a
signal, live until the head passes it; what it says then is kept for the point, later changes of the
cell don't concern that train. The limit ends when the head passes the point, it doesn't hold the rest
of the train and doesn't extend or break a speed limit of the line, like W27 of length 0 moved d metres
on. The AI brakes so the head reaches the point at v; for a human driver it only shows as the next
speed limit of the driving aid, the security systems don't see it.

It is made for the warning disc of a level crossing (TOP, Osp1/Osp2), which has to give 20 km/h at the
crossing about 500 m beyond the disc, as the disc showed when the train passed it.

The cell with PointVelocity as its first command makes its getvalues scanned (passive) as SetVelocity
does; PutCommand ignores it when such an event runs. Old commands keep working as they did,
SetProximityVelocity included.

* fix(ai): a point limit isn't a signal, and a PointVelocity 0 can be released

From the review of the PointVelocity commit:
- a cell rewritten from SetVelocity or ShuntVelocity to PointVelocity drops the flags of a signal, so it
  can't count as a semaphor or report a signal passed at danger;
- PointVelocity 0 is read on after the head passes the cell, as a stop of a signal is, otherwise the
  train would stand short of the point for good;
- a point limit doesn't become eSignNext, so a W4 between the disc and the crossing keeps its release.

* fix(ai): a PointVelocity limit outlives a rebuilt speed table, and holds when shunting

The state of the cell, latched when the head passes it, is now kept by the
controller apart from the speed table, and the distance to the point is
measured by the movement of the consist in the world. Stopping, backing up
and going on between the cell and the point, coupling or a takeover no longer
lose the limit or read the cell anew, unless the head backs up past the cell,
when the cell is read again.

Near the point the desired speed is capped to the limit, so a train that
coasts within its tolerance (as a shunting one does) reaches the point at it.

* fix(ai): review of the latched point limits

- a point the head has passed already isn't latched, and a latched limit at
  or behind the head isn't applied (it asked for a full brake for a cycle);
- a latched limit is dropped once the head backs up behind its cell, so it
  can't follow the consist onto another track; the table reads the cell again;
- a cell latched already, found under the consist by a rebuilt table, is
  ignored whatever it shows now (a 0 for the next train no longer stops it);
- PointVelocity 0 stops at the usual distance, not from the approach;
- the heading follows the track under the measured vehicle, not the chord of
  the consist, which a long consist on a tight curve holds far off the track;
- vehicles coupled or uncoupled at the end towards the point move the head;
- a jump of the consist (moved elsewhere) drops the latched limits.

* fix(ai): a cab change and curves don't move the latched point limits

- the end of the consist towards the point is taken into the distance only
  when the consist changes (its end vehicles or its length), not when another
  vehicle is measured from (a cab change at a reversal) nor when a curve
  shortens its projection;
- the way of travel follows the direction of the driver's vehicle against
  its own couplers, not the chord of the consist, which on a balloon loop
  points against it.

* fix(ai): a coupling with a cab change in one order still moves the head of a latched point limit

The end of the consist measured from the previous vehicle is moved to the place of the new one, so a coupling or an uncoupling followed at once by a change of direction to the other cab (the shunting orders) is taken into the distance to the point.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-10 18:44:33 +01:00

294 lines
9.0 KiB
C++

/*
This Source Code Form is subject to the
terms of the Mozilla Public License, v.
2.0. If a copy of the MPL was not
distributed with this file, You can
obtain one at
http://mozilla.org/MPL/2.0/.
*/
/*
MaSzyna EU07 locomotive simulator
Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others
*/
#include "stdafx.h"
#include "world/MemCell.h"
#include "simulation/simulation.h"
#include "vehicle/Driver.h"
#include "world/Event.h"
#include "utilities/Logs.h"
//---------------------------------------------------------------------------
TMemCell::TMemCell( scene::node_data const &Nodedata ) : basic_node( Nodedata ) {}
void TMemCell::UpdateValues( std::string_view szNewText, double const fNewValue1, double const fNewValue2, int const CheckMask )
{
if (CheckMask & basic_event::flags::mode_add)
{ // dodawanie wartości
if( TestFlag( CheckMask, basic_event::flags::text ) )
szText += szNewText;
if (TestFlag(CheckMask, basic_event::flags::value1))
fValue1 += fNewValue1;
if (TestFlag(CheckMask, basic_event::flags::value2))
fValue2 += fNewValue2;
}
else
{
if( TestFlag( CheckMask, basic_event::flags::text ) )
szText = szNewText;
if (TestFlag(CheckMask, basic_event::flags::value1))
fValue1 = fNewValue1;
if (TestFlag(CheckMask, basic_event::flags::value2))
fValue2 = fNewValue2;
}
if (TestFlag(CheckMask, basic_event::flags::text))
CommandCheck(); // jeśli zmieniony tekst, próbujemy rozpoznać komendę
}
TCommandType TMemCell::CommandCheck()
{ // rozpoznanie komendy
using enum TCommandType;
if( szText == "SetVelocity" ) // najpopularniejsze
{
eCommand = cm_SetVelocity;
bCommand = false; // ta komenda nie jest wysyłana
}
else if( szText == "ShuntVelocity" ) // w tarczach manewrowych
{
eCommand = cm_ShuntVelocity;
bCommand = false; // ta komenda nie jest wysyłana
}
else if( szText == "Change_direction" ) // zdarza się
{
eCommand = cm_ChangeDirection;
bCommand = true; // do wysłania
}
else if( szText == "OutsideStation" ) // zdarza się
{
eCommand = cm_OutsideStation;
bCommand = false; // tego nie powinno być w komórce
}
else if( szText.starts_with("PassengerStopPoint:") ) // porównanie początków
{
eCommand = cm_PassengerStopPoint;
bCommand = false; // tego nie powinno być w komórce
}
else if( szText == "SetProximityVelocity" ) // nie powinno tego być
{
eCommand = cm_SetProximityVelocity;
bCommand = false; // ta komenda nie jest wysyłana
}
else if( szText == "PointVelocity" ) // tarcze ostrzegawcze przejazdowe: v1 prędkość, v2 odległość
{
eCommand = cm_PointVelocity;
bCommand = false; // odczytywana skanowaniem, nie wysyłana
}
else if( szText == "Emergency_brake" )
{
eCommand = cm_EmergencyBrake;
bCommand = false;
}
else if( szText == "CabSignal" ) {
eCommand = cm_SecuritySystemMagnet;
bCommand = false;
}
else
{
eCommand = cm_Unknown; // ciąg nierozpoznany (nie jest komendą)
bCommand = true; // do wysłania
}
return eCommand;
}
bool TMemCell::Load(cParser *parser)
{
std::string token;
parser->getTokens( 6, false );
*parser
>> m_area.center.x
>> m_area.center.y
>> m_area.center.z
>> szText
>> fValue1
>> fValue2;
parser->getTokens();
*parser >> token;
if (token != "none") // gdy różne od "none"
asTrackName = token; // sprawdzane przez IsEmpty()
parser->getTokens();
*parser >> token;
if (token != "endmemcell")
Error("endmemcell statement missing");
CommandCheck();
return true;
}
void TMemCell::PutCommand( TController *Mech, glm::dvec3 const *Loc ) const
{ // wysłanie zawartości komórki do AI
if (Mech)
Mech->PutCommand(szText, fValue1, fValue2, Loc);
}
bool TMemCell::Compare( std::string const &szTestText, double const fTestValue1, double const fTestValue2, int const CheckMask,
comparison_operator const TextOperator, comparison_operator const Value1Operator, comparison_operator const Value2Operator,
comparison_pass const Pass ) const {
// porównanie zawartości komórki pamięci z podanymi wartościami
/*
if( TestFlag( CheckMask, basic_event::flags::text ) ) {
// porównać teksty
auto range = szTestText.find( '*' );
if( range != std::string::npos ) {
// compare string parts
if( 0 != szText.compare( 0, range, szTestText, 0, range ) ) {
return false;
}
}
else {
// compare full strings
if( szText != szTestText ) {
return false;
}
}
}
// tekst zgodny, porównać resztę
return ( ( !TestFlag( CheckMask, basic_event::flags::value1 ) || ( fValue1 == fTestValue1 ) )
&& ( !TestFlag( CheckMask, basic_event::flags::value2 ) || ( fValue2 == fTestValue2 ) ) );
*/
bool checkpassed { false };
bool checkfailed { false };
if( TestFlag( CheckMask, basic_event::flags::text ) ) {
// porównać teksty
auto wildcardpos = szTestText.find( '*' );
auto const result { (
wildcardpos == std::string::npos ?
compare( szText, szTestText, TextOperator ) :
compare( szText.substr( 0, wildcardpos ), szTestText.substr( 0, wildcardpos ), TextOperator ) ) };
checkpassed |= result;
checkfailed |= !result;
}
if( TestFlag( CheckMask, basic_event::flags::value1 ) ) {
auto const result { compare( fValue1, fTestValue1, Value1Operator ) };
checkpassed |= result;
checkfailed |= !result;
}
if( TestFlag( CheckMask, basic_event::flags::value2 ) ) {
auto const result { compare( fValue2, fTestValue2, Value2Operator ) };
checkpassed |= result;
checkfailed |= !result;
}
switch( Pass ) {
using enum comparison_pass;
case all: { return checkfailed == false; }
case any: { return checkpassed == true; }
case none: { return checkpassed == false; }
default: { return false; }
}
};
bool TMemCell::IsVelocity() const
{ // sprawdzenie, czy event odczytu tej komórki ma być do skanowania, czy do kolejkowania
using enum TCommandType;
if (eCommand == cm_SetVelocity)
return true;
if (eCommand == cm_ShuntVelocity)
return true;
if (eCommand == cm_PointVelocity)
return true;
return eCommand == cm_SetProximityVelocity;
};
void TMemCell::StopCommandSent()
{ //
if (!bCommand)
return;
bCommand = false;
if( OnSent ) {
// jeśli jest event
simulation::Events.AddToQuery( OnSent, nullptr );
}
};
void TMemCell::AssignEvents(basic_event *e)
{ // powiązanie eventu
OnSent = e;
};
std::string TMemCell::Values() const {
return { "[" + Text() + "] [" + to_string( Value1(), 2 ) + "] [" + to_string( Value2(), 2 ) + "]" };
}
void TMemCell::LogValues() const {
WriteLog( "Memcell " + name() + ": " + Values() );
}
// serialize() subclass details, sends content of the subclass to provided stream
void
TMemCell::serialize_( std::ostream &Output ) const {
// TODO: implement
}
// deserialize() subclass details, restores content of the subclass from provided stream
void
TMemCell::deserialize_( std::istream &Input ) {
// TODO: implement
}
// export() subclass details, sends basic content of the class in legacy (text) format to provided stream
void
TMemCell::export_as_text_( std::ostream &Output ) const {
// header
Output << "memcell ";
// location
Output
<< location().x << ' '
<< location().y << ' '
<< location().z << ' '
// cell data
<< szText << ' '
<< fValue1 << ' '
<< fValue2 << ' '
// associated track
<< ( Track ? Track->name() : asTrackName.empty() ? "none" : asTrackName ) << ' '
// footer
<< "endmemcell"
<< "\n";
}
// legacy method, initializes traction after deserialization from scenario file
void
memory_table::InitCells() const {
for( auto *cell : m_items ) {
// Ra: eventy komórek pamięci, wykonywane po wysłaniu komendy do zatrzymanego pojazdu
cell->AssignEvents( simulation::Events.FindEvent( cell->name() + ":sent" ) );
// bind specified path with the memory cell
if( false == cell->asTrackName.empty() ) {
cell->Track = simulation::Paths.find( cell->asTrackName );
if( cell->Track == nullptr ) {
ErrorLog( "Bad memcell: track \"" + cell->asTrackName + "\" referenced in memcell \"" + cell->name() + "\" doesn't exist" );
}
}
}
}
// legacy method, sends content of all cells to the log
void
memory_table::log_all() const {
for( auto const *cell : m_items ) {
cell->LogValues();
}
}