internal void DoorChange(DoorStates oldState, DoorStates newState)
{
stationsMemory.DoorChange(oldState, newState);
driverless.DoorChange(oldState, newState);
atp2.DoorChange(oldState, newState);
ato.DoorChange(oldState, newState);
}
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
public void DoorChange(DoorStates oldState, DoorStates newState)
{
foreach (IRuntime plugin in plugins_)
{
plugin.DoorChange(oldState, newState);
}
}
/// <summary>
/// Constructor. Creates an object for a section.
/// </summary>
/// <param name="game"></param>
/// <param name="section"></param>
public PrisonModel(PrisonGame game, int section)
{
state = DoorStates.Closed;
this.game = game;
this.section = section;
this.asset = "AntonPhibes" + section.ToString();
}
public void DoorChange(DoorStates oldState, DoorStates newState)
{
if (oldState == DoorStates.None & newState != DoorStates.None)
{
try
{
Win32DoorOpen();
}
catch (Exception ex)
{
Callback.ReportError(ex.ToString());
}
}
else if (oldState != DoorStates.None & newState == DoorStates.None)
{
try
{
Win32DoorClose();
}
catch (Exception ex)
{
Callback.ReportError(ex.ToString());
}
}
}
// Update is called once per frame
void Update()
{
if (state == DoorStates.open)
{
targetRotation = Quaternion.AngleAxis(openAngle, Vector3.up);
}
else
{
targetRotation = Quaternion.AngleAxis(closedAngle, Vector3.up);
}
transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, speed * Time.time);
if (transform.rotation == targetRotation && prevState != state)
{
prevState = state;
if (state == DoorStates.closed)
{
GetComponent <AudioSource>().Play();
}
}
}
internal void DoorChange(DoorStates oldState, DoorStates newState)
{
foreach (Device device in devices.Values)
{
device.DoorChange(oldState, newState);
}
}
public override void DoorChange(DoorStates oldState, DoorStates newState)
{
if (oldState == DoorStates.None & newState != DoorStates.None)
{
try
{
Win32DoorOpen();
}
catch (Exception ex)
{
base.LastException = ex;
throw;
}
}
else if (oldState != DoorStates.None & newState == DoorStates.None)
{
try
{
Win32DoorClose();
}
catch (Exception ex)
{
base.LastException = ex;
throw;
}
}
}
public void ChangeState(DoorStates newState)
{
switch (newState)
{
case DoorStates.Bottom:
targetAngle = new Vector3(0, 0, 0);
break;
case DoorStates.Left:
targetAngle = new Vector3(-90, -180, 0);
break;
case DoorStates.Right:
targetAngle = new Vector3(0, 0, -90);
break;
case DoorStates.Top:
targetAngle = new Vector3(90, 0, -90);
break;
}
}
// Update is called once per frame
// Simply handles opening and closing the door
void FixedUpdate()
{
if (touched)
{
float currentRotation = door.transform.localEulerAngles.y;
if (touched)
{
Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Player"), LayerMask.NameToLayer("Door"), true);
if (doorState == DoorStates.closed)
{
door.transform.RotateAround(pivot.transform.position, Vector3.up, doorOpenSpeed);
if (Mathf.Floor(currentRotation) == openRotation)
{
touched = false;
doorState = DoorStates.open;
Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Player"), LayerMask.NameToLayer("Door"), false);
}
//
}
if (doorState == DoorStates.open)
{
door.transform.RotateAround(pivot.transform.position, Vector3.up, -doorOpenSpeed);
if (Mathf.Floor(currentRotation) == closedRotation)
{
touched = false;
doorState = DoorStates.closed;
Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Player"), LayerMask.NameToLayer("Door"), false);
}
}
}
}
}
/// <summary>
/// Constructor. Creates an object for a section.
/// </summary>
/// <param name="game"></param>
/// <param name="section"></param>
public PrisonModel(PrisonGame game, int section)
{
state = DoorStates.Closed;
this.game = game;
this.section = section;
this.asset = "AntonPhibes" + section.ToString();
}
public PilotLamp(AbstractCar car)
{
baseCar = car;
oldState = DoorStates.None;
OnSound = new CarSound();
OffSound = new CarSound();
}
public void DoorSetState(int state)
{
if (secondsTilDefault > 0.0f)
if ((DoorStates)state == defaultState || defaultTimer > 0.0f)
return;
doorState = (DoorStates)state;
if (doorState == DoorStates.Open)
doorOpenCount++;
else
doorOpenCount--;
if (doorOpenCount < 0) doorOpenCount = 0;
if (doorOpenCount <= 0)
{
targetPosition = closedPosition + basePosition;
}
else
{
targetPosition = openPosition + basePosition;
if (playAudio && doorOpenCount == 1 && doorState == DoorStates.Open)
audio.PlayOneShot(audio.clip);
}
if (secondsTilDefault > 0.0f)
{
if (defaultState != doorState)
defaultTimer = secondsTilDefault;
}
}
private void SendTheMessage(int doorId, DoorStates state)
{
Task.Factory.StartNew(() =>
{
var message = _messageFactory.CreateDoorControlMessage(doorId, state);
_messageWriterService?.SendMessage(message);
});
}
internal void DoorChange(DoorStates oldState, DoorStates newState)
{
if (newState == DoorStates.None) {
doorCls = true;
} else {
doorCls = false;
}
}
protected void Open()
{
// Play Opening animation
OnDoorOpen?.Invoke();
objectCollider.enabled = false;
currentDoorState = DoorStates.Open;
}
public void OpenDoor(int x)
{
if (state != DoorStates.Open)
{
state = DoorStates.Opening;
}
//boneTransforms[d] = Matrix.CreateTranslation(0, 200, 0) * bindTransforms[d];
}
public void CloseDoor(int x)
{
if (state != DoorStates.Closed)
{
state = DoorStates.Closing;
}
//boneTransforms[d] = Matrix.CreateTranslation(0, 0, 0) * bindTransforms[d];
}
public void HandleDoorClosedEvent(object source, DoorClosedEventArgs args)
{
switch (_currentState)
{
case DoorStates.DoorOpen:
_currentState = DoorStates.DoorClosed;
break;
}
}
private void LogDoorStateEvent(int doorId, DoorStates state)
{
var currentEvent = _createEvent().ForDoorWithId(doorId);
using var context = _createDoorContext();
context.Events.Add((DoorEvent)currentEvent.SetTheEventDescriptionTo(state));
context.Doors.First(d => d.Id == doorId).State = state;
context.SaveChanges();
}
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
public void DoorChange(DoorStates oldState, DoorStates newState)
{
this.Doors = newState;
foreach (var device in this.Devices)
{
device.DoorChange(oldState, newState);
}
this.Calling.DoorChange(oldState, newState);
}
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
internal override void DoorChange(DoorStates oldState, DoorStates newState)
{
if (oldState != DoorStates.None & newState == DoorStates.None)
{
if (this.State == States.Pattern)
{
this.State = States.Released;
}
}
}
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
public void DoorChange(DoorStates oldState, DoorStates newState)
{
if (oldState != DoorStates.None & newState == DoorStates.None)
{
if (this.SignalType != SignalTypes.None & !this.SignalCalled)
{
CallOutSignalAspect(false);
}
}
}
public void DoorChange(DoorStates _p1, DoorStates _p2)
{
_doorState = _p2;
try { Impl.DoorChangeAny(); } catch (Exception ex) { RuntimeException(ex); }
if ((_p1 == DoorStates.None) == (_p2 == DoorStates.None))
{
return;
}
try { Impl.DoorChange(); } catch (Exception ex) { RuntimeException(ex); }
}
// --- constructors ---
/// <summary>Creates a new train without any devices installed.</summary>
/// <param name="panel">The array of panel variables.</param>
/// <param name="playSound">The delegate to play sounds.</param>
internal Train(int[] panel, PlaySoundDelegate playSound)
{
this.PluginInitializing = false;
this.Specs = new VehicleSpecs(0, BrakeTypes.ElectromagneticStraightAirBrake, 0, false, 0);
this.State = new VehicleState(0.0, new Speed(0.0), 0.0, 0.0, 0.0, 0.0, 0.0);
this.Handles = new ReadOnlyHandles(new Handles(0, 0, 0, false));
this.Doors = DoorStates.None;
this.Panel = panel;
this.Sounds = new Sounds(playSound);
this.AI = new AI(this);
}
/// <summary>
/// Opens or closes the door based on its current status
/// </summary>
public virtual void ToggleDoor()
{
if (DoorState == DoorStates.Open)
{
DoorState = DoorStates.Closed;
}
else
{
DoorState = DoorStates.Open;
}
}
/// <summary>Is called when the state of the doors changes.</summary>
public void DoorChange(DoorStates oldState, DoorStates newState)
{
if (oldState == DoorStates.None & newState != DoorStates.None) /* Door is opened */
{
SafetySystem.DoorOpened = true;
}
else if (oldState != DoorStates.None & newState == DoorStates.None) /* Door is closed */
{
SafetySystem.DoorOpened = false;
}
}
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
public void DoorChange(DoorStates oldState, DoorStates newState)
{
if (oldState == DoorStates.None & newState != DoorStates.None)
{
// TODO: Your old DoorOpen code goes here.
}
else if (oldState != DoorStates.None & newState == DoorStates.None)
{
// TODO: Your old DoorClose code goes here.
}
}
// --- constructors ---
/// <summary>Creates a new train without any devices installed.</summary>
/// <param name="panel">The array of panel variables.</param>
/// <param name="playSound">The delegate to play sounds.</param>
internal Train(int[] panel, PlaySoundDelegate playSound)
{
this.PluginInitializing = false;
this.Specs = new VehicleSpecs(0, BrakeTypes.ElectromagneticStraightAirBrake, 0, false, 0);
this.State = new VehicleState(0.0, new Speed(0.0), 0.0, 0.0, 0.0, 0.0, 0.0);
this.Handles = new ReadOnlyHandles(new Handles(0, 0, 0, false));
this.Doors = DoorStates.None;
this.Panel = panel;
this.Sounds = new Sounds(playSound);
this.AI = new AI(this);
}
public void DoorChange(DoorStates oldState, DoorStates newState)
{
if (newState == DoorStates.None)
{
Win32DetailManagerPInvoke.DoorClose();
}
else if (oldState == DoorStates.None)
{
Win32DetailManagerPInvoke.DoorOpen();
}
}
public void DoorChange(DoorStates oldState, DoorStates newState)
{
if (oldState == DoorStates.None && (newState == DoorStates.Right || newState == DoorStates.Left))
{
ATSPlugin.Cpp.DoorOpen();
}
if (newState == DoorStates.None && (oldState == DoorStates.Right || oldState == DoorStates.Left))
{
ATSPlugin.Cpp.DoorClose();
}
}
internal override void DoorChange(DoorStates oldState, DoorStates newState)
{
try
{
this.Api.DoorChange(oldState, newState);
}
catch (Exception ex)
{
base.LastException = ex;
throw;
}
}
internal override void DoorChange(DoorStates oldState, DoorStates newState)
{
#if !DEBUG
try {
#endif
this.Api.DoorChange(oldState, newState);
#if !DEBUG
} catch (Exception ex) {
base.LastException = ex;
throw;
}
#endif
}
internal override void DoorChange(DoorStates oldState, DoorStates newState)
{
if (oldState == DoorStates.None && newState != DoorStates.None)
{
atoState = AtoStates.Stopped;
}
else if (oldState != DoorStates.None && newState == DoorStates.None)
{
//Door closed
atoState = AtoStates.Ready;
readyTimer = ATO_READY_TIMER;
}
}
internal override void DoorChange(DoorStates oldState, DoorStates newState)
{
#if !DEBUG
try {
#endif
this.Api.DoorChange(oldState, newState);
#if !DEBUG
}
catch (Exception ex) {
base.LastException = ex;
throw;
}
#endif
}
public void Update(DoorStates newState)
{
if (oldState != DoorStates.None & newState == DoorStates.None)
{
Lit = true;
OnSound.Play(baseCar, false);
}
else if (oldState == DoorStates.None & newState != DoorStates.None)
{
Lit = false;
OffSound.Play(baseCar, false);
}
oldState = newState;
}
public void DoorChange(DoorStates oldState, DoorStates newState)
{
if (Stations.Count > 0) {
if (/*oldState != DoorStates.None && */newState == DoorStates.None
&& vState.Vehicle.Speed.KilometersPerHour == 0
&& (Stations[lastCompletedDockingIndex + 1].DoorOpen == -1 || Stations[lastCompletedDockingIndex + 1].DoorOpen >= 1)
&& vState.Vehicle.Location >= Stations[lastCompletedDockingIndex + 1].StopPosition - OpenDoorStopsErrorRange
&& vState.Vehicle.Location <= Stations[lastCompletedDockingIndex + 1].StopPosition + OpenDoorStopsErrorRange
&& lastCompletedDockingIndex < Stations.Count)
{
lastCompletedDockingIndex++;
}
}
}
public DoorControl(IDoor door, IUserValidation userValidation, IEntryNotification entryNotification, IAlarm alarm)
{
_door = door;
_userValidation = userValidation;
_entryNotification = entryNotification;
_alarm = alarm;
_currentState = DoorStates.DoorClosed;
if (_door == null)
{
return;
}
_door.DoorOpenedEvent += HandleDoorOpenedEvent;
_door.DoorClosedEvent += HandleDoorClosedEvent;
}
public Door CreateDoor(int x, int y, DoorTypes type, DoorStates state, DoorDirections direction)
{
Transform parent = this.container.Find("Entities/Doors");
GameObject obj = GameObject.Instantiate(prefabs.doors[type]);
obj.transform.SetParent(parent, false);
obj.name = type.ToString(); //"Item";
Door door = obj.GetComponent<Door>();
door.Init(this, x, y, Color.white);
door.type = type;
door.state = state;
door.SetDirection(direction);
return door;
}
internal override void DoorChange(DoorStates oldState, DoorStates newState)
{
if (oldState == DoorStates.None & newState != DoorStates.None) {
try {
Win32DoorOpen();
} catch (Exception ex) {
base.LastException = ex;
throw;
}
} else if (oldState != DoorStates.None & newState == DoorStates.None) {
try {
Win32DoorClose();
} catch (Exception ex) {
base.LastException = ex;
throw;
}
}
}
public void DoorToggle()
{
if (doorState == DoorStates.Closed)
doorState = DoorStates.Open;
else
doorState = DoorStates.Closed;
if (doorState == DoorStates.Closed)
targetPosition = closedPosition + basePosition;
else
targetPosition = openPosition + basePosition;
if (secondsTilDefault > 0.0f)
{
if (defaultState != doorState)
defaultTimer = secondsTilDefault;
}
}
public void CloseDoor(int x)
{
if(state!= DoorStates.Closed)
state = DoorStates.Closing;
//boneTransforms[d] = Matrix.CreateTranslation(0, 0, 0) * bindTransforms[d];
}
/// <summary>Called when the state of the doors changes.</summary> internal abstract void DoorChange(DoorStates oldState, DoorStates newState);
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
public void DoorChange(DoorStates oldState, DoorStates newState) {
if (oldState == DoorStates.None & newState != DoorStates.None) {
// TODO: Your old DoorOpen code goes here.
} else if (oldState != DoorStates.None & newState == DoorStates.None) {
// TODO: Your old DoorClose code goes here.
}
}
internal void DoorChange(DoorStates oldState, DoorStates newState) {
doorCls = newState == DoorStates.None; // E~A~S~Y~
}
void Update()
{
if (secondsTilDefault > 0.0f)
{
if (defaultTimer > 0.0f)
defaultTimer -= Time.deltaTime;
if (defaultTimer <= 0.0f && doorState != defaultState)
{
if (defaultState == DoorStates.Closed)
{
targetPosition = closedPosition + basePosition;
doorState = DoorStates.Closed;
doorOpenCount = 0;
}
else
{
targetPosition = openPosition + basePosition;
doorState = DoorStates.Open;
}
}
}
transform.position = Vector3.SmoothDamp(transform.position, targetPosition,
ref currentVelocity, smoothSpeed * Time.deltaTime);
}
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
public void DoorChange(DoorStates oldState, DoorStates newState) {
}
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
public void DoorChange(DoorStates oldState, DoorStates newState) {
this.Train.Doors = newState;
this.Train.DoorChange(oldState, newState);
}
internal void DoorChange(DoorStates oldStatue, DoorStates newState)
{
}
public void DoorChange(DoorStates oldState, DoorStates newState)
{
doorCls = newState == DoorStates.None;
}
public void OpenDoor(int x)
{
if (state != DoorStates.Open)
state = DoorStates.Opening;
//boneTransforms[d] = Matrix.CreateTranslation(0, 200, 0) * bindTransforms[d];
}
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
public void DoorChange(DoorStates oldState, DoorStates newState)
{
ms.DoorChange(oldState, newState);
tims.DoorChange(oldState, newState);
}
/// <summary>Is called when the state of the doors changes.</summary>
/// <param name="oldState">The old state of the doors.</param>
/// <param name="newState">The new state of the doors.</param>
public void DoorChange(DoorStates oldState, DoorStates newState)
{
vacma.trainEvent(new TrainEvent(EventTypes.EventTypeChangeDoors, newState));
}
/// <summary>
/// This function is called to update this component of our game
/// to the current game time.
/// </summary>
/// <param name="gameTime"></param>
public void Update(GameTime gameTime)
{
float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
switch (state)
{
case DoorStates.Closed:
canMoveThrough = false;
break;
case DoorStates.Open:
canMoveThrough = true;
break;
case DoorStates.Opening:
canMoveThrough = false;
doorTranslation += 200 *delta / timeToRasieDoor;
if (doorTranslation >= 200)
{
state = DoorStates.Open;
doorTranslation = 200;
}
foreach (int d in doors)
{
boneTransforms[d] = Matrix.CreateTranslation(0, doorTranslation, 0) * bindTransforms[d];
}
break;
case DoorStates.Closing:
canMoveThrough = false;
doorTranslation -= 200 * delta / timeToRasieDoor;
if (doorTranslation <= 0)
{
state = DoorStates.Closed;
doorTranslation = 0;
}
foreach (int d in doors)
{
boneTransforms[d] = Matrix.CreateTranslation(0, doorTranslation, 0) * bindTransforms[d];
}
break;
}
}
