eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-23 13:19:19 +02:00
Code Issues 123 Wiki Activity

build 190129. door control system enhancements, minor bug fixes

Browse Source
This commit is contained in:
tmj-fstate
2019-01-29 16:29:37 +01:00
parent 753cf7ee5d
commit e71db46de0
20 changed files with 1225 additions and 1000 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
Driver.cpp
View File

@@ -1009,21 +1009,6 @@ TCommandType TController::TableUpdate(double &fVelDes, double &fDist, double &fN
continue; continue;
} }
} }
else {
// sitting at passenger stop
if( fStopTime < 0 ) {
// verify progress of load exchange
auto exchangetime { 0.f };
auto *vehicle { pVehicles[ 0 ] };
while( vehicle != nullptr ) {
exchangetime = std::max( exchangetime, vehicle->LoadExchangeTime() );
vehicle = vehicle->Next();
}
if( exchangetime > 0 ) {
WaitingSet( exchangetime );
}
}
}
if (OrderCurrentGet() & Shunt) { if (OrderCurrentGet() & Shunt) {
OrderNext(Obey_train); // uruchomić jazdę pociągową OrderNext(Obey_train); // uruchomić jazdę pociągową
@@ -2089,8 +2074,8 @@ bool TController::CheckVehicles(TOrders user)
{ {
// HACK: wagony muszą mieć baterię załączoną do otwarcia drzwi... // HACK: wagony muszą mieć baterię załączoną do otwarcia drzwi...
if( ( p != pVehicle ) if( ( p != pVehicle )
&& ( ( p->MoverParameters->Couplers[ side::front ].CouplingFlag & ( coupling::control | coupling::permanent ) ) == 0 ) && ( ( p->MoverParameters->Couplers[ end::front ].CouplingFlag & ( coupling::control | coupling::permanent ) ) == 0 )
&& ( ( p->MoverParameters->Couplers[ side::rear ].CouplingFlag & ( coupling::control | coupling::permanent ) ) == 0 ) ) { && ( ( p->MoverParameters->Couplers[ end::rear ].CouplingFlag & ( coupling::control | coupling::permanent ) ) == 0 ) ) {
// NOTE: don't set battery in the occupied vehicle, let the user/ai do it explicitly // NOTE: don't set battery in the occupied vehicle, let the user/ai do it explicitly
p->MoverParameters->BatterySwitch( true ); p->MoverParameters->BatterySwitch( true );
} }
@@ -2114,12 +2099,12 @@ bool TController::CheckVehicles(TOrders user)
// jeśli jazda pociągowa // jeśli jazda pociągowa
// światła pociągowe (Pc1) i końcówki (Pc5) // światła pociągowe (Pc1) i końcówki (Pc5)
auto const frontlights { ( auto const frontlights { (
( m_lighthints[ side::front ] != -1 ) ? ( m_lighthints[ end::front ] != -1 ) ?
m_lighthints[ side::front ] : m_lighthints[ end::front ] :
light::headlight_left | light::headlight_right | light::headlight_upper ) }; light::headlight_left | light::headlight_right | light::headlight_upper ) };
auto const rearlights { ( auto const rearlights { (
( m_lighthints[ side::rear ] != -1 ) ? ( m_lighthints[ end::rear ] != -1 ) ?
m_lighthints[ side::rear ] : m_lighthints[ end::rear ] :
light::redmarker_left | light::redmarker_right | light::rearendsignals ) }; light::redmarker_left | light::redmarker_right | light::rearendsignals ) };
Lights( Lights(
frontlights, frontlights,
@@ -2156,9 +2141,12 @@ bool TController::CheckVehicles(TOrders user)
Lights( 0, light::headlight_right ); Lights( 0, light::headlight_right );
} }
} }
// nastawianie hamulca do jazdy pociągowej
if( OrderCurrentGet() & ( Obey_train | Shunt ) ) { if( OrderCurrentGet() & ( Obey_train | Shunt ) ) {
// nastawianie hamulca do jazdy pociągowej
AutoRewident(); AutoRewident();
// enable door locks
mvOccupied->LockDoors( true );
} }
} }
else { // gdy człowiek i gdy nastąpiło połącznie albo rozłączenie else { // gdy człowiek i gdy nastąpiło połącznie albo rozłączenie
@@ -2473,10 +2461,10 @@ bool TController::PrepareEngine()
// w EN57 sprężarka w ra jest zasilana z silnikowego // w EN57 sprężarka w ra jest zasilana z silnikowego
mvOccupied->CompressorSwitch( true ); mvOccupied->CompressorSwitch( true );
// enable motor blowers // enable motor blowers
mvOccupied->MotorBlowersSwitchOff( false, side::front ); mvOccupied->MotorBlowersSwitchOff( false, end::front );
mvOccupied->MotorBlowersSwitch( true, side::front ); mvOccupied->MotorBlowersSwitch( true, end::front );
mvOccupied->MotorBlowersSwitchOff( false, side::rear ); mvOccupied->MotorBlowersSwitchOff( false, end::rear );
mvOccupied->MotorBlowersSwitch( true, side::rear ); mvOccupied->MotorBlowersSwitch( true, end::rear );
} }
} }
else else
@@ -2558,15 +2546,9 @@ bool TController::ReleaseEngine() {
while( ( mvOccupied->ActiveDir > 0 ) && ( mvOccupied->DirectionBackward() ) ) { ; } while( ( mvOccupied->ActiveDir > 0 ) && ( mvOccupied->DirectionBackward() ) ) { ; }
while( ( mvOccupied->ActiveDir < 0 ) && ( mvOccupied->DirectionForward() ) ) { ; } while( ( mvOccupied->ActiveDir < 0 ) && ( mvOccupied->DirectionForward() ) ) { ; }
if( mvOccupied->DoorCloseCtrl == control_t::driver ) { // zamykanie drzwi
// zamykanie drzwi mvOccupied->OperateDoors( side::right, false );
if( mvOccupied->DoorLeftOpened ) { mvOccupied->OperateDoors( side::left, false );
mvOccupied->DoorLeft( false );
}
if( mvOccupied->DoorRightOpened ) {
mvOccupied->DoorRight( false );
}
}
if( true == mvControlling->Mains ) { if( true == mvControlling->Mains ) {
mvControlling->CompressorSwitch( false ); mvControlling->CompressorSwitch( false );
@@ -3238,36 +3220,40 @@ void TController::Doors( bool const Open, int const Side ) {
// otwieranie drzwi // otwieranie drzwi
// otwieranie drzwi w składach wagonowych - docelowo wysyłać komendę zezwolenia na otwarcie drzwi // otwieranie drzwi w składach wagonowych - docelowo wysyłać komendę zezwolenia na otwarcie drzwi
// tu będzie jeszcze długość peronu zaokrąglona do 10m (20m bezpieczniej, bo nie modyfikuje bitu 1) // tu będzie jeszcze długość peronu zaokrąglona do 10m (20m bezpieczniej, bo nie modyfikuje bitu 1)
auto *vehicle = pVehicles[0]; // pojazd na czole składu auto const lewe = ( pVehicle->DirectionGet() > 0 ) ? 1 : 2;
while( vehicle != nullptr ) { auto const prawe = 3 - lewe;
// otwieranie drzwi w pojazdach - flaga zezwolenia była by lepsza
if( vehicle->MoverParameters->DoorOpenCtrl != control_t::passenger ) { if( ( pVehicle->MoverParameters->Doors.open_permit == false )
// if the door are controlled by the driver, we let the user operate them... && ( true == AIControllFlag ) ) {
if( true == AIControllFlag ) { // grant door control permission if it's not automatic
// ...unless this user is an ai // TBD: stricter requirements?
// Side=platform side (1:left, 2:right, 3:both) if( Side & prawe )
// jeśli jedzie do tyłu, to drzwi otwiera odwrotnie pVehicle->MoverParameters->PermitDoors( side::right );
auto const lewe = ( vehicle->DirectionGet() > 0 ) ? 1 : 2; if( Side & lewe )
auto const prawe = 3 - lewe; pVehicle->MoverParameters->PermitDoors( side::left );
if( Side & lewe ) }
vehicle->MoverParameters->DoorLeft( true, range_t::local );
if( Side & prawe ) if( ( pVehicle->MoverParameters->Doors.open_control == control_t::conductor )
vehicle->MoverParameters->DoorRight( true, range_t::local ); || ( ( true == AIControllFlag )
} && ( ( pVehicle->MoverParameters->Doors.open_control == control_t::driver )
} || ( pVehicle->MoverParameters->Doors.open_control == control_t::mixed ) ) ) ) {
// pojazd podłączony z tyłu (patrząc od czoła) // if the door can be operated by the driver we let the user operate them unless this user is an ai
vehicle = vehicle->Next(); // the train conductor, if present, handles door operation also for human-driven trains
if( Side & prawe )
pVehicle->MoverParameters->OperateDoors( side::right, true );
if( Side & lewe )
pVehicle->MoverParameters->OperateDoors( side::left, true );
} }
} }
else { else {
// zamykanie // zamykanie
if( false == doors_open() ) { if( ( true == pVehicle->MoverParameters->Doors.open_permit ) && ( false == doors_open() ) ) {
// the doors are already closed, we can skip all hard work // the doors are already closed and we don't have to revoke control permit, we can skip all hard work
iDrivigFlags &= ~moveDoorOpened; iDrivigFlags &= ~moveDoorOpened;
} }
if( AIControllFlag ) { if( AIControllFlag ) {
if( ( true == mvOccupied->DoorClosureWarning ) if( ( true == mvOccupied->Doors.has_autowarning )
&& ( false == mvOccupied->DepartureSignal ) && ( false == mvOccupied->DepartureSignal )
&& ( true == TestFlag( iDrivigFlags, moveDoorOpened ) ) ) { && ( true == TestFlag( iDrivigFlags, moveDoorOpened ) ) ) {
mvOccupied->signal_departure( true ); // załącenie bzyczka mvOccupied->signal_departure( true ); // załącenie bzyczka
@@ -3279,12 +3265,22 @@ void TController::Doors( bool const Open, int const Side ) {
&& ( ( fActionTime > -0.5 ) && ( ( fActionTime > -0.5 )
|| ( false == AIControllFlag ) ) ) { || ( false == AIControllFlag ) ) ) {
// ai doesn't close the door until it's free to depart, but human driver has free reign to do stupid things // ai doesn't close the door until it's free to depart, but human driver has free reign to do stupid things
if( ( pVehicle->MoverParameters->Doors.open_control == control_t::conductor )
|| ( ( true == AIControllFlag )
&& ( ( pVehicle->MoverParameters->Doors.open_control == control_t::driver )
|| ( pVehicle->MoverParameters->Doors.open_control == control_t::mixed ) ) ) ) {
// if the door are controlled by the driver, we let the user operate them unless this user is an ai
// the train conductor, if present, handles door operation also for human-driven trains
pVehicle->MoverParameters->OperateDoors( side::right, false );
pVehicle->MoverParameters->OperateDoors( side::left, false );
}
auto *vehicle = pVehicles[ 0 ]; // pojazd na czole składu auto *vehicle = pVehicles[ 0 ]; // pojazd na czole składu
while( vehicle != nullptr ) { while( vehicle != nullptr ) {
// zamykanie drzwi w pojazdach - flaga zezwolenia była by lepsza // zamykanie drzwi w pojazdach - flaga zezwolenia była by lepsza
if( vehicle->MoverParameters->DoorCloseCtrl != control_t::autonomous ) { if( vehicle->MoverParameters->Doors.auto_velocity < 0.f ) {
vehicle->MoverParameters->DoorLeft( false, range_t::local ); // w lokomotywie można by nie zamykać... vehicle->MoverParameters->OperateDoors( side::right, false, range_t::local ); // w lokomotywie można by nie zamykać...
vehicle->MoverParameters->DoorRight( false, range_t::local ); vehicle->MoverParameters->OperateDoors( side::left, false, range_t::local );
} }
vehicle = vehicle->Next(); // pojazd podłączony z tyłu (patrząc od czoła) vehicle = vehicle->Next(); // pojazd podłączony z tyłu (patrząc od czoła)
} }
@@ -3307,8 +3303,8 @@ TController::doors_open() const {
auto *vehicle = pVehicles[ 0 ]; // pojazd na czole składu auto *vehicle = pVehicles[ 0 ]; // pojazd na czole składu
while( vehicle != nullptr ) { while( vehicle != nullptr ) {
if( ( vehicle->MoverParameters->DoorRightOpened == true ) if( ( false == vehicle->MoverParameters->Doors.instances[side::right].is_closed )
|| ( vehicle->MoverParameters->DoorLeftOpened == true ) ) { || ( false == vehicle->MoverParameters->Doors.instances[side::left].is_closed ) ) {
// any open door is enough // any open door is enough
return true; return true;
} }
@@ -3725,8 +3721,8 @@ bool TController::PutCommand( std::string NewCommand, double NewValue1, double N
if( NewCommand == "SetLights" ) { if( NewCommand == "SetLights" ) {
// set consist lights pattern hints // set consist lights pattern hints
m_lighthints[ side::front ] = static_cast<int>( NewValue1 ); m_lighthints[ end::front ] = static_cast<int>( NewValue1 );
m_lighthints[ side::rear ] = static_cast<int>( NewValue2 ); m_lighthints[ end::rear ] = static_cast<int>( NewValue2 );
if( true == TestFlag( OrderCurrentGet(), Obey_train ) ) { if( true == TestFlag( OrderCurrentGet(), Obey_train ) ) {
// light hints only apply in the obey_train mode // light hints only apply in the obey_train mode
CheckVehicles(); CheckVehicles();
@@ -3846,6 +3842,7 @@ TController::UpdateSituation(double dt) {
fAccGravity = 0.0; // przyspieszenie wynikające z pochylenia fAccGravity = 0.0; // przyspieszenie wynikające z pochylenia
double dy; // składowa styczna grawitacji, w przedziale <0,1> double dy; // składowa styczna grawitacji, w przedziale <0,1>
double AbsAccS = 0; double AbsAccS = 0;
IsAnyDoorOpen[ side::right ] = IsAnyDoorOpen[ side::left ] = false;
TDynamicObject *p = pVehicles[0]; // pojazd na czole składu TDynamicObject *p = pVehicles[0]; // pojazd na czole składu
while (p) while (p)
{ // sprawdzenie odhamowania wszystkich połączonych pojazdów { // sprawdzenie odhamowania wszystkich połączonych pojazdów
@@ -3879,6 +3876,15 @@ TController::UpdateSituation(double dt) {
&& ( vehicle->FuseFlag ) ) { // wywalony nadmiarowy && ( vehicle->FuseFlag ) ) { // wywalony nadmiarowy
Need_TryAgain = true; // reset jak przy wywaleniu nadmiarowego Need_TryAgain = true; // reset jak przy wywaleniu nadmiarowego
} }
// check door state
auto const switchsides { p->DirectionGet() <= 0 };
IsAnyDoorOpen[ side::right ] =
IsAnyDoorOpen[ side::right ]
|| ( false == vehicle->Doors.instances[ ( switchsides ? side::left : side::right ) ].is_closed );
IsAnyDoorOpen[ side::left ] =
IsAnyDoorOpen[ side::left ]
|| ( false == vehicle->Doors.instances[ ( switchsides ? side::right : side::left ) ].is_closed );
p = p->Next(); // pojazd podłączony z tyłu (patrząc od czoła) p = p->Next(); // pojazd podłączony z tyłu (patrząc od czoła)
} }
@@ -3938,7 +3944,7 @@ TController::UpdateSituation(double dt) {
// TODO: check if this situation still happens and the hack is still needed // TODO: check if this situation still happens and the hack is still needed
if( ( false == AIControllFlag ) if( ( false == AIControllFlag )
&& ( iDrivigFlags & moveDoorOpened ) && ( iDrivigFlags & moveDoorOpened )
&& ( mvOccupied->DoorCloseCtrl != control_t::driver ) && ( mvOccupied->Doors.close_control != control_t::driver )
&& ( mvControlling->MainCtrlPos > ( mvControlling->EngineType != TEngineType::DieselEngine ? 0 : 1 ) ) ) { // for diesel 1st position is effectively 0 && ( mvControlling->MainCtrlPos > ( mvControlling->EngineType != TEngineType::DieselEngine ? 0 : 1 ) ) ) { // for diesel 1st position is effectively 0
Doors( false ); Doors( false );
} }
@@ -4470,8 +4476,8 @@ TController::UpdateSituation(double dt) {
&& ( false == TestFlag( iDrivigFlags, movePress ) ) && ( false == TestFlag( iDrivigFlags, movePress ) )
&& ( iCoupler == 0 ) && ( iCoupler == 0 )
// && ( mvOccupied->Vel > 0.0 ) // && ( mvOccupied->Vel > 0.0 )
&& ( pVehicle->MoverParameters->Couplers[ side::front ].CouplingFlag == coupling::faux ) && ( pVehicle->MoverParameters->Couplers[ end::front ].CouplingFlag == coupling::faux )
&& ( pVehicle->MoverParameters->Couplers[ side::rear ].CouplingFlag == coupling::faux ) ) { && ( pVehicle->MoverParameters->Couplers[ end::rear ].CouplingFlag == coupling::faux ) ) {
SetVelocity(0, 0, stopJoin); // 1. faza odczepiania: zatrzymanie SetVelocity(0, 0, stopJoin); // 1. faza odczepiania: zatrzymanie
// WriteLog("Zatrzymanie w celu odczepienia"); // WriteLog("Zatrzymanie w celu odczepienia");
AccPreferred = std::min( 0.0, AccPreferred ); AccPreferred = std::min( 0.0, AccPreferred );
@@ -4925,6 +4931,16 @@ TController::UpdateSituation(double dt) {
if( fStopTime < 0 ) { if( fStopTime < 0 ) {
// czas postoju przed dalszą jazdą (np. na przystanku) // czas postoju przed dalszą jazdą (np. na przystanku)
VelDesired = 0.0; // jak ma czekać, to nie ma jazdy VelDesired = 0.0; // jak ma czekać, to nie ma jazdy
// verify progress of load exchange
auto exchangetime { 0.f };
auto *vehicle { pVehicles[ 0 ] };
while( vehicle != nullptr ) {
exchangetime = std::max( exchangetime, vehicle->LoadExchangeTime() );
vehicle = vehicle->Next();
}
if( exchangetime > 0 ) {
WaitingSet( exchangetime );
}
} }
if( ( OrderCurrentGet() & Obey_train ) != 0 ) { if( ( OrderCurrentGet() & Obey_train ) != 0 ) {
@@ -5686,7 +5702,7 @@ void TController::OrderCheck()
if( OrderList[ OrderPos ] != Obey_train ) { if( OrderList[ OrderPos ] != Obey_train ) {
// reset light hints // reset light hints
m_lighthints[ side::front ] = m_lighthints[ side::rear ] = -1; m_lighthints[ end::front ] = m_lighthints[ end::rear ] = -1;
} }
if( OrderList[ OrderPos ] & ( Shunt | Connect | Obey_train ) ) { if( OrderList[ OrderPos ] & ( Shunt | Connect | Obey_train ) ) {
CheckVehicles(); // sprawdzić światła CheckVehicles(); // sprawdzić światła
@@ -6327,7 +6343,7 @@ bool TController::IsStop() const
double double
TController::TrackBlock() const { TController::TrackBlock() const {
return pVehicles[ side::front ]->fTrackBlock; return pVehicles[ end::front ]->fTrackBlock;
} }
void TController::MoveTo(TDynamicObject *to) void TController::MoveTo(TDynamicObject *to)

3
Driver.h
View File

@@ -422,6 +422,7 @@ private:
double fReady = 0.0; // poziom odhamowania wagonów double fReady = 0.0; // poziom odhamowania wagonów
bool Ready = false; // ABu: stan gotowosci do odjazdu - sprawdzenie odhamowania wagonow bool Ready = false; // ABu: stan gotowosci do odjazdu - sprawdzenie odhamowania wagonow
TDynamicObject *pVehicles[ 2 ]; // skrajne pojazdy w składzie (niekoniecznie bezpośrednio sterowane) TDynamicObject *pVehicles[ 2 ]; // skrajne pojazdy w składzie (niekoniecznie bezpośrednio sterowane)
bool IsAnyDoorOpen[ 2 ]; // state of door in the consist
// logs // logs
// methods // methods
@@ -436,7 +437,7 @@ private:
public: public:
TDynamicObject const *Vehicle() const { TDynamicObject const *Vehicle() const {
return pVehicle; } return pVehicle; }
TDynamicObject *Vehicle( side const Side ) const { TDynamicObject *Vehicle( end const Side ) const {
return pVehicles[ Side ]; } return pVehicles[ Side ]; }
private: private:
std::string OwnerName() const; std::string OwnerName() const;

699
DynObj.cpp
View File

File diff suppressed because it is too large Load Diff

9
DynObj.h
View File

@@ -271,12 +271,6 @@ private:
public: public:
TAnim *pants; // indeks obiektu animującego dla pantografu 0 TAnim *pants; // indeks obiektu animującego dla pantografu 0
double NoVoltTime; // czas od utraty zasilania double NoVoltTime; // czas od utraty zasilania
float DoorDelayL{ 0.f }; // left side door closing delay timer
float DoorDelayR{ 0.f }; // right side door closing delay timer
double dDoorMoveL; // NBMX
double dDoorMoveR; // NBMX
double dDoorstepMoveL{ 0.0 };
double dDoorstepMoveR{ 0.0 };
double dMirrorMoveL{ 0.0 }; double dMirrorMoveL{ 0.0 };
double dMirrorMoveR{ 0.0 }; double dMirrorMoveR{ 0.0 };
TSubModel *smBrakeSet; // nastawa hamulca (wajcha) TSubModel *smBrakeSet; // nastawa hamulca (wajcha)
@@ -316,6 +310,7 @@ private:
sound_source unlock { sound_placement::general }; sound_source unlock { sound_placement::general };
sound_source step_open { sound_placement::general }; sound_source step_open { sound_placement::general };
sound_source step_close { sound_placement::general }; sound_source step_close { sound_placement::general };
side placement {};
}; };
struct exchange_sounds { struct exchange_sounds {
@@ -621,7 +616,7 @@ private:
void RadioStop(); void RadioStop();
void Damage(char flag); void Damage(char flag);
void RaLightsSet(int head, int rear); void RaLightsSet(int head, int rear);
int LightList( side const Side ) const { return iInventory[ Side ]; } int LightList( end const Side ) const { return iInventory[ Side ]; }
void set_cab_lights( int const Cab, float const Level ); void set_cab_lights( int const Cab, float const Level );
TDynamicObject * FirstFind(int &coupler_nr, int cf = 1); TDynamicObject * FirstFind(int &coupler_nr, int cf = 1);
float GetEPP(); // wyliczanie sredniego cisnienia w PG float GetEPP(); // wyliczanie sredniego cisnienia w PG

74
McZapkie/MOVER.h
View File

@@ -138,10 +138,16 @@ static int const ctrain_scndpneumatic = 32; //przewody 8 atm (żółte; zasilani
static int const ctrain_heating = 64; //przewody ogrzewania WN static int const ctrain_heating = 64; //przewody ogrzewania WN
static int const ctrain_depot = 128; //nie rozłączalny podczas zwykłych manewrów (międzyczłonowy), we wpisie wartość ujemna static int const ctrain_depot = 128; //nie rozłączalny podczas zwykłych manewrów (międzyczłonowy), we wpisie wartość ujemna
// vehicle sides; exclusive // vehicle sides; exclusive
enum side { enum end {
front = 0, front = 0,
rear rear
}; };
enum side {
right = 0,
left = 1
};
// possible coupling types; can be combined // possible coupling types; can be combined
enum coupling { enum coupling {
faux = 0x0, faux = 0x0,
@@ -677,6 +683,54 @@ private:
bool breaker { true }; // device is allowed to operate bool breaker { true }; // device is allowed to operate
}; };
// basic approximation of doors
struct basic_door {
// config
// ld inputs
bool open_permit { false }; // door can be opened
bool local_open { false }; // local attempt to open the door
bool local_close { false }; // local attempt to close the door
bool remote_open { false }; // received remote signal to open the door
bool remote_close { false }; // received remote signal to close the door
// internal data
float auto_timer { -1.f }; // delay between activation of open state and closing state for automatic doors
float close_delay { 0.f }; // delay between activation of closing state and actual closing
float position { 0.f }; // current shift of the door from the closed position
float step_position { 0.f }; // current shift of the movable step from the retracted position
// ld outputs
bool is_closed { true }; // the door is fully closed
bool is_closing { false }; // the door is currently closing
bool is_opening { false }; // the door is currently opening
bool is_open { false }; // the door is fully open
};
struct door_data {
// config
control_t open_control { control_t::passenger };
float open_rate { 1.f };
control_t close_control { control_t::passenger };
float close_rate { 1.f };
float close_delay { 0.f };
int type { 2 };
float range { 0.f }; // extent of primary move/rotation
float range_out { 0.f }; // extent of shift outward, applicable for plug doors
int step_type { 2 };
float step_rate { 0.5f };
float step_range { 0.f };
bool has_lock { false };
bool has_warning { false };
bool has_autowarning { false };
float auto_duration { -1.f }; // automatic door closure delay period
float auto_velocity { -1.f }; // automatic door closure velocity threshold
// ld inputs
bool lock_enabled { true };
bool open_permit { true };
// vehicle parts
std::array<basic_door, 2> instances; // door on the right and left side of the vehicle
// ld outputs
bool is_locked { false };
};
struct water_heater { struct water_heater {
// config // config
struct heater_config_t { struct heater_config_t {
@@ -983,6 +1037,7 @@ public:
float MaxLoad = 0.f; /*masa w T lub ilosc w sztukach - ladownosc*/ float MaxLoad = 0.f; /*masa w T lub ilosc w sztukach - ladownosc*/
double OverLoadFactor = 0.0; /*ile razy moze byc przekroczona ladownosc*/ double OverLoadFactor = 0.0; /*ile razy moze byc przekroczona ladownosc*/
float LoadSpeed = 0.f; float UnLoadSpeed = 0.f;/*szybkosc na- i rozladunku jednostki/s*/ float LoadSpeed = 0.f; float UnLoadSpeed = 0.f;/*szybkosc na- i rozladunku jednostki/s*/
#ifdef EU07_USEOLDDOORCODE
int DoorOpenCtrl = 0; int DoorCloseCtrl = 0; /*0: przez pasazera, 1: przez maszyniste, 2: samoczynne (zamykanie)*/ int DoorOpenCtrl = 0; int DoorCloseCtrl = 0; /*0: przez pasazera, 1: przez maszyniste, 2: samoczynne (zamykanie)*/
double DoorStayOpen = 0.0; /*jak dlugo otwarte w przypadku DoorCloseCtrl=2*/ double DoorStayOpen = 0.0; /*jak dlugo otwarte w przypadku DoorCloseCtrl=2*/
bool DoorClosureWarning = false; /*czy jest ostrzeganie przed zamknieciem*/ bool DoorClosureWarning = false; /*czy jest ostrzeganie przed zamknieciem*/
@@ -994,6 +1049,7 @@ public:
double PlatformSpeed = 0.5; /*szybkosc stopnia*/ double PlatformSpeed = 0.5; /*szybkosc stopnia*/
double PlatformMaxShift { 0.0 }; /*wysuniecie stopnia*/ double PlatformMaxShift { 0.0 }; /*wysuniecie stopnia*/
int PlatformOpenMethod { 2 }; /*sposob animacji stopnia*/ int PlatformOpenMethod { 2 }; /*sposob animacji stopnia*/
#endif
double MirrorMaxShift { 90.0 }; double MirrorMaxShift { 90.0 };
bool ScndS = false; /*Czy jest bocznikowanie na szeregowej*/ bool ScndS = false; /*Czy jest bocznikowanie na szeregowej*/
double SpeedCtrlDelay = 2; /*opoznienie dzialania tempomatu z wybieralna predkoscia*/ double SpeedCtrlDelay = 2; /*opoznienie dzialania tempomatu z wybieralna predkoscia*/
@@ -1057,6 +1113,7 @@ public:
bool WaterCircuitsLink { false }; // optional connection between water circuits bool WaterCircuitsLink { false }; // optional connection between water circuits
heat_data dizel_heat; heat_data dizel_heat;
std::array<cooling_fan, 2> MotorBlowers; std::array<cooling_fan, 2> MotorBlowers;
door_data Doors;
int BrakeCtrlPos = -2; /*nastawa hamulca zespolonego*/ int BrakeCtrlPos = -2; /*nastawa hamulca zespolonego*/
double BrakeCtrlPosR = 0.0; /*nastawa hamulca zespolonego - plynna dla FV4a*/ double BrakeCtrlPosR = 0.0; /*nastawa hamulca zespolonego - plynna dla FV4a*/
@@ -1200,13 +1257,14 @@ public:
std::string LoadQuantity; // jednostki miary std::string LoadQuantity; // jednostki miary
int LoadStatus = 0; //+1=trwa rozladunek,+2=trwa zaladunek,+4=zakończono,0=zaktualizowany model int LoadStatus = 0; //+1=trwa rozladunek,+2=trwa zaladunek,+4=zakończono,0=zaktualizowany model
double LastLoadChangeTime = 0.0; //raz (roz)ładowania double LastLoadChangeTime = 0.0; //raz (roz)ładowania
#ifdef EU07_USEOLDDOORCODE
bool DoorBlocked = false; //Czy jest blokada drzwi bool DoorBlocked = false; //Czy jest blokada drzwi
bool DoorLockEnabled { true }; bool DoorLockEnabled { true };
bool DoorLeftOpened = false; //stan drzwi bool DoorLeftOpened = false; //stan drzwi
double DoorLeftOpenTimer { -1.0 }; // left door closing timer for automatic door type double DoorLeftOpenTimer { -1.0 }; // left door closing timer for automatic door type
bool DoorRightOpened = false; bool DoorRightOpened = false;
double DoorRightOpenTimer{ -1.0 }; // right door closing timer for automatic door type double DoorRightOpenTimer{ -1.0 }; // right door closing timer for automatic door type
#endif
bool PantFrontUp = false; //stan patykow 'Winger 160204 bool PantFrontUp = false; //stan patykow 'Winger 160204
bool PantRearUp = false; bool PantRearUp = false;
bool PantFrontSP = true; //dzwiek patykow 'Winger 010304 bool PantFrontSP = true; //dzwiek patykow 'Winger 010304
@@ -1360,8 +1418,8 @@ public:
bool FuelPumpSwitchOff( bool State, range_t const Notify = range_t::consist ); // fuel pump state toggle bool FuelPumpSwitchOff( bool State, range_t const Notify = range_t::consist ); // fuel pump state toggle
bool OilPumpSwitch( bool State, range_t const Notify = range_t::consist ); // oil pump state toggle bool OilPumpSwitch( bool State, range_t const Notify = range_t::consist ); // oil pump state toggle
bool OilPumpSwitchOff( bool State, range_t const Notify = range_t::consist ); // oil pump state toggle bool OilPumpSwitchOff( bool State, range_t const Notify = range_t::consist ); // oil pump state toggle
bool MotorBlowersSwitch( bool State, side const Side, range_t const Notify = range_t::consist ); // traction motor fan state toggle bool MotorBlowersSwitch( bool State, end const Side, range_t const Notify = range_t::consist ); // traction motor fan state toggle
bool MotorBlowersSwitchOff( bool State, side const Side, range_t const Notify = range_t::consist ); // traction motor fan state toggle bool MotorBlowersSwitchOff( bool State, end const Side, range_t const Notify = range_t::consist ); // traction motor fan state toggle
bool MainSwitch( bool const State, range_t const Notify = range_t::consist );/*! wylacznik glowny*/ bool MainSwitch( bool const State, range_t const Notify = range_t::consist );/*! wylacznik glowny*/
void MainSwitch_( bool const State ); void MainSwitch_( bool const State );
bool ConverterSwitch( bool State, range_t const Notify = range_t::consist );/*! wl/wyl przetwornicy*/ bool ConverterSwitch( bool State, range_t const Notify = range_t::consist );/*! wl/wyl przetwornicy*/
@@ -1414,11 +1472,11 @@ public:
/* funckje dla wagonow*/ /* funckje dla wagonow*/
bool AssignLoad( std::string const &Name, float const Amount = 0.f ); bool AssignLoad( std::string const &Name, float const Amount = 0.f );
bool LoadingDone(double LSpeed, std::string const &Loadname); bool LoadingDone(double LSpeed, std::string const &Loadname);
bool DoorLeft(bool State, range_t const Notify = range_t::consist ); //obsluga drzwi lewych bool PermitDoors( side const Door, range_t const Notify = range_t::consist );
bool DoorRight(bool State, range_t const Notify = range_t::consist ); //obsluga drzwi prawych bool OperateDoors( side const Door, bool const State, range_t const Notify = range_t::consist );
bool DoorBlockedFlag(void); //sprawdzenie blokady drzwi bool LockDoors( bool const State, range_t const Notify = range_t::consist );
bool signal_departure( bool const State, range_t const Notify = range_t::consist ); // toggles departure warning bool signal_departure( bool const State, range_t const Notify = range_t::consist ); // toggles departure warning
void update_autonomous_doors( double const Deltatime ); // automatic door controller update void update_doors( double const Deltatime ); // door controller update
/* funkcje dla samochodow*/ /* funkcje dla samochodow*/
bool ChangeOffsetH(double DeltaOffset); bool ChangeOffsetH(double DeltaOffset);

612
McZapkie/Mover.cpp
View File

@@ -815,8 +815,8 @@ void TMoverParameters::UpdateBatteryVoltage(double dt)
// HACK: emulate low voltage generator powered directly by the diesel engine // HACK: emulate low voltage generator powered directly by the diesel engine
auto const converteractive{ ( auto const converteractive{ (
( ConverterFlag ) ( ConverterFlag )
|| ( ( ( Couplers[ side::front ].CouplingFlag & coupling::permanent ) != 0 ) && Couplers[ side::front ].Connected->ConverterFlag ) || ( ( ( Couplers[ end::front ].CouplingFlag & coupling::permanent ) != 0 ) && Couplers[ end::front ].Connected->ConverterFlag )
|| ( ( ( Couplers[ side::rear ].CouplingFlag & coupling::permanent ) != 0 ) && Couplers[ side::rear ].Connected->ConverterFlag ) ) || ( ( ( Couplers[ end::rear ].CouplingFlag & coupling::permanent ) != 0 ) && Couplers[ end::rear ].Connected->ConverterFlag ) )
|| ( ( EngineType == TEngineType::DieselElectric ) && ( true == Mains ) ) || ( ( EngineType == TEngineType::DieselElectric ) && ( true == Mains ) )
|| ( ( EngineType == TEngineType::DieselEngine ) && ( true == Mains ) ) }; || ( ( EngineType == TEngineType::DieselEngine ) && ( true == Mains ) ) };
@@ -1119,7 +1119,7 @@ double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShap
for( int side = 0; side < 2; ++side ) { for( int side = 0; side < 2; ++side ) {
// przekazywanie napiec // przekazywanie napiec
auto const oppositeside = ( side == side::front ? side::rear : side::front ); auto const oppositeside = ( side == end::front ? end::rear : end::front );
if( ( Couplers[ side ].CouplingFlag & ctrain_power ) if( ( Couplers[ side ].CouplingFlag & ctrain_power )
|| ( ( Heating ) || ( ( Heating )
@@ -1135,7 +1135,7 @@ double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShap
} }
} }
hvc = Couplers[ side::front ].power_high.voltage + Couplers[ side::rear ].power_high.voltage; hvc = Couplers[ end::front ].power_high.voltage + Couplers[ end::rear ].power_high.voltage;
if( std::abs( PantFrontVolt ) + std::abs( PantRearVolt ) < 1.0 ) { if( std::abs( PantFrontVolt ) + std::abs( PantRearVolt ) < 1.0 ) {
// bez napiecia... // bez napiecia...
@@ -1151,9 +1151,9 @@ double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShap
&& ( Couplers[ side ].CouplingFlag & ctrain_heating ) ) ) { && ( Couplers[ side ].CouplingFlag & ctrain_heating ) ) ) {
auto const &connectedcoupler = auto const &connectedcoupler =
Couplers[ side ].Connected->Couplers[ Couplers[ side ].Connected->Couplers[
( Couplers[ side ].ConnectedNr == side::front ? ( Couplers[ side ].ConnectedNr == end::front ?
side::rear : end::rear :
side::front ) ]; end::front ) ];
Couplers[ side ].power_high.current = Couplers[ side ].power_high.current =
connectedcoupler.power_high.current connectedcoupler.power_high.current
+ Itot * Couplers[ side ].power_high.voltage / hvc; // obciążenie rozkladane stosownie do napiec + Itot * Couplers[ side ].power_high.voltage / hvc; // obciążenie rozkladane stosownie do napiec
@@ -1175,9 +1175,9 @@ double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShap
&& ( Couplers[ side ].CouplingFlag & ctrain_heating ) ) ) { && ( Couplers[ side ].CouplingFlag & ctrain_heating ) ) ) {
auto const &connectedcoupler = auto const &connectedcoupler =
Couplers[ side ].Connected->Couplers[ Couplers[ side ].Connected->Couplers[
( Couplers[ side ].ConnectedNr == side::front ? ( Couplers[ side ].ConnectedNr == end::front ?
side::rear : end::rear :
side::front ) ]; end::front ) ];
TotalCurrent += connectedcoupler.power_high.current; TotalCurrent += connectedcoupler.power_high.current;
Couplers[ side ].power_high.current = 0.0; Couplers[ side ].power_high.current = 0.0;
} }
@@ -1465,7 +1465,7 @@ void TMoverParameters::compute_movement_( double const Deltatime ) {
} }
BrakeSlippingTimer += Deltatime; BrakeSlippingTimer += Deltatime;
// automatic doors // automatic doors
update_autonomous_doors( Deltatime ); update_doors( Deltatime );
} }
double TMoverParameters::ShowEngineRotation(int VehN) double TMoverParameters::ShowEngineRotation(int VehN)
@@ -2643,7 +2643,7 @@ bool TMoverParameters::OilPumpSwitchOff( bool State, range_t const Notify ) {
return ( OilPump.is_disabled != initialstate ); return ( OilPump.is_disabled != initialstate );
} }
bool TMoverParameters::MotorBlowersSwitch( bool State, side const Side, range_t const Notify ) { bool TMoverParameters::MotorBlowersSwitch( bool State, end const Side, range_t const Notify ) {
auto &fan { MotorBlowers[ Side ] }; auto &fan { MotorBlowers[ Side ] };
@@ -2659,7 +2659,7 @@ bool TMoverParameters::MotorBlowersSwitch( bool State, side const Side, range_t
if( Notify != range_t::local ) { if( Notify != range_t::local ) {
SendCtrlToNext( SendCtrlToNext(
( Side == side::front ? "MotorBlowersFrontSwitch" : "MotorBlowersRearSwitch" ), ( Side == end::front ? "MotorBlowersFrontSwitch" : "MotorBlowersRearSwitch" ),
( fan.is_enabled ? 1 : 0 ), ( fan.is_enabled ? 1 : 0 ),
CabNo, CabNo,
( Notify == range_t::unit ? ( Notify == range_t::unit ?
@@ -2670,7 +2670,7 @@ bool TMoverParameters::MotorBlowersSwitch( bool State, side const Side, range_t
return ( fan.is_enabled != initialstate ); return ( fan.is_enabled != initialstate );
} }
bool TMoverParameters::MotorBlowersSwitchOff( bool State, side const Side, range_t const Notify ) { bool TMoverParameters::MotorBlowersSwitchOff( bool State, end const Side, range_t const Notify ) {
auto &fan { MotorBlowers[ Side ] }; auto &fan { MotorBlowers[ Side ] };
@@ -2686,7 +2686,7 @@ bool TMoverParameters::MotorBlowersSwitchOff( bool State, side const Side, range
if( Notify != range_t::local ) { if( Notify != range_t::local ) {
SendCtrlToNext( SendCtrlToNext(
( Side == side::front ? "MotorBlowersFrontSwitchOff" : "MotorBlowersRearSwitchOff" ), ( Side == end::front ? "MotorBlowersFrontSwitchOff" : "MotorBlowersRearSwitchOff" ),
( fan.is_disabled ? 1 : 0 ), ( fan.is_disabled ? 1 : 0 ),
CabNo, CabNo,
( Notify == range_t::unit ? ( Notify == range_t::unit ?
@@ -3314,11 +3314,11 @@ void TMoverParameters::CompressorCheck(double dt)
{ // sprawdzić możliwe warunki wyłączenia sprężarki { // sprawdzić możliwe warunki wyłączenia sprężarki
if (CompressorPower == 5) // jeśli zasilanie z sąsiedniego członu if (CompressorPower == 5) // jeśli zasilanie z sąsiedniego członu
{ // zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1) { // zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1)
if( Couplers[ side::rear ].Connected != NULL ) { if( Couplers[ end::rear ].Connected != NULL ) {
CompressorFlag = ( CompressorFlag = (
( ( Couplers[ side::rear ].Connected->CompressorAllow ) || ( CompressorStart == start_t::automatic ) ) ( ( Couplers[ end::rear ].Connected->CompressorAllow ) || ( CompressorStart == start_t::automatic ) )
&& ( CompressorAllowLocal ) && ( CompressorAllowLocal )
&& ( Couplers[ side::rear ].Connected->ConverterFlag ) ); && ( Couplers[ end::rear ].Connected->ConverterFlag ) );
} }
else { else {
// bez tamtego członu nie zadziała // bez tamtego członu nie zadziała
@@ -3327,11 +3327,11 @@ void TMoverParameters::CompressorCheck(double dt)
} }
else if (CompressorPower == 4) // jeśli zasilanie z poprzedniego członu else if (CompressorPower == 4) // jeśli zasilanie z poprzedniego członu
{ // zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1) { // zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1)
if( Couplers[ side::front ].Connected != NULL ) { if( Couplers[ end::front ].Connected != NULL ) {
CompressorFlag = ( CompressorFlag = (
( ( Couplers[ side::front ].Connected->CompressorAllow ) || ( CompressorStart == start_t::automatic ) ) ( ( Couplers[ end::front ].Connected->CompressorAllow ) || ( CompressorStart == start_t::automatic ) )
&& ( CompressorAllowLocal ) && ( CompressorAllowLocal )
&& ( Couplers[ side::front ].Connected->ConverterFlag ) ); && ( Couplers[ end::front ].Connected->ConverterFlag ) );
} }
else { else {
CompressorFlag = false; // bez tamtego członu nie zadziała CompressorFlag = false; // bez tamtego członu nie zadziała
@@ -3390,11 +3390,11 @@ void TMoverParameters::CompressorCheck(double dt)
// or if the switch is on and the pressure isn't maxed // or if the switch is on and the pressure isn't maxed
if( CompressorPower == 5 ) // jeśli zasilanie z następnego członu if( CompressorPower == 5 ) // jeśli zasilanie z następnego członu
{ // zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1) { // zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1)
if( Couplers[ side::rear ].Connected != NULL ) { if( Couplers[ end::rear ].Connected != NULL ) {
CompressorFlag = ( CompressorFlag = (
( ( Couplers[ side::rear ].Connected->CompressorAllow ) || ( CompressorStart == start_t::automatic ) ) ( ( Couplers[ end::rear ].Connected->CompressorAllow ) || ( CompressorStart == start_t::automatic ) )
&& ( CompressorAllowLocal ) && ( CompressorAllowLocal )
&& ( Couplers[ side::rear ].Connected->ConverterFlag ) ); && ( Couplers[ end::rear ].Connected->ConverterFlag ) );
} }
else { else {
// bez tamtego członu nie zadziała // bez tamtego członu nie zadziała
@@ -3403,11 +3403,11 @@ void TMoverParameters::CompressorCheck(double dt)
} }
else if( CompressorPower == 4 ) // jeśli zasilanie z poprzedniego członu else if( CompressorPower == 4 ) // jeśli zasilanie z poprzedniego członu
{ // zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1) { // zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1)
if( Couplers[ side::front ].Connected != NULL ) { if( Couplers[ end::front ].Connected != NULL ) {
CompressorFlag = ( CompressorFlag = (
( ( Couplers[ side::front ].Connected->CompressorAllow ) || ( CompressorStart == start_t::automatic ) ) ( ( Couplers[ end::front ].Connected->CompressorAllow ) || ( CompressorStart == start_t::automatic ) )
&& ( CompressorAllowLocal ) && ( CompressorAllowLocal )
&& ( Couplers[ side::front ].Connected->ConverterFlag ) ); && ( Couplers[ end::front ].Connected->ConverterFlag ) );
} }
else { else {
CompressorFlag = false; // bez tamtego członu nie zadziała CompressorFlag = false; // bez tamtego członu nie zadziała
@@ -3961,15 +3961,15 @@ void TMoverParameters::ComputeTotalForce(double dt, double dt1, bool FullVer)
Voltage = RunningTraction.TractionVoltage * DirAbsolute; // ActiveDir*CabNo; Voltage = RunningTraction.TractionVoltage * DirAbsolute; // ActiveDir*CabNo;
} // bo nie dzialalo } // bo nie dzialalo
else if( ( EngineType == TEngineType::ElectricInductionMotor ) else if( ( EngineType == TEngineType::ElectricInductionMotor )
|| ( ( ( Couplers[ side::front ].CouplingFlag & ctrain_power ) == ctrain_power ) || ( ( ( Couplers[ end::front ].CouplingFlag & ctrain_power ) == ctrain_power )
|| ( ( Couplers[ side::rear ].CouplingFlag & ctrain_power ) == ctrain_power ) ) ) { || ( ( Couplers[ end::rear ].CouplingFlag & ctrain_power ) == ctrain_power ) ) ) {
// potem ulepszyc! pantogtrafy! // potem ulepszyc! pantogtrafy!
Voltage = Voltage =
std::max( std::max(
RunningTraction.TractionVoltage, RunningTraction.TractionVoltage,
std::max( std::max(
Couplers[ side::front ].power_high.voltage, Couplers[ end::front ].power_high.voltage,
Couplers[ side::rear ].power_high.voltage ) ); Couplers[ end::rear ].power_high.voltage ) );
} }
else { else {
Voltage = 0; Voltage = 0;
@@ -5058,8 +5058,10 @@ double TMoverParameters::TractionForce( double dt ) {
} }
dtrans = Hamulec->GetEDBCP(); dtrans = Hamulec->GetEDBCP();
if (((DoorLeftOpened) || (DoorRightOpened))) if( ( ( false == Doors.instances[ side::left ].is_closed )
|| ( false == Doors.instances[ side::right ].is_closed ) ) ) {
DynamicBrakeFlag = true; DynamicBrakeFlag = true;
}
else if (((dtrans < 0.25) && (LocHandle->GetCP() < 0.25) && (AnPos < 0.01)) || else if (((dtrans < 0.25) && (LocHandle->GetCP() < 0.25) && (AnPos < 0.01)) ||
((dtrans < 0.25) && (ShuntModeAllow) && (LocalBrakePosA < 0.01))) ((dtrans < 0.25) && (ShuntModeAllow) && (LocalBrakePosA < 0.01)))
DynamicBrakeFlag = false; DynamicBrakeFlag = false;
@@ -6719,49 +6721,64 @@ bool TMoverParameters::LoadingDone(double const LSpeed, std::string const &Loadn
return ( LoadStatus >= 4 ); return ( LoadStatus >= 4 );
} }
// ************************************************************************************************* bool TMoverParameters::PermitDoors( side const Door, range_t const Notify ) {
// Q: 20160713
// Zwraca informacje o działającej blokadzie drzwi bool const initialstate { Doors.instances[Door].open_permit };
// *************************************************************************************************
bool TMoverParameters::DoorBlockedFlag( void ) { if( ( true == Battery )
// TBD: configurable lock activation threshold? && ( false == Doors.is_locked ) ) {
return (
( true == DoorBlocked ) Doors.instances[ Door ].open_permit = true;
&& ( true == DoorLockEnabled ) }
&& ( Vel >= 10.0 ) );
if( Notify != range_t::local ) {
SendCtrlToNext(
"DoorPermit",
( Door == ( CabNo > 0 ? side::left : side::right ) ? // 1=lewe, 2=prawe (swap if reversed)
1 :
2 ),
CabNo,
( Notify == range_t::unit ?
coupling::control | coupling::permanent :
coupling::control ) );
}
return ( Doors.instances[ Door ].open_permit != initialstate );
} }
// ************************************************************************************************* bool TMoverParameters::OperateDoors( side const Door, bool const State, range_t const Notify ) {
// Q: 20160713
// Otwiera / zamyka lewe drzwi
// *************************************************************************************************
// NOTE: door methods work regardless of vehicle door control type,
// but commands issued through the command system work only for vehicles which accept remote door control
bool TMoverParameters::DoorLeft(bool State, range_t const Notify ) {
if( DoorLeftOpened == State ) { auto &door { Doors.instances[ Door ] };
/*
if( ( State == true ? door.is_open : door.is_closed ) ) {
// TBD: should the command be passed to other vehicles regardless of whether it affected the primary target? // TBD: should the command be passed to other vehicles regardless of whether it affected the primary target?
// (for the time being no, methods are often invoked blindly which would lead to commands spam) // (for the time being no, methods are often invoked blindly which would lead to commands spam)
return false; return false;
} }
*/
bool result { false }; bool result { false };
if( ( Battery == true ) if( Battery == true ) {
&& ( ( State == false ) // closing door works always, but if the lock is engaged they can't be opened
|| ( DoorBlockedFlag() == false ) ) ) {
DoorLeftOpened = State; if( Notify != range_t::local ) {
result = true; door.remote_open = State;
door.remote_close = ( false == State );
if( DoorCloseCtrl == control_t::autonomous ) {
// activate or disable the door timer depending on whether door were open or closed
// NOTE: this it a local-only operation but shouldn't be an issue as automatic door are operated locally anyway
DoorLeftOpenTimer = (
State == true ?
DoorStayOpen :
-1.0 );
} }
else {
door.local_open = State;
door.local_close = ( false == State );
}
result = true;
/*
// activate or disable the door timer depending on whether door were open or closed
// NOTE: this is a local-only operation but shouldn't be an issue as automatic door are operated locally anyway
door.auto_timer = (
( ( State == true ) && ( Notify == range_t::local ) ) ?
Doors.auto_duration :
-1.0 );
*/
} }
if( Notify != range_t::local ) { if( Notify != range_t::local ) {
@@ -6769,7 +6786,7 @@ bool TMoverParameters::DoorLeft(bool State, range_t const Notify ) {
( State == true ? ( State == true ?
"DoorOpen" : "DoorOpen" :
"DoorClose" ), "DoorClose" ),
( CabNo > 0 ? // 1=lewe, 2=prawe (swap if reversed) ( Door == ( CabNo > 0 ? side::left : side::right ) ? // 1=lewe, 2=prawe (swap if reversed)
1 : 1 :
2 ), 2 ),
CabNo, CabNo,
@@ -6781,54 +6798,24 @@ bool TMoverParameters::DoorLeft(bool State, range_t const Notify ) {
return result; return result;
} }
// ************************************************************************************************* // toggle door lock
// Q: 20160713 bool TMoverParameters::LockDoors( bool const State, range_t const Notify ) {
// Otwiera / zamyka prawe drzwi
// *************************************************************************************************
// NOTE: door methods work regardless of vehicle door control type,
// but commands issued through the command system work only for vehicles which accept remote door control
bool TMoverParameters::DoorRight(bool State, range_t const Notify ) {
if( DoorRightOpened == State ) { Doors.lock_enabled = State;
// TBD: should the command be passed to other vehicles regardless of whether it affected the primary target?
// (for the time being no, methods are often invoked blindly which would lead to commands spam)
return false;
}
bool result { false };
if( ( Battery == true )
&& ( ( State == false )
|| ( DoorBlockedFlag() == false ) ) ) {
DoorRightOpened = State;
result = true;
if( DoorCloseCtrl == control_t::autonomous ) {
// activate or disable the door timer depending on whether door were open or closed
// NOTE: this it a local-only operation but shouldn't be an issue as automatic door are operated locally anyway
DoorRightOpenTimer = (
State == true ?
DoorStayOpen :
-1.0 );
}
}
if( Notify != range_t::local ) { if( Notify != range_t::local ) {
// wysłanie wyłączenia do pozostałych?
SendCtrlToNext( SendCtrlToNext(
"DoorLock",
( State == true ? ( State == true ?
"DoorOpen" : 1 :
"DoorClose" ), 0 ),
( CabNo > 0 ? // 1=lewe, 2=prawe (swap if reversed)
2 :
1 ),
CabNo, CabNo,
( Notify == range_t::unit ? ( Notify == range_t::unit ?
coupling::control | coupling::permanent : coupling::control | coupling::permanent :
coupling::control ) ); coupling::control ) );
} }
return result; return true;
} }
// toggles departure warning // toggles departure warning
@@ -6859,37 +6846,165 @@ TMoverParameters::signal_departure( bool const State, range_t const Notify ) {
// automatic door controller update // automatic door controller update
void void
TMoverParameters::update_autonomous_doors( double const Deltatime ) { TMoverParameters::update_doors( double const Deltatime ) {
if( DoorCloseCtrl != control_t::autonomous ) { return; } if( Doors.range == 0.f ) { return; } // HACK: crude way to distinguish vehicles with actual doors
if( ( false == DoorLeftOpened )
&& ( false == DoorRightOpened ) ) { return; }
if( DoorStayOpen > 0.0 ) { // NBMX Obsluga drzwi, MC: zuniwersalnione
// update door timers if the door close after defined time auto const localopencontrol {
if( DoorLeftOpenTimer >= 0.0 ) { DoorLeftOpenTimer -= Deltatime; } ( Doors.open_control == control_t::passenger )
if( DoorRightOpenTimer >= 0.0 ) { DoorRightOpenTimer -= Deltatime; } || ( Doors.open_control == control_t::mixed ) };
} auto const remoteopencontrol {
if( ( LoadStatus & ( 2 | 1 ) ) != 0 ) { ( Doors.open_control == control_t::driver )
// if there's load exchange in progress, reset the timer(s) for already open doors || ( Doors.open_control == control_t::conductor )
if( true == DoorLeftOpened ) { DoorLeftOpenTimer = DoorStayOpen; } || ( Doors.open_control == control_t::mixed ) };
if( true == DoorRightOpened ) { DoorRightOpenTimer = DoorStayOpen; } auto const localclosecontrol {
} ( Doors.close_control == control_t::passenger )
// the door are closed if their timer goes below 0, or if the vehicle is moving at > 10 km/h || ( Doors.close_control == control_t::mixed ) };
auto const closingspeed { 10.0 }; auto const remoteclosecontrol {
// NOTE: timer value of 0 is 'special' as it means the door will stay open until vehicle is moving ( Doors.close_control == control_t::driver )
if( true == DoorLeftOpened ) { || ( Doors.close_control == control_t::conductor )
if( ( ( DoorStayOpen > 0.0 ) && ( DoorLeftOpenTimer < 0.0 ) ) || ( Doors.close_control == control_t::mixed ) };
|| ( Vel > closingspeed ) ) {
// close the door and set the timer to expired state (closing may happen sooner if vehicle starts moving) Doors.is_locked =
DoorLeft( false, range_t::local ); ( true == Doors.has_lock )
&& ( true == Doors.lock_enabled )
&& ( Vel >= 10.0 );
for( auto &door : Doors.instances ) {
door.open_permit = door.open_permit && ( false == door.remote_close ) && ( false == Doors.is_locked );
door.is_open =
( door.position >= Doors.range )
&& ( door.step_position >= ( Doors.step_range != 0.f ? 1.f : 0.f ) );
door.is_closed =
( door.position <= 0.f )
&& ( door.step_position <= 0.f );
door.local_open = door.local_open && ( false == door.is_open ) && ( Doors.open_permit || door.open_permit );
door.remote_open = door.remote_open && ( false == door.is_open ) && ( Doors.open_permit || door.open_permit );
door.local_close = door.local_close && ( false == door.is_closed );
door.remote_close = door.remote_close && ( false == door.is_closed );
auto const openrequest {
( localopencontrol && door.local_open )
|| ( remoteopencontrol && door.remote_open ) };
auto const autocloserequest {
( ( Doors.auto_velocity != -1.f ) && ( Vel > Doors.auto_velocity ) )
|| ( ( Doors.auto_duration != -1.f ) && ( door.auto_timer <= 0.f ) ) };
auto const closerequest {
( remoteclosecontrol && door.remote_close )
|| ( localclosecontrol && door.local_close )
|| ( autocloserequest && door.local_close ) };
door.is_opening =
( false == door.is_open )
&& ( false == closerequest )
&& ( door.is_opening || openrequest );
door.is_closing =
( false == door.is_closed )
&& ( false == openrequest )
&& ( door.is_closing || closerequest );
if( true == door.is_opening ) {
door.auto_timer = (
( remoteopencontrol && door.remote_open ) ?
-1.f :
Doors.auto_duration );
}
// doors
if( ( true == door.is_opening )
&& ( door.position < Doors.range ) ) {
// open door
if( ( TrainType == dt_EZT )
|| ( TrainType == dt_DMU ) ) {
// multi-unit vehicles typically open door only after unfolding the doorstep
if( ( Doors.step_range == 0.f ) // no wait if no doorstep
|| ( Doors.step_type == 2 ) // no wait for rotating doorstep
|| ( door.step_position == 1.f ) ) {
door.position = std::min<float>(
Doors.range,
door.position + Doors.open_rate * Deltatime );
}
}
else {
door.position = std::min<float>(
Doors.range,
door.position + Doors.open_rate * Deltatime );
}
door.close_delay = 0.f;
}
if( ( true == door.is_closing )
&& ( door.position > 0.f ) ) {
// close door
door.close_delay += Deltatime;
if( door.close_delay > Doors.close_delay ) {
door.position = std::max<float>(
0.f,
door.position - Doors.close_rate * Deltatime );
}
}
// doorsteps
if( ( true == door.is_opening )
&& ( Doors.step_range != 0.f )
&& ( door.step_position < 1.f ) ) {
// unfold left doorstep
door.step_position = std::min<float>(
1.f,
door.step_position + Doors.step_rate * Deltatime );
}
if( ( true == door.is_closing )
&& ( door.step_position > 0.f )
&& ( door.close_delay > Doors.close_delay ) ) {
// fold left doorstep
if( ( TrainType == dt_EZT )
|| ( TrainType == dt_DMU ) ) {
// multi-unit vehicles typically fold the doorstep only after closing the door
if( door.position == 0.f ) {
door.step_position = std::max<float>(
0.f,
door.step_position - Doors.step_rate * Deltatime );
}
}
else {
door.step_position = std::max<float>(
0.f,
door.step_position - Doors.step_rate * Deltatime );
}
} }
} }
if( true == DoorRightOpened ) {
if( ( ( DoorStayOpen > 0.0 ) && ( DoorRightOpenTimer < 0.0 ) ) if( ( false == Doors.instances[side::right].is_open )
|| ( Vel > closingspeed ) ) { && ( false == Doors.instances[side::left].is_open ) ) { return; }
// close the door and set the timer to expired state (closing may happen sooner if vehicle starts moving)
DoorRight( false, range_t::local ); if( Doors.auto_duration > 0.f ) {
// update door timers if the door close after defined time
for( auto &door : Doors.instances ) {
if( false == door.is_open ) { continue; }
if( door.auto_timer > 0.f ) {
door.auto_timer -= Deltatime;
}
// if there's load exchange in progress, reset the timer(s) for already open doors
if( ( door.auto_timer != -1.f )
&& ( ( LoadStatus & ( 2 | 1 ) ) != 0 ) ) {
door.auto_timer = Doors.auto_duration;
}
}
}
// the door are closed if their timer goes below 0, or if the vehicle is moving faster than defined threshold
std::array<side, 2> const doorids { side::right, side::left };
for( auto const doorid : doorids ) {
auto const &door { Doors.instances[ doorid ] };
if( true == door.is_open ) {
if( ( ( Doors.auto_velocity != -1.f ) && ( Vel > Doors.auto_velocity ) )
|| ( ( door.auto_timer != -1.f ) && ( door.auto_timer <= 0.f ) ) ) {
// close the door and set the timer to expired state (closing may happen sooner if vehicle starts moving)
OperateDoors( doorid, false, range_t::local );
}
} }
} }
} }
@@ -6982,17 +7097,17 @@ std::string TMoverParameters::EngineDescription(int what) const
double TMoverParameters::GetTrainsetVoltage(void) double TMoverParameters::GetTrainsetVoltage(void)
{//ABu: funkcja zwracajaca napiecie dla calego skladu, przydatna dla EZT {//ABu: funkcja zwracajaca napiecie dla calego skladu, przydatna dla EZT
return std::max( return std::max(
( ( ( Couplers[side::front].Connected ) ( ( ( Couplers[end::front].Connected )
&& ( ( Couplers[ side::front ].CouplingFlag & ctrain_power ) && ( ( Couplers[ end::front ].CouplingFlag & ctrain_power )
|| ( ( Heating ) || ( ( Heating )
&& ( Couplers[ side::front ].CouplingFlag & ctrain_heating ) ) ) ) ? && ( Couplers[ end::front ].CouplingFlag & ctrain_heating ) ) ) ) ?
Couplers[side::front].Connected->Couplers[ Couplers[side::front].ConnectedNr ].power_high.voltage : Couplers[end::front].Connected->Couplers[ Couplers[end::front].ConnectedNr ].power_high.voltage :
0.0 ), 0.0 ),
( ( ( Couplers[side::rear].Connected ) ( ( ( Couplers[end::rear].Connected )
&& ( ( Couplers[ side::rear ].CouplingFlag & ctrain_power ) && ( ( Couplers[ end::rear ].CouplingFlag & ctrain_power )
|| ( ( Heating ) || ( ( Heating )
&& ( Couplers[ side::rear ].CouplingFlag & ctrain_heating ) ) ) ) ? && ( Couplers[ end::rear ].CouplingFlag & ctrain_heating ) ) ) ) ?
Couplers[ side::rear ].Connected->Couplers[ Couplers[ side::rear ].ConnectedNr ].power_high.voltage : Couplers[ end::rear ].Connected->Couplers[ Couplers[ end::rear ].ConnectedNr ].power_high.voltage :
0.0 ) ); 0.0 ) );
} }
@@ -7976,7 +8091,7 @@ void TMoverParameters::LoadFIZ_Brake( std::string const &line ) {
void TMoverParameters::LoadFIZ_Doors( std::string const &line ) { void TMoverParameters::LoadFIZ_Doors( std::string const &line ) {
std::map<std::string, int> doorcontrols { std::map<std::string, control_t> doorcontrols {
{ "Passenger", control_t::passenger }, { "Passenger", control_t::passenger },
{ "AutomaticCtrl", control_t::autonomous }, { "AutomaticCtrl", control_t::autonomous },
{ "DriverCtrl", control_t::driver }, { "DriverCtrl", control_t::driver },
@@ -7986,7 +8101,7 @@ void TMoverParameters::LoadFIZ_Doors( std::string const &line ) {
// opening method // opening method
{ {
auto lookup = doorcontrols.find( extract_value( "OpenCtrl", line ) ); auto lookup = doorcontrols.find( extract_value( "OpenCtrl", line ) );
DoorOpenCtrl = Doors.open_control =
lookup != doorcontrols.end() ? lookup != doorcontrols.end() ?
lookup->second : lookup->second :
control_t::passenger; control_t::passenger;
@@ -7994,37 +8109,60 @@ void TMoverParameters::LoadFIZ_Doors( std::string const &line ) {
// closing method // closing method
{ {
auto lookup = doorcontrols.find( extract_value( "CloseCtrl", line ) ); auto lookup = doorcontrols.find( extract_value( "CloseCtrl", line ) );
DoorCloseCtrl = Doors.close_control =
lookup != doorcontrols.end() ? lookup != doorcontrols.end() ?
lookup->second : lookup->second :
control_t::passenger; control_t::passenger;
if( Doors.close_control == control_t::autonomous ) {
// convert legacy method
Doors.close_control = control_t::passenger;
Doors.auto_velocity = 10.0;
}
}
// automatic closing conditions
extract_value( Doors.auto_duration, "DoorStayOpen", line, "" );
extract_value( Doors.auto_velocity, "DoorAutoCloseVel", line, "" );
// operation permit override
{
bool doorneedpermit { false };
extract_value( doorneedpermit, "DoorNeedPermit", line, "" );
Doors.open_permit = ( false == doorneedpermit );
} }
// automatic closing timer
if( DoorCloseCtrl == control_t::autonomous ) { extract_value( DoorStayOpen, "DoorStayOpen", line, "" ); }
extract_value( DoorOpenSpeed, "OpenSpeed", line, "" ); extract_value( Doors.open_rate, "OpenSpeed", line, "" );
extract_value( DoorCloseSpeed, "CloseSpeed", line, "" ); extract_value( Doors.close_rate, "CloseSpeed", line, "" );
extract_value( DoorCloseDelay, "DoorCloseDelay", line, "" ); extract_value( Doors.close_delay, "DoorCloseDelay", line, "" );
extract_value( DoorMaxShiftL, "DoorMaxShiftL", line, "" ); extract_value( Doors.range, "DoorMaxShiftL", line, "" );
extract_value( DoorMaxShiftR, "DoorMaxShiftR", line, "" ); extract_value( Doors.range, "DoorMaxShiftR", line, "" );
extract_value( DoorMaxPlugShift, "DoorMaxShiftPlug", line, "" ); extract_value( Doors.range_out, "DoorMaxShiftPlug", line, "" );
std::string openmethod; extract_value( openmethod, "DoorOpenMethod", line, "" ); std::map<std::string, int> doortypes {
if( openmethod == "Shift" ) { DoorOpenMethod = 1; } //przesuw { "Shift", 1 },
else if( openmethod == "Fold" ) { DoorOpenMethod = 3; } //3 submodele się obracają { "Rotate", 2 },
else if( openmethod == "Plug" ) { DoorOpenMethod = 4; } //odskokowo-przesuwne { "Fold", 3 },
{ "Plug", 4 },
};
// opening method
{
auto lookup = doortypes.find( extract_value( "DoorOpenMethod", line ) );
Doors.type =
lookup != doortypes.end() ?
lookup->second :
2; // default type is plain, rotating door
}
extract_value( DoorClosureWarning, "DoorClosureWarning", line, "" ); extract_value( Doors.has_warning, "DoorClosureWarning", line, "" );
extract_value( DoorClosureWarningAuto, "DoorClosureWarningAuto", line, "" ); extract_value( Doors.has_autowarning, "DoorClosureWarningAuto", line, "" );
extract_value( DoorBlocked, "DoorBlocked", line, "" ); extract_value( Doors.has_lock, "DoorBlocked", line, "" );
extract_value( PlatformSpeed, "PlatformSpeed", line, "" ); extract_value( Doors.step_rate, "PlatformSpeed", line, "" );
extract_value( PlatformMaxShift, "PlatformMaxShift", line, "" ); extract_value( Doors.step_range, "PlatformMaxShift", line, "" );
extract_value( MirrorMaxShift, "MirrorMaxShift", line, "" );
std::string platformopenmethod; extract_value( platformopenmethod, "PlatformOpenMethod", line, "" ); std::string platformopenmethod; extract_value( platformopenmethod, "PlatformOpenMethod", line, "" );
if( platformopenmethod == "Shift" ) { PlatformOpenMethod = 1; } // przesuw if( platformopenmethod == "Shift" ) { Doors.step_type = 1; } // przesuw
extract_value( MirrorMaxShift, "MirrorMaxShift", line, "" );
} }
void TMoverParameters::LoadFIZ_BuffCoupl( std::string const &line, int const Index ) { void TMoverParameters::LoadFIZ_BuffCoupl( std::string const &line, int const Index ) {
@@ -8336,8 +8474,8 @@ void TMoverParameters::LoadFIZ_Cntrl( std::string const &line ) {
// traction motor fans // traction motor fans
{ {
auto lookup = starts.find( extract_value( "MotorBlowersStart", line ) ); auto lookup = starts.find( extract_value( "MotorBlowersStart", line ) );
MotorBlowers[side::front].start_type = MotorBlowers[end::front].start_type =
MotorBlowers[side::rear].start_type = MotorBlowers[end::rear].start_type =
lookup != starts.end() ? lookup != starts.end() ?
lookup->second : lookup->second :
start_t::manual; start_t::manual;
@@ -8596,8 +8734,8 @@ void TMoverParameters::LoadFIZ_Engine( std::string const &Input ) {
} }
// traction motors // traction motors
extract_value( MotorBlowers[ side::front ].speed, "MotorBlowersSpeed", Input, "" ); extract_value( MotorBlowers[ end::front ].speed, "MotorBlowersSpeed", Input, "" );
MotorBlowers[ side::rear ] = MotorBlowers[ side::front ]; MotorBlowers[ end::rear ] = MotorBlowers[ end::front ];
} }
void TMoverParameters::LoadFIZ_Switches( std::string const &Input ) { void TMoverParameters::LoadFIZ_Switches( std::string const &Input ) {
@@ -9032,8 +9170,8 @@ bool TMoverParameters::CheckLocomotiveParameters(bool ReadyFlag, int Dir)
CompressedVolume = VeselVolume * MinCompressor * ( 9.8 ) / 10.0; CompressedVolume = VeselVolume * MinCompressor * ( 9.8 ) / 10.0;
ScndPipePress = ( ScndPipePress = (
VeselVolume > 0.0 ? CompressedVolume / VeselVolume : VeselVolume > 0.0 ? CompressedVolume / VeselVolume :
( Couplers[ side::front ].AllowedFlag & coupling::mainhose ) != 0 ? 5.0 : ( Couplers[ end::front ].AllowedFlag & coupling::mainhose ) != 0 ? 5.0 :
( Couplers[ side::rear ].AllowedFlag & coupling::mainhose ) != 0 ? 5.0 : ( Couplers[ end::rear ].AllowedFlag & coupling::mainhose ) != 0 ? 5.0 :
0.0 ); 0.0 );
PipePress = CntrlPipePress; PipePress = CntrlPipePress;
BrakePress = 0.0; BrakePress = 0.0;
@@ -9062,8 +9200,8 @@ bool TMoverParameters::CheckLocomotiveParameters(bool ReadyFlag, int Dir)
*/ */
ScndPipePress = ( ScndPipePress = (
VeselVolume > 0.0 ? CompressedVolume / VeselVolume : VeselVolume > 0.0 ? CompressedVolume / VeselVolume :
( Couplers[ side::front ].AllowedFlag & coupling::mainhose ) != 0 ? 5.1 : ( Couplers[ end::front ].AllowedFlag & coupling::mainhose ) != 0 ? 5.1 :
( Couplers[ side::rear ].AllowedFlag & coupling::mainhose ) != 0 ? 5.1 : ( Couplers[ end::rear ].AllowedFlag & coupling::mainhose ) != 0 ? 5.1 :
0.0 ); 0.0 );
PipePress = LowPipePress; PipePress = LowPipePress;
PipeBrakePress = MaxBrakePress[ 3 ] * 0.5; PipeBrakePress = MaxBrakePress[ 3 ] * 0.5;
@@ -9376,34 +9514,34 @@ bool TMoverParameters::RunCommand( std::string Command, double CValue1, double C
OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype ); OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype );
} }
else if( Command == "MotorBlowersFrontSwitch" ) { else if( Command == "MotorBlowersFrontSwitch" ) {
if( ( MotorBlowers[ side::front ].start_type != start_t::manual ) if( ( MotorBlowers[ end::front ].start_type != start_t::manual )
&& ( MotorBlowers[ side::front ].start_type != start_t::manualwithautofallback ) ) { && ( MotorBlowers[ end::front ].start_type != start_t::manualwithautofallback ) ) {
// automatic device ignores 'manual' state commands // automatic device ignores 'manual' state commands
MotorBlowers[side::front].is_enabled = ( CValue1 == 1 ); MotorBlowers[end::front].is_enabled = ( CValue1 == 1 );
} }
OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype ); OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype );
} }
else if( Command == "MotorBlowersFrontSwitchOff" ) { else if( Command == "MotorBlowersFrontSwitchOff" ) {
if( ( MotorBlowers[ side::front ].start_type != start_t::manual ) if( ( MotorBlowers[ end::front ].start_type != start_t::manual )
&& ( MotorBlowers[ side::front ].start_type != start_t::manualwithautofallback ) ) { && ( MotorBlowers[ end::front ].start_type != start_t::manualwithautofallback ) ) {
// automatic device ignores 'manual' state commands // automatic device ignores 'manual' state commands
MotorBlowers[side::front].is_disabled = ( CValue1 == 1 ); MotorBlowers[end::front].is_disabled = ( CValue1 == 1 );
} }
OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype ); OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype );
} }
else if( Command == "MotorBlowersRearSwitch" ) { else if( Command == "MotorBlowersRearSwitch" ) {
if( ( MotorBlowers[ side::rear ].start_type != start_t::manual ) if( ( MotorBlowers[ end::rear ].start_type != start_t::manual )
&& ( MotorBlowers[ side::rear ].start_type != start_t::manualwithautofallback ) ) { && ( MotorBlowers[ end::rear ].start_type != start_t::manualwithautofallback ) ) {
// automatic device ignores 'manual' state commands // automatic device ignores 'manual' state commands
MotorBlowers[side::rear].is_enabled = ( CValue1 == 1 ); MotorBlowers[end::rear].is_enabled = ( CValue1 == 1 );
} }
OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype ); OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype );
} }
else if( Command == "MotorBlowersRearSwitchOff" ) { else if( Command == "MotorBlowersRearSwitchOff" ) {
if( ( MotorBlowers[ side::rear ].start_type != start_t::manual ) if( ( MotorBlowers[ end::rear ].start_type != start_t::manual )
&& ( MotorBlowers[ side::rear ].start_type != start_t::manualwithautofallback ) ) { && ( MotorBlowers[ end::rear ].start_type != start_t::manualwithautofallback ) ) {
// automatic device ignores 'manual' state commands // automatic device ignores 'manual' state commands
MotorBlowers[side::rear].is_disabled = ( CValue1 == 1 ); MotorBlowers[end::rear].is_disabled = ( CValue1 == 1 );
} }
OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype ); OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype );
} }
@@ -9492,40 +9630,41 @@ bool TMoverParameters::RunCommand( std::string Command, double CValue1, double C
} }
OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype ); OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype );
} }
else if (Command == "DoorPermit") {
if( ( true == Battery )
&& ( false == Doors.is_locked ) ) {
auto const left { CValue2 > 0 ? 1 : 2 };
auto const right { 3 - left };
if( static_cast<int>( CValue1 ) & right ) {
Doors.instances[ side::right ].open_permit = true;
}
if( static_cast<int>( CValue1 ) & left ) {
Doors.instances[ side::left ].open_permit = true;
}
}
OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype );
}
else if (Command == "DoorOpen") /*NBMX*/ else if (Command == "DoorOpen") /*NBMX*/
{ // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów
if( ( DoorOpenCtrl == control_t::conductor ) if( ( Doors.open_control == control_t::conductor )
|| ( DoorOpenCtrl == control_t::driver ) || ( Doors.open_control == control_t::driver )
|| ( DoorOpenCtrl == control_t::mixed ) ) { || ( Doors.open_control == control_t::mixed ) ) {
// ignore remote command if the door is only operated locally // ignore remote command if the door is only operated locally
if( CValue2 > 0 ) { if( true == Battery ) {
// normalne ustawienie pojazdu
if( ( CValue1 == 1 ) || ( CValue1 == 3 ) ) { auto const left{ CValue2 > 0 ? 1 : 2 };
DoorLeftOpened = ( auto const right { 3 - left };
( ( true == Battery ) && ( false == DoorBlockedFlag() ) ) ?
true : if( static_cast<int>( CValue1 ) & right ) {
DoorLeftOpened ); Doors.instances[ side::right ].remote_open = true;
Doors.instances[ side::right ].remote_close = false;
} }
if( ( CValue1 == 2 ) || ( CValue1 == 3 ) ) { if( static_cast<int>( CValue1 ) & left ) {
DoorRightOpened = ( Doors.instances[ side::left ].remote_open = true;
( ( true == Battery ) && ( false == DoorBlockedFlag() ) ) ? Doors.instances[ side::left ].remote_close = false;
true :
DoorRightOpened );
}
}
else {
// odwrotne ustawienie pojazdu
if( ( CValue1 == 2 ) || ( CValue1 == 3 ) ) {
DoorLeftOpened = (
( ( true == Battery ) && ( false == DoorBlockedFlag() ) ) ?
true :
DoorLeftOpened );
}
if( ( CValue1 == 1 ) || ( CValue1 == 3 ) ) {
DoorRightOpened = (
( ( true == Battery ) && ( false == DoorBlockedFlag() ) ) ?
true :
DoorRightOpened );
} }
} }
} }
@@ -9533,43 +9672,34 @@ bool TMoverParameters::RunCommand( std::string Command, double CValue1, double C
} }
else if (Command == "DoorClose") /*NBMX*/ else if (Command == "DoorClose") /*NBMX*/
{ // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów { // Ra: uwzględnić trzeba jeszcze zgodność sprzęgów
if( ( DoorCloseCtrl == control_t::conductor ) if( ( Doors.open_control == control_t::conductor )
|| ( DoorCloseCtrl == control_t::driver ) || ( Doors.open_control == control_t::driver )
|| ( DoorCloseCtrl == control_t::mixed ) ) { || ( Doors.open_control == control_t::mixed ) ) {
// ignore remote command if the door is only operated locally // ignore remote command if the door is only operated locally
if( CValue2 > 0 ) { if( true == Battery ) {
// normalne ustawienie pojazdu
if( ( CValue1 == 1 ) || ( CValue1 == 3 ) ) { auto const left{ CValue2 > 0 ? 1 : 2 };
DoorLeftOpened = ( auto const right { 3 - left };
true == Battery ?
false : if( static_cast<int>( CValue1 ) & right ) {
DoorLeftOpened ); Doors.instances[ side::right ].remote_close = true;
Doors.instances[ side::right ].remote_open = false;
} }
if( ( CValue1 == 2 ) || ( CValue1 == 3 ) ) { if( static_cast<int>( CValue1 ) & left ) {
DoorRightOpened = ( Doors.instances[ side::left ].remote_close = true;
true == Battery ? Doors.instances[ side::left ].remote_open = false;
false :
DoorRightOpened );
}
}
else {
// odwrotne ustawienie pojazdu
if( ( CValue1 == 2 ) || ( CValue1 == 3 ) ) {
DoorLeftOpened = (
true == Battery ?
false :
DoorLeftOpened );
}
if( ( CValue1 == 1 ) || ( CValue1 == 3 ) ) {
DoorRightOpened = (
true == Battery ?
false :
DoorRightOpened );
} }
} }
} }
OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype ); OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype );
} }
else if( Command == "DoorLock" ) {
Doors.lock_enabled = (
CValue1 == 1 ?
true :
false );
OK = SendCtrlToNext( Command, CValue1, CValue2, Couplertype );
}
else if( Command == "DepartureSignal" ) { else if( Command == "DepartureSignal" ) {
DepartureSignal = ( DepartureSignal = (
CValue1 == 1 ? CValue1 == 1 ?

2
Track.cpp
View File

@@ -932,7 +932,7 @@ bool TTrack::AssignEvents() {
m_events = true; m_events = true;
} }
else { else {
ErrorLog( "Bad track: \"" + m_name + "\" can't find assigned event \"" + event.first + "\"" ); ErrorLog( "Bad track: " + ( m_name.empty() ? "unnamed track" : "\"" + m_name + "\"" ) + " can't find assigned event \"" + event.first + "\"" );
lookupfail = true; lookupfail = true;
} }
} }

571
Train.cpp
View File

File diff suppressed because it is too large Load Diff

9
Train.h
View File

@@ -139,6 +139,8 @@ class TTrain
void set_master_controller( double const Position ); void set_master_controller( double const Position );
// moves train brake lever to specified position, potentially emits switch sound if conditions are met // moves train brake lever to specified position, potentially emits switch sound if conditions are met
void set_train_brake( double const Position ); void set_train_brake( double const Position );
// potentially moves train brake lever to neutral position
void zero_charging_train_brake();
// sets specified brake acting speed for specified vehicle, potentially updating state of cab controls to match // sets specified brake acting speed for specified vehicle, potentially updating state of cab controls to match
void set_train_brake_speed( TDynamicObject *Vehicle, int const Speed ); void set_train_brake_speed( TDynamicObject *Vehicle, int const Speed );
// sets the motor connector button in paired unit to specified state // sets the motor connector button in paired unit to specified state
@@ -311,10 +313,13 @@ class TTrain
static void OnCommand_doorlocktoggle( TTrain *Train, command_data const &Command ); static void OnCommand_doorlocktoggle( TTrain *Train, command_data const &Command );
static void OnCommand_doortoggleleft( TTrain *Train, command_data const &Command ); static void OnCommand_doortoggleleft( TTrain *Train, command_data const &Command );
static void OnCommand_doortoggleright( TTrain *Train, command_data const &Command ); static void OnCommand_doortoggleright( TTrain *Train, command_data const &Command );
static void OnCommand_doorpermitleft( TTrain *Train, command_data const &Command );
static void OnCommand_doorpermitright( TTrain *Train, command_data const &Command );
static void OnCommand_dooropenleft( TTrain *Train, command_data const &Command ); static void OnCommand_dooropenleft( TTrain *Train, command_data const &Command );
static void OnCommand_dooropenright( TTrain *Train, command_data const &Command ); static void OnCommand_dooropenright( TTrain *Train, command_data const &Command );
static void OnCommand_doorcloseleft( TTrain *Train, command_data const &Command ); static void OnCommand_doorcloseleft( TTrain *Train, command_data const &Command );
static void OnCommand_doorcloseright( TTrain *Train, command_data const &Command ); static void OnCommand_doorcloseright( TTrain *Train, command_data const &Command );
static void OnCommand_dooropenall( TTrain *Train, command_data const &Command );
static void OnCommand_doorcloseall( TTrain *Train, command_data const &Command ); static void OnCommand_doorcloseall( TTrain *Train, command_data const &Command );
static void OnCommand_carcouplingincrease( TTrain *Train, command_data const &Command ); static void OnCommand_carcouplingincrease( TTrain *Train, command_data const &Command );
static void OnCommand_carcouplingdisconnect( TTrain *Train, command_data const &Command ); static void OnCommand_carcouplingdisconnect( TTrain *Train, command_data const &Command );
@@ -438,12 +443,15 @@ public: // reszta może by?publiczna
// oswietlenia kabiny // oswietlenia kabiny
// NBMX wrzesien 2003 - obsluga drzwi // NBMX wrzesien 2003 - obsluga drzwi
TGauge ggDoorLeftPermitButton;
TGauge ggDoorRightPermitButton;
TGauge ggDoorLeftButton; TGauge ggDoorLeftButton;
TGauge ggDoorRightButton; TGauge ggDoorRightButton;
TGauge ggDoorLeftOnButton; TGauge ggDoorLeftOnButton;
TGauge ggDoorRightOnButton; TGauge ggDoorRightOnButton;
TGauge ggDoorLeftOffButton; TGauge ggDoorLeftOffButton;
TGauge ggDoorRightOffButton; TGauge ggDoorRightOffButton;
TGauge ggDoorAllOnButton;
TGauge ggDoorAllOffButton; TGauge ggDoorAllOffButton;
TGauge ggDepartureSignalButton; TGauge ggDepartureSignalButton;
@@ -542,6 +550,7 @@ public: // reszta może by?publiczna
TButton btLampkaPrzekrMaxSila; TButton btLampkaPrzekrMaxSila;
TButton btLampkaDoorLeft; TButton btLampkaDoorLeft;
TButton btLampkaDoorRight; TButton btLampkaDoorRight;
TButton btLampkaDoors;
TButton btLampkaDepartureSignal; TButton btLampkaDepartureSignal;
TButton btLampkaBlokadaDrzwi; TButton btLampkaBlokadaDrzwi;
TButton btLampkaDoorLockOff; TButton btLampkaDoorLockOff;

3
command.cpp
View File

@@ -142,8 +142,11 @@ commanddescription_sequence Commands_descriptions = {
{ "carcouplingdisconnect", command_target::vehicle }, { "carcouplingdisconnect", command_target::vehicle },
{ "doortoggleleft", command_target::vehicle }, { "doortoggleleft", command_target::vehicle },
{ "doortoggleright", command_target::vehicle }, { "doortoggleright", command_target::vehicle },
{ "doorpermitleft", command_target::vehicle },
{ "doorpermitright", command_target::vehicle },
{ "dooropenleft", command_target::vehicle }, { "dooropenleft", command_target::vehicle },
{ "dooropenright", command_target::vehicle }, { "dooropenright", command_target::vehicle },
{ "dooropenall", command_target::vehicle },
{ "doorcloseleft", command_target::vehicle }, { "doorcloseleft", command_target::vehicle },
{ "doorcloseright", command_target::vehicle }, { "doorcloseright", command_target::vehicle },
{ "doorcloseall", command_target::vehicle }, { "doorcloseall", command_target::vehicle },

3
command.h
View File

@@ -135,8 +135,11 @@ enum class user_command {
carcouplingdisconnect, carcouplingdisconnect,
doortoggleleft, doortoggleleft,
doortoggleright, doortoggleright,
doorpermitleft,
doorpermitright,
dooropenleft, dooropenleft,
dooropenright, dooropenright,
dooropenall,
doorcloseleft, doorcloseleft,
doorcloseright, doorcloseright,
doorcloseall, doorcloseall,

6
drivermode.cpp
View File

@@ -924,7 +924,7 @@ driver_mode::ExternalView() {
switch( m_externalviewmode ) { switch( m_externalviewmode ) {
case view::consistfront: { case view::consistfront: {
// bind camera with the vehicle // bind camera with the vehicle
auto *owner { vehicle->Mechanik->Vehicle( side::front ) }; auto *owner { vehicle->Mechanik->Vehicle( end::front ) };
Camera.m_owner = owner; Camera.m_owner = owner;
@@ -955,7 +955,7 @@ driver_mode::ExternalView() {
} }
case view::consistrear: { case view::consistrear: {
// bind camera with the vehicle // bind camera with the vehicle
auto *owner { vehicle->Mechanik->Vehicle( side::rear ) }; auto *owner { vehicle->Mechanik->Vehicle( end::rear ) };
Camera.m_owner = owner; Camera.m_owner = owner;
@@ -985,7 +985,7 @@ driver_mode::ExternalView() {
break; break;
} }
case view::bogie: { case view::bogie: {
auto *owner { vehicle->Mechanik->Vehicle( side::front ) }; auto *owner { vehicle->Mechanik->Vehicle( end::front ) };
Camera.m_owner = owner; Camera.m_owner = owner;

9
drivermouseinput.cpp
View File

@@ -551,6 +551,12 @@ drivermouse_input::default_bindings() {
{ "stlinoff_bt:", { { "stlinoff_bt:", {
user_command::motorconnectorsopen, user_command::motorconnectorsopen,
user_command::none } }, user_command::none } },
{ "doorleftpermit_sw:", {
user_command::doorpermitleft,
user_command::none } },
{ "doorrightpermit_sw:", {
user_command::doorpermitright,
user_command::none } },
{ "door_left_sw:", { { "door_left_sw:", {
user_command::doortoggleleft, user_command::doortoggleleft,
user_command::none } }, user_command::none } },
@@ -569,6 +575,9 @@ drivermouse_input::default_bindings() {
{ "doorrightoff_sw:", { { "doorrightoff_sw:", {
user_command::doorcloseright, user_command::doorcloseright,
user_command::none } }, user_command::none } },
{ "doorallon_sw:", {
user_command::dooropenall,
user_command::none } },
{ "dooralloff_sw:", { { "dooralloff_sw:", {
user_command::doorcloseall, user_command::doorcloseall,
user_command::none } }, user_command::none } },

22
driveruipanels.cpp
View File

@@ -393,8 +393,8 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
mover.EngineDescription( 0 ).c_str(), mover.EngineDescription( 0 ).c_str(),
// TODO: put wheel flat reporting in the enginedescription() // TODO: put wheel flat reporting in the enginedescription()
std::string( mover.WheelFlat > 0.01 ? " Flat: " + to_string( mover.WheelFlat, 1 ) + " mm" : "" ).c_str(), std::string( mover.WheelFlat > 0.01 ? " Flat: " + to_string( mover.WheelFlat, 1 ) + " mm" : "" ).c_str(),
update_vehicle_coupler( side::front ).c_str(), update_vehicle_coupler( end::front ).c_str(),
update_vehicle_coupler( side::rear ).c_str() ); update_vehicle_coupler( end::rear ).c_str() );
Output.emplace_back( std::string{ m_buffer.data() }, Global.UITextColor ); Output.emplace_back( std::string{ m_buffer.data() }, Global.UITextColor );
@@ -419,13 +419,13 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
std::string( isplayervehicle ? locale::strings[ locale::string::debug_vehicle_radio ] + ( mover.Radio ? std::to_string( m_input.train->RadioChannel() ) : "-" ) : "" ).c_str(), std::string( isplayervehicle ? locale::strings[ locale::string::debug_vehicle_radio ] + ( mover.Radio ? std::to_string( m_input.train->RadioChannel() ) : "-" ) : "" ).c_str(),
std::string( isdieselenginepowered ? locale::strings[ locale::string::debug_vehicle_oilpressure ] + to_string( mover.OilPump.pressure, 2 ) : "" ).c_str(), std::string( isdieselenginepowered ? locale::strings[ locale::string::debug_vehicle_oilpressure ] + to_string( mover.OilPump.pressure, 2 ) : "" ).c_str(),
// power transfers // power transfers
mover.Couplers[ side::front ].power_high.voltage, mover.Couplers[ end::front ].power_high.voltage,
mover.Couplers[ side::front ].power_high.current, mover.Couplers[ end::front ].power_high.current,
std::string( mover.Couplers[ side::front ].power_high.local ? "" : "-" ).c_str(), std::string( mover.Couplers[ end::front ].power_high.local ? "" : "-" ).c_str(),
std::string( vehicle.DirectionGet() ? ":<<:" : ":>>:" ).c_str(), std::string( vehicle.DirectionGet() ? ":<<:" : ":>>:" ).c_str(),
std::string( mover.Couplers[ side::rear ].power_high.local ? "" : "-" ).c_str(), std::string( mover.Couplers[ end::rear ].power_high.local ? "" : "-" ).c_str(),
mover.Couplers[ side::rear ].power_high.voltage, mover.Couplers[ end::rear ].power_high.voltage,
mover.Couplers[ side::rear ].power_high.current ); mover.Couplers[ end::rear ].power_high.current );
Output.emplace_back( m_buffer.data(), Global.UITextColor ); Output.emplace_back( m_buffer.data(), Global.UITextColor );
@@ -443,8 +443,8 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
std::abs( mover.enrot ) * 60, std::abs( mover.enrot ) * 60,
std::abs( mover.nrot ) * mover.Transmision.Ratio * 60, std::abs( mover.nrot ) * mover.Transmision.Ratio * 60,
mover.RventRot * 60, mover.RventRot * 60,
std::abs( mover.MotorBlowers[side::front].revolutions ), std::abs( mover.MotorBlowers[end::front].revolutions ),
std::abs( mover.MotorBlowers[side::rear].revolutions ), std::abs( mover.MotorBlowers[end::rear].revolutions ),
mover.dizel_heat.rpmw, mover.dizel_heat.rpmw,
mover.dizel_heat.rpmw2 ); mover.dizel_heat.rpmw2 );
@@ -536,7 +536,7 @@ debug_panel::update_vehicle_coupler( int const Side ) {
std::string couplerstatus { locale::strings[ locale::string::debug_vehicle_none ] }; std::string couplerstatus { locale::strings[ locale::string::debug_vehicle_none ] };
auto const *connected { ( auto const *connected { (
Side == side::front ? Side == end::front ?
m_input.vehicle->PrevConnected : m_input.vehicle->PrevConnected :
m_input.vehicle->NextConnected ) }; m_input.vehicle->NextConnected ) };

8
lightarray.cpp
View File

@@ -23,8 +23,8 @@ light_array::insert( TDynamicObject const *Owner ) {
// we're only storing lights for locos, which have two sets of lights, front and rear // we're only storing lights for locos, which have two sets of lights, front and rear
// for a more generic role this function would have to be tweaked to add vehicle type-specific light combinations // for a more generic role this function would have to be tweaked to add vehicle type-specific light combinations
data.emplace_back( Owner, side::front ); data.emplace_back( Owner, end::front );
data.emplace_back( Owner, side::rear ); data.emplace_back( Owner, end::rear );
} }
void void
@@ -44,7 +44,7 @@ light_array::update() {
for( auto &light : data ) { for( auto &light : data ) {
// update light parameters to match current data of the owner // update light parameters to match current data of the owner
if( light.index == side::front ) { if( light.index == end::front ) {
// front light set // front light set
light.position = light.owner->GetPosition() + ( light.owner->VectorFront() * light.owner->GetLength() * 0.4 ); light.position = light.owner->GetPosition() + ( light.owner->VectorFront() * light.owner->GetLength() * 0.4 );
light.direction = glm::make_vec3( light.owner->VectorFront().getArray() ); light.direction = glm::make_vec3( light.owner->VectorFront().getArray() );
@@ -61,7 +61,7 @@ light_array::update() {
|| ( true == light.owner->MoverParameters->ConverterFlag ) ) { || ( true == light.owner->MoverParameters->ConverterFlag ) ) {
// with power on, the intensity depends on the state of activated switches // with power on, the intensity depends on the state of activated switches
// first we cross-check the list of enabled lights with the lights installed in the vehicle... // first we cross-check the list of enabled lights with the lights installed in the vehicle...
auto const lights { light.owner->iLights[ light.index ] & light.owner->LightList( static_cast<side>( light.index ) ) }; auto const lights { light.owner->iLights[ light.index ] & light.owner->LightList( static_cast<end>( light.index ) ) };
// ...then check their individual state // ...then check their individual state
light.count = 0 light.count = 0
+ ( ( lights & light::headlight_left ) ? 1 : 0 ) + ( ( lights & light::headlight_left ) ? 1 : 0 )

21
messaging.cpp
View File

@@ -300,14 +300,19 @@ WyslijNamiary(TDynamicObject const *Vehicle)
r.iPar[19] = Vehicle->MoverParameters->MainCtrlActualPos; // Pozycja jezdna r.iPar[19] = Vehicle->MoverParameters->MainCtrlActualPos; // Pozycja jezdna
r.iPar[20] = Vehicle->MoverParameters->ScndCtrlActualPos; // Pozycja bocznikowania r.iPar[20] = Vehicle->MoverParameters->ScndCtrlActualPos; // Pozycja bocznikowania
r.iPar[21] = Vehicle->MoverParameters->ScndCtrlActualPos; // Pozycja bocznikowania r.iPar[21] = Vehicle->MoverParameters->ScndCtrlActualPos; // Pozycja bocznikowania
r.iPar[22] = Vehicle->MoverParameters->ResistorsFlag * 1 + r.iPar[22] = Vehicle->MoverParameters->ResistorsFlag * 1
Vehicle->MoverParameters->ConverterFlag * 2 + + Vehicle->MoverParameters->ConverterFlag * 2
+Vehicle->MoverParameters->CompressorFlag * 4 + + Vehicle->MoverParameters->CompressorFlag * 4
Vehicle->MoverParameters->Mains * 8 + + Vehicle->MoverParameters->Mains * 8
+Vehicle->MoverParameters->DoorLeftOpened * 16 + #ifdef EU07_USEOLDDOORCODE
Vehicle->MoverParameters->DoorRightOpened * 32 + + Vehicle->MoverParameters->DoorLeftOpened * 16
+Vehicle->MoverParameters->FuseFlag * 64 + + Vehicle->MoverParameters->DoorRightOpened * 32
Vehicle->MoverParameters->DepartureSignal * 128; #else
+ ( false == Vehicle->MoverParameters->Doors.instances[side::left].is_closed ) * 16
+ ( false == Vehicle->MoverParameters->Doors.instances[side::right].is_closed ) * 32
#endif
+ Vehicle->MoverParameters->FuseFlag * 64
+ Vehicle->MoverParameters->DepartureSignal * 128;
// WriteLog("Zapisalem stare"); // WriteLog("Zapisalem stare");
// WriteLog("Mam patykow "+IntToStr(t->DynamicObject->iAnimType[ANIM_PANTS])); // WriteLog("Mam patykow "+IntToStr(t->DynamicObject->iAnimType[ANIM_PANTS]));
for (int p = 0; p < 4; p++) for (int p = 0; p < 4; p++)

6
simulationstateserializer.cpp
View File

@@ -337,8 +337,8 @@ state_serializer::deserialize_node( cParser &Input, scene::scratch_data &Scratch
} }
if( ( vehicle->MoverParameters->CategoryFlag == 1 ) // trains only if( ( vehicle->MoverParameters->CategoryFlag == 1 ) // trains only
&& ( ( ( vehicle->LightList( side::front ) & ( light::headlight_left | light::headlight_right | light::headlight_upper ) ) != 0 ) && ( ( ( vehicle->LightList( end::front ) & ( light::headlight_left | light::headlight_right | light::headlight_upper ) ) != 0 )
|| ( ( vehicle->LightList( side::rear ) & ( light::headlight_left | light::headlight_right | light::headlight_upper ) ) != 0 ) ) ) { || ( ( vehicle->LightList( end::rear ) & ( light::headlight_left | light::headlight_right | light::headlight_upper ) ) != 0 ) ) ) {
simulation::Lights.insert( vehicle ); simulation::Lights.insert( vehicle );
} }
} }
@@ -859,7 +859,7 @@ state_serializer::deserialize_dynamic( cParser &Input, scene::scratch_data &Scra
Scratchpad.trainset.offset -= length; Scratchpad.trainset.offset -= length;
// automatically establish permanent connections for couplers which specify them in their definitions // automatically establish permanent connections for couplers which specify them in their definitions
if( ( coupling != 0 ) if( ( coupling != 0 )
&& ( vehicle->MoverParameters->Couplers[ ( offset == -1.0 ? side::front : side::rear ) ].AllowedFlag & coupling::permanent ) ) { && ( vehicle->MoverParameters->Couplers[ ( offset == -1.0 ? end::front : end::rear ) ].AllowedFlag & coupling::permanent ) ) {
coupling |= coupling::permanent; coupling |= coupling::permanent;
} }
if( true == Scratchpad.trainset.is_open ) { if( true == Scratchpad.trainset.is_open ) {

9
translation.cpp
View File

@@ -103,6 +103,9 @@ init() {
"right door", "right door",
"left door", "left door",
"right door", "right door",
"left door",
"right door",
"all doors",
"all doors", "all doors",
"departure signal", "departure signal",
"upper headlight", "upper headlight",
@@ -241,6 +244,9 @@ init() {
"drzwi prawe", "drzwi prawe",
"drzwi lewe", "drzwi lewe",
"drzwi prawe", "drzwi prawe",
"drzwi lewe",
"drzwi prawe",
"drzwi",
"drzwi", "drzwi",
"sygnal odjazdu", "sygnal odjazdu",
"reflektor gorny", "reflektor gorny",
@@ -345,12 +351,15 @@ init() {
"fuse_bt:", "fuse_bt:",
"converterfuse_bt:", "converterfuse_bt:",
"stlinoff_bt:", "stlinoff_bt:",
"doorleftpermit_sw:",
"doorrightpermit_sw:",
"door_left_sw:", "door_left_sw:",
"door_right_sw:", "door_right_sw:",
"doorlefton_sw:", "doorlefton_sw:",
"doorrighton_sw:", "doorrighton_sw:",
"doorleftoff_sw:", "doorleftoff_sw:",
"doorrightoff_sw:", "doorrightoff_sw:",
"doorallon_sw:",
"dooralloff_sw:", "dooralloff_sw:",
"departure_signal_bt:", "departure_signal_bt:",
"upperlight_sw:", "upperlight_sw:",

3
translation.h
View File

@@ -86,12 +86,15 @@ enum string {
cab_fuse_bt, cab_fuse_bt,
cab_converterfuse_bt, cab_converterfuse_bt,
cab_stlinoff_bt, cab_stlinoff_bt,
cab_doorleftpermit_sw,
cab_doorrightpermit_sw,
cab_door_left_sw, cab_door_left_sw,
cab_door_right_sw, cab_door_right_sw,
cab_doorlefton_sw, cab_doorlefton_sw,
cab_doorrighton_sw, cab_doorrighton_sw,
cab_doorleftoff_sw, cab_doorleftoff_sw,
cab_doorrightoff_sw, cab_doorrightoff_sw,
cab_doorallon_sw,
cab_dooralloff_sw, cab_dooralloff_sw,
cab_departure_signal_bt, cab_departure_signal_bt,
cab_upperlight_sw, cab_upperlight_sw,

2
version.h
View File

@@ -1,5 +1,5 @@
#pragma once #pragma once
#define VERSION_MAJOR 19 #define VERSION_MAJOR 19
#define VERSION_MINOR 119 #define VERSION_MINOR 129
#define VERSION_REVISION 0 #define VERSION_REVISION 0