public override void SignalEvent(PowerSupplyEvent evt)
{
if (Simulator.Confirmer != null && Simulator.PlayerLocomotive == this)
{
switch (evt)
{
case PowerSupplyEvent.RaisePantograph:
Simulator.Confirmer.Confirm(CabControl.Pantograph1, CabSetting.On);
Simulator.Confirmer.Confirm(CabControl.Pantograph2, CabSetting.On);
Simulator.Confirmer.Confirm(CabControl.Pantograph3, CabSetting.On);
Simulator.Confirmer.Confirm(CabControl.Pantograph4, CabSetting.On);
break;
case PowerSupplyEvent.LowerPantograph:
Simulator.Confirmer.Confirm(CabControl.Pantograph1, CabSetting.Off);
Simulator.Confirmer.Confirm(CabControl.Pantograph2, CabSetting.Off);
Simulator.Confirmer.Confirm(CabControl.Pantograph3, CabSetting.Off);
Simulator.Confirmer.Confirm(CabControl.Pantograph4, CabSetting.Off);
break;
}
}
switch (evt)
{
case PowerSupplyEvent.CloseCircuitBreaker:
case PowerSupplyEvent.OpenCircuitBreaker:
case PowerSupplyEvent.CloseCircuitBreakerButtonPressed:
case PowerSupplyEvent.CloseCircuitBreakerButtonReleased:
case PowerSupplyEvent.OpenCircuitBreakerButtonPressed:
case PowerSupplyEvent.OpenCircuitBreakerButtonReleased:
case PowerSupplyEvent.GiveCircuitBreakerClosingAuthorization:
case PowerSupplyEvent.RemoveCircuitBreakerClosingAuthorization:
PowerSupply.HandleEvent(evt);
break;
}
base.SignalEvent(evt);
}
public override void HandleEvent(PowerSupplyEvent evt)
{
switch (evt)
{
case PowerSupplyEvent.CloseCircuitBreakerButtonPressed:
Confirm(CabControl.CircuitBreakerClosingOrder, CabSetting.On);
SetDriverClosingOrder(true);
break;
case PowerSupplyEvent.CloseCircuitBreakerButtonReleased:
SetDriverClosingOrder(false);
break;
case PowerSupplyEvent.GiveCircuitBreakerClosingAuthorization:
SetDriverClosingAuthorization(true);
Confirm(CabControl.CircuitBreakerClosingAuthorization, CabSetting.On);
break;
case PowerSupplyEvent.RemoveCircuitBreakerClosingAuthorization:
SetDriverClosingAuthorization(false);
Confirm(CabControl.CircuitBreakerClosingAuthorization, CabSetting.Off);
break;
}
}
public void HandleEvent(PowerSupplyEvent evt)
{
Event soundEvent = Event.None;
switch (evt)
{
case PowerSupplyEvent.LowerPantograph:
if (State == PantographState.Up || State == PantographState.Raising)
{
State = PantographState.Lowering;
switch (Id)
{
default:
case 1:
soundEvent = Event.Pantograph1Down;
break;
case 2:
soundEvent = Event.Pantograph2Down;
break;
case 3:
soundEvent = Event.Pantograph3Down;
break;
case 4:
soundEvent = Event.Pantograph4Down;
break;
}
}
break;
case PowerSupplyEvent.RaisePantograph:
if (State == PantographState.Down || State == PantographState.Lowering)
{
State = PantographState.Raising;
switch (Id)
{
default:
case 1:
soundEvent = Event.Pantograph1Up;
break;
case 2:
soundEvent = Event.Pantograph2Up;
break;
case 3:
soundEvent = Event.Pantograph3Up;
break;
case 4:
soundEvent = Event.Pantograph4Up;
break;
}
}
break;
}
if (soundEvent != Event.None)
{
try
{
foreach (var eventHandler in Wagon.EventHandlers)
{
eventHandler.HandleEvent(soundEvent);
}
}
catch (Exception error)
{
Trace.TraceInformation("Sound event skipped due to thread safety problem " + error.Message);
}
}
}
public override void HandleEvent(PowerSupplyEvent evt)
{
switch (evt)
{
case PowerSupplyEvent.CloseCircuitBreakerButtonPressed:
if (!DriverClosingOrder())
{
SetDriverClosingOrder(true);
SignalEvent(Event.CircuitBreakerClosingOrderOn);
Confirm(CabControl.CircuitBreakerClosingOrder, CabSetting.On);
if (!ClosingAuthorization())
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Fermeture du disjoncteur non autorisée");
}
else
{
Message(ConfirmLevel.Warning, "Circuit breaker closing not authorized");
}
}
}
break;
case PowerSupplyEvent.CloseCircuitBreakerButtonReleased:
if (DriverClosingOrder())
{
SetDriverClosingOrder(false);
SignalEvent(Event.CircuitBreakerClosingOrderOff);
}
break;
case PowerSupplyEvent.GiveCircuitBreakerClosingAuthorization:
if (!DriverClosingAuthorization())
{
SetDriverClosingAuthorization(true);
SignalEvent(Event.CircuitBreakerClosingAuthorizationOn);
Confirm(CabControl.CircuitBreakerClosingAuthorization, CabSetting.On);
}
break;
case PowerSupplyEvent.RemoveCircuitBreakerClosingAuthorization:
if (DriverClosingAuthorization())
{
SetDriverClosingAuthorization(false);
SignalEvent(Event.CircuitBreakerClosingAuthorizationOff);
Confirm(CabControl.CircuitBreakerClosingAuthorization, CabSetting.Off);
}
break;
case PowerSupplyEvent.QuickPowerOn:
SetDriverClosingAuthorization(true);
SetCurrentState(CircuitBreakerState.Closed);
break;
case PowerSupplyEvent.QuickPowerOff:
SetDriverClosingAuthorization(false);
SetCurrentState(CircuitBreakerState.Open);
break;
}
}
/// <summary>
/// Called when a power supply event happens (like the circuit breaker closed)
/// Set at virtual to keep compatibility with scripts not providing this method.
/// </summary>
/// <param name="evt">The event happened</param>
/// <param name="message">The message the event wants to communicate. May be empty.</param>
public virtual void HandleEvent(PowerSupplyEvent evt, string message)
{
}
public void HandleEventFromLeadLocomotive(PowerSupplyEvent evt)
{
AbstractScript?.HandleEventFromLeadLocomotive(evt);
}
/// <summary> /// Called when an event happens (a closing order from the driver for example) /// </summary> /// <param name="evt">The event happened</param> public abstract void HandleEvent(PowerSupplyEvent evt);
public override void HandleEvent(PowerSupplyEvent evt)
{
switch (evt)
{
case PowerSupplyEvent.GiveCircuitBreakerClosingAuthorization:
if (MasterKeyOn())
{
SignalEventToCircuitBreaker(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
}
else
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Ce bouton ne peut être utilisé que si la boîte à leviers est déverrouillée");
}
else
{
Message(ConfirmLevel.Warning, "This button can only be used when the master key is turned on");
}
}
break;
case PowerSupplyEvent.CloseCircuitBreakerButtonPressed:
if (!MasterKeyOn())
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Ce bouton ne peut être utilisé que si la boîte à leviers est déverrouillée");
}
else
{
Message(ConfirmLevel.Warning, "This button can only be used when the master key is turned on");
}
}
else if (ThrottlePercent() > 0)
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Ce bouton ne peut être utilisé que si le manipulateur traction est à 0");
}
else
{
Message(ConfirmLevel.Warning, "This button can only be used when the throttle controller is at 0");
}
}
else
{
SignalEventToCircuitBreaker(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
}
break;
case PowerSupplyEvent.CloseCircuitBreakerButtonReleased:
case PowerSupplyEvent.RemoveCircuitBreakerClosingAuthorization:
SignalEventToCircuitBreaker(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
break;
case PowerSupplyEvent.SwitchOnElectricTrainSupply:
if (MasterKeyOn())
{
SignalEventToElectricTrainSupplySwitch(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
}
else
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Ce bouton ne peut être utilisé que si la boîte à leviers est déverrouillée");
}
else
{
Message(ConfirmLevel.Warning, "This button can only be used when the master key is turned on");
}
}
break;
case PowerSupplyEvent.SwitchOffElectricTrainSupply:
SignalEventToElectricTrainSupplySwitch(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
break;
case PowerSupplyEvent.CloseBatterySwitch:
case PowerSupplyEvent.CloseBatterySwitchButtonPressed:
case PowerSupplyEvent.CloseBatterySwitchButtonReleased:
case PowerSupplyEvent.OpenBatterySwitch:
case PowerSupplyEvent.OpenBatterySwitchButtonPressed:
case PowerSupplyEvent.OpenBatterySwitchButtonReleased:
SignalEventToBatterySwitch(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
break;
case PowerSupplyEvent.TurnOnMasterKey:
case PowerSupplyEvent.TurnOffMasterKey:
if (!CircuitBreakerDriverClosingAuthorization() && !CircuitBreakerDriverClosingOrder() && !CircuitBreakerDriverOpeningOrder())
{
SignalEventToMasterKey(evt);
SignalEventToTcs(evt);
}
else
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Tous les leviers de la rangée supérieure de la boîte à leviers doivent être bas (sauf le bouton de maintien de service) pour verrouiller la boîte à leviers");
}
else
{
Message(ConfirmLevel.Warning, "All upper levers must be down (except service hold button) in order to switch off the master key");
}
}
break;
case PowerSupplyEvent.QuickPowerOn:
QuickPowerOn = true;
SignalEventToBatterySwitch(PowerSupplyEvent.CloseBatterySwitch);
SignalEventToMasterKey(PowerSupplyEvent.TurnOnMasterKey);
SignalEventToPantograph(PowerSupplyEvent.RaisePantograph, 1);
SignalEventToElectricTrainSupplySwitch(PowerSupplyEvent.SwitchOnElectricTrainSupply);
SignalEventToOtherTrainVehicles(PowerSupplyEvent.QuickPowerOn);
break;
case PowerSupplyEvent.QuickPowerOff:
QuickPowerOn = false;
SignalEventToElectricTrainSupplySwitch(PowerSupplyEvent.SwitchOffElectricTrainSupply);
SignalEventToCircuitBreaker(PowerSupplyEvent.QuickPowerOff);
SignalEventToPantographs(PowerSupplyEvent.LowerPantograph);
SignalEventToMasterKey(PowerSupplyEvent.TurnOffMasterKey);
SignalEventToBatterySwitch(PowerSupplyEvent.OpenBatterySwitch);
SignalEventToOtherTrainVehicles(PowerSupplyEvent.QuickPowerOff);
break;
}
}
public override void HandleEvent(PowerSupplyEvent evt)
{
SignalEventToPantographs(evt);
SignalEventToBatterySwitch(evt);
}
public void HandleEventFromLeadLocomotive(PowerSupplyEvent evt, int id)
{
Script?.HandleEventFromLeadLocomotive(evt, id);
}
public void HandleEvent(PowerSupplyEvent evt, int id)
{
Script?.HandleEvent(evt, id);
}
public override void HandleEvent(PowerSupplyEvent evt)
{
switch (evt)
{
case PowerSupplyEvent.CloseTractionCutOffRelayButtonPressed:
if (!MasterKeyOn())
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Ce bouton ne peut être utilisé que si la boîte à leviers est déverrouillée");
}
else
{
Message(ConfirmLevel.Warning, "This button can only be used when the master key is turned on");
}
}
else if (ThrottlePercent() > 0)
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Ce bouton ne peut être utilisé que si le manipulateur traction est à 0");
}
else
{
Message(ConfirmLevel.Warning, "This button can only be used when the throttle controller is at 0");
}
}
else
{
SignalEventToTractionCutOffRelay(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
}
break;
case PowerSupplyEvent.CloseTractionCutOffRelayButtonReleased:
SignalEventToTractionCutOffRelay(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
break;
case PowerSupplyEvent.SwitchOnElectricTrainSupply:
if (MasterKeyOn())
{
SignalEventToElectricTrainSupplySwitch(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
}
else
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Ce bouton ne peut être utilisé que si la boîte à leviers est déverrouillée");
}
else
{
Message(ConfirmLevel.Warning, "This button can only be used when the master key is turned on");
}
}
break;
case PowerSupplyEvent.SwitchOffElectricTrainSupply:
SignalEventToElectricTrainSupplySwitch(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
break;
case PowerSupplyEvent.CloseBatterySwitch:
case PowerSupplyEvent.CloseBatterySwitchButtonPressed:
case PowerSupplyEvent.CloseBatterySwitchButtonReleased:
case PowerSupplyEvent.OpenBatterySwitch:
case PowerSupplyEvent.OpenBatterySwitchButtonPressed:
case PowerSupplyEvent.OpenBatterySwitchButtonReleased:
SignalEventToBatterySwitch(evt);
SignalEventToTcs(evt);
SignalEventToOtherTrainVehicles(evt);
break;
case PowerSupplyEvent.TurnOnMasterKey:
case PowerSupplyEvent.TurnOffMasterKey:
if (!TractionCutOffRelayDriverClosingAuthorization() && !TractionCutOffRelayDriverClosingOrder() && !TractionCutOffRelayDriverOpeningOrder() && !ElectricTrainSupplySwitchOn())
{
SignalEventToMasterKey(evt);
SignalEventToTcs(evt);
}
else
{
if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
Message(ConfirmLevel.Warning, "Tous les leviers de la rangée supérieure de la boîte à leviers doivent être bas (sauf le bouton de maintien de service) pour verrouiller la boîte à leviers");
}
else
{
Message(ConfirmLevel.Warning, "All upper levers must be down (except service hold button) in order to switch off the master key");
}
}
break;
case PowerSupplyEvent.QuickPowerOn:
QuickPowerOn = true;
SignalEventToBatterySwitch(PowerSupplyEvent.CloseBatterySwitch);
SignalEventToMasterKey(PowerSupplyEvent.TurnOnMasterKey);
SignalEventToDieselEngines(PowerSupplyEvent.StartEngine);
SignalEventToElectricTrainSupplySwitch(PowerSupplyEvent.SwitchOnElectricTrainSupply);
SignalEventToOtherLocomotives(PowerSupplyEvent.QuickPowerOn);
break;
case PowerSupplyEvent.QuickPowerOff:
QuickPowerOn = false;
SignalEventToElectricTrainSupplySwitch(PowerSupplyEvent.SwitchOffElectricTrainSupply);
SignalEventToTractionCutOffRelay(PowerSupplyEvent.OpenTractionCutOffRelay);
SignalEventToDieselEngines(PowerSupplyEvent.StopEngine);
SignalEventToMasterKey(PowerSupplyEvent.TurnOffMasterKey);
SignalEventToBatterySwitch(PowerSupplyEvent.OpenBatterySwitch);
SignalEventToOtherLocomotives(PowerSupplyEvent.QuickPowerOff);
break;
case PowerSupplyEvent.TogglePlayerEngine:
switch (CurrentDieselEngineState(0))
{
case DieselEngineState.Stopped:
case DieselEngineState.Stopping:
SignalEventToDieselEngines(PowerSupplyEvent.StartEngine);
SignalEventToHelperEngines(PowerSupplyEvent.StartEngine);
Confirm(CabControl.PlayerDiesel, CabSetting.On);
break;
case DieselEngineState.Starting:
SignalEventToDieselEngines(PowerSupplyEvent.StopEngine);
SignalEventToHelperEngines(PowerSupplyEvent.StopEngine);
Confirm(CabControl.PlayerDiesel, CabSetting.Off);
break;
case DieselEngineState.Running:
if (ThrottlePercent() < 1)
{
SignalEventToDieselEngines(PowerSupplyEvent.StopEngine);
SignalEventToHelperEngines(PowerSupplyEvent.StopEngine);
Confirm(CabControl.PlayerDiesel, CabSetting.Off);
}
else
{
Confirm(CabControl.PlayerDiesel, CabSetting.Warn1);
}
break;
}
break;
}
}
public override void HandleEventFromLeadLocomotive(PowerSupplyEvent evt)
{
}
public virtual void HandleEvent(PowerSupplyEvent evt, int id)
{
// By default, send the event to every component
SignalEventToPantograph(evt, id);
}
public override void HandleEvent(PowerSupplyEvent evt, int id)
{
SignalEventToPantograph(evt, id);
}
public virtual void HandleEventFromLeadLocomotive(PowerSupplyEvent evt)
{
// By default, send the event to every component
SignalEventToBatterySwitch(evt);
}
public void HandleEvent(PowerSupplyEvent evt)
{
Script?.HandleEvent(evt);
}
public void HandleEvent(PowerSupplyEvent evt)
{
CircuitBreaker.HandleEvent(evt);
}
public override void HandleEvent(PowerSupplyEvent evt)
{
// Nothing to do since it is automatic
}
public void HandleEvent(PowerSupplyEvent evt)
{
Event soundEvent = Event.None;
switch (evt)
{
case PowerSupplyEvent.LowerPantograph:
if (State == PantographState.Up || State == PantographState.Raising)
{
State = PantographState.Lowering;
switch (Id)
{
default:
case 1:
soundEvent = Event.Pantograph1Down;
Confirm(CabControl.Pantograph1, CabSetting.Off);
break;
case 2:
soundEvent = Event.Pantograph2Down;
Confirm(CabControl.Pantograph2, CabSetting.Off);
break;
case 3:
soundEvent = Event.Pantograph3Down;
Confirm(CabControl.Pantograph3, CabSetting.Off);
break;
case 4:
soundEvent = Event.Pantograph4Down;
Confirm(CabControl.Pantograph4, CabSetting.Off);
break;
}
}
break;
case PowerSupplyEvent.RaisePantograph:
if (State == PantographState.Down || State == PantographState.Lowering)
{
State = PantographState.Raising;
switch (Id)
{
default:
case 1:
soundEvent = Event.Pantograph1Up;
Confirm(CabControl.Pantograph4, CabSetting.On);
break;
case 2:
soundEvent = Event.Pantograph2Up;
Confirm(CabControl.Pantograph2, CabSetting.On);
break;
case 3:
soundEvent = Event.Pantograph3Up;
Confirm(CabControl.Pantograph3, CabSetting.On);
break;
case 4:
soundEvent = Event.Pantograph4Up;
Confirm(CabControl.Pantograph4, CabSetting.On);
break;
}
if (!Simulator.TRK.Tr_RouteFile.Electrified)
{
Simulator.Confirmer.Warning(Simulator.Catalog.GetString("No power line!"));
}
if (Simulator.Settings.OverrideNonElectrifiedRoutes)
{
Simulator.Confirmer.Information(Simulator.Catalog.GetString("Power line condition overridden."));
}
}
break;
}
if (soundEvent != Event.None)
{
try
{
foreach (var eventHandler in Wagon.EventHandlers)
{
eventHandler.HandleEvent(soundEvent);
}
}
catch (Exception error)
{
Trace.TraceInformation("Sound event skipped due to thread safety problem " + error.Message);
}
}
}
public void HandleEvent(PowerSupplyEvent evt)
{
Event soundEvent = Event.None;
switch (evt)
{
case PowerSupplyEvent.LowerPantograph:
if (State == PantographState.Up || State == PantographState.Raising)
{
State = PantographState.Lowering;
switch (Id)
{
default:
case 1:
soundEvent = Event.Pantograph1Down;
break;
case 2:
soundEvent = Event.Pantograph2Down;
break;
case 3:
soundEvent = Event.Pantograph3Down;
break;
case 4:
soundEvent = Event.Pantograph4Down;
break;
}
}
break;
case PowerSupplyEvent.RaisePantograph:
if (State == PantographState.Down || State == PantographState.Lowering)
{
State = PantographState.Raising;
switch (Id)
{
default:
case 1:
soundEvent = Event.Pantograph1Up;
break;
case 2:
soundEvent = Event.Pantograph2Up;
break;
case 3:
soundEvent = Event.Pantograph3Up;
break;
case 4:
soundEvent = Event.Pantograph4Up;
break;
}
}
break;
}
if (soundEvent != Event.None)
{
foreach (var eventHandler in Wagon.EventHandlers)
{
eventHandler.HandleEvent(soundEvent);
}
}
}
