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); } } } } }
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. } }
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; } }
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);
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; } }