private void DoorUpdate() { switch (Status) { case DoorStatus.Close: if (transform.position.y > DoorPos.y) { transform.Translate(0, -Speed * Time.deltaTime, 0); } else { transform.position = DoorPos; Status = DoorStatus.Still; } break; case DoorStatus.Open: if (transform.position.y < DoorPos.y + Height) { transform.Translate(0, Speed * Time.deltaTime, 0); } else { Status = DoorStatus.Still; } break; default: break; } }
public void ChangeBayDoors(DoorStatus state) { string actionString; if (state == DoorStatus.Closed) { actionString = "Open_Off"; } else if (state == DoorStatus.Open) { actionString = "Open_On"; } else { Echo("Invalid End Door State"); return; } hangarDoors.GetBlocksOfType <IMyAirtightHangarDoor>(doorList); if (startDoorMove) { ITerminalAction action; action = doorList.First().GetActionWithName(actionString); doorList.ForEach((door) => action.Apply(door)); startDoorMove = false; } if (CheckDoorState(state)) { currentState = State.Idle; currentDoorState = state; Echo("Finished"); } }
public void Populate(string text, IEnumerable <iDoor> doors, DoorStatus status) { if (!doors.IsNullOrEmpty() && !string.IsNullOrWhiteSpace(text)) { var splitted = text.Replace(" ", "").Split(','); foreach (var range in splitted) { if (range.Contains("-")) { var splittedRange = range.Split('-'); int.TryParse(splittedRange.FirstOrDefault(), out var first); int.TryParse(splittedRange.LastOrDefault(), out var last); SetDoors(doors, status, Enumerable.Range(first, last - first - 1).ToArray()); } else { int.TryParse(range, out var number); SetDoors(doors, status, number); } } } }
public MainPage() { this.InitializeComponent(); Controller = GpioController.GetDefault(); if (null != Controller) { TxtMessage.Text += "[OK] GPIO Controller Initialized." + Environment.NewLine; Uln2003Driver = new Uln2003Driver(Controller, 5, 6, 13, 19); TxtMessage.Text += "[OK] Uln2003Driver Initialized on 5,6,13,19." + Environment.NewLine; Status = DoorStatus.Closed; PinVT = Controller.OpenPin(4); PinVT.SetDriveMode(GpioPinDriveMode.Input); TxtMessage.Text += "[OK] VT Initialized on GPIO 04." + Environment.NewLine; PinVT.ValueChanged += async(sender, args) => { if (!IsBusy && PinVT.Read() == GpioPinValue.High && Status != DoorStatus.Open) { IsBusy = true; await LogMessageAsync("Remote Signal Received on VT."); await OpenDoorAsync(); await Task.Delay(2000); await CloseDoorAsync(); IsBusy = false; } }; } }
//not needed?? ///<summary> ///constructor ///</summary> ///<param name="map"></param> ///<param name="doorData"></param> public Door(Map map, DoorData doorData) : base(new EntitySceneObject()) { _status = DoorStatus.Closed; _numTicksStayOpen = 600; //TODO: this should be a parameter Name = doorData.Name; _p1 = doorData.From; _p2 = doorData.To; _switchIds = new List<uint>(); foreach (string triggerName in doorData.TriggerList) { T2DSceneObject trigger = TorqueObjectDatabase.Instance.FindObject<T2DSceneObject>(triggerName); Assert.Fatal(trigger != null, "Door.Door: no trigger"); if (trigger != null) _switchIds.Add(trigger.ObjectId); } _toP2Norm = Vector2.Normalize(_p2 - _p1); _currentSize = _doorSize = Vector2.Distance(_p2, _p1); Vector2 perp = Vector2Util.Perp(_toP2Norm); //create the walls that make up the door's geometry _wall1 = map.AddWall(_p1 + perp, _p2 + perp); _wall2 = map.AddWall(_p2 - perp, _p1 - perp); }
private IEnumerator ChangeStatus() { while (true) { float waitTime = 0.0f; DoorStatus nextStatus = DoorStatus.Blank; switch (_currStatus) { case DoorStatus.Close: waitTime = _closeDuration; //Set wait time nextStatus = DoorStatus.Open; //Set next status _renderer.material.SetColor("_Color", Color.red); break; case DoorStatus.Open: waitTime = _openDuration; nextStatus = DoorStatus.Close; _renderer.material.SetColor("_Color", Color.green); this.gameObject.GetComponent <DoorController>().Open(); break; } yield return(new WaitForSeconds(waitTime)); //Change Status after X seconds _currStatus = nextStatus; } }
public void SetStatus(DoorStatus status) { for (int i = 0; i < buttons.Length; i++) { switch (status) { case DoorStatus.Open: buttons[i].material = matOpen; lights[i].color = Color.green; break; case DoorStatus.Locked: buttons[i].material = matLocked; lights[i].color = Color.red; break; case DoorStatus.Puzzle: buttons[i].material = matPuzzle; lights[i].color = Color.blue; break; case DoorStatus.Enemies: buttons[i].material = matEnemies; lights[i].color = Color.red; break; default: break; } } }
public static ACState ToACState(DoorStatus doorStatus) { var states = GetDoorStates(doorStatus); var iconKey = GetDoorStateIconKey(doorStatus); return(new ACState(doorStatus.DoorId.ToString(), states, iconKey, null)); }
IEnumerator OpenDoors() { if (doorOpeningSoundClip != null) { audioSource.PlayOneShot(doorOpeningSoundClip, 0.7F); } status = DoorStatus.Animating; float t = 0f; while (t < 1f) { t += Time.deltaTime * speed; halfDoorLeftTransform.localPosition = Vector3.Slerp(leftDoorClosedPosition, leftDoorOpenPosition, t); halfDoorRightTransform.localPosition = Vector3.Slerp(rightDoorClosedPosition, rightDoorOpenPosition, t); yield return(null); } status = DoorStatus.Open; doorObstacle.enabled = false; }
/*////////////////////////////////////////////////////////////////////////////////////////////////*/ /// <summary> /// determine what to do based on door's status /// </summary> /*///////////////////////////////////////////////////////////////////////////////////////////////*/ public void UpdateDoor(DoorStatus _status) { if(_status == DoorStatus.CLOSED) CloseDoor(); else if (_status == DoorStatus.OPEN) OpenDoor(); }
void OnTriggerExit(Collider other) { if (other.CompareTag(KeyTag) || other.CompareTag("Player")) { Status = DoorStatus.CLOSE; } }
private static DoorStatus MapLockBooleansToDoorStatus(RegisterDoorRequestModel model) { DoorStatus status = DoorStatus.Unknown; if (!model.LockMagBondStatus && !model.LockReedStatus) { status = DoorStatus.Open; } if (!model.LockMagBondStatus && !model.LockReedStatus && (model.LockTriggerStatus || model.LockRequestExitStatus)) { status = DoorStatus.Locking; } if (!model.LockMagBondStatus && model.LockReedStatus) { status = DoorStatus.Closed; } if (model.LockMagBondStatus && model.LockReedStatus) { status = DoorStatus.Locked; } if (model.LockMagBondStatus && !model.LockReedStatus) { status = DoorStatus.Fault; } if (model.LockRequestExitStatus) { status = DoorStatus.UnlockRequested; } return(status); }
public void Move(Direction direction) { motorStatus = GetMotorStatus(); if (motorStatus == MotorStatus.MOVING) { return; } DoorStatus doorStatus = door.GetDoorStatus(); if (doorStatus == DoorStatus.OPEND) { door.Close(); } Console.WriteLine("Closing the door"); SetMotorStatus(MotorStatus.MOVING); //concret class implements this method MoveMotor(direction); SetMotorStatus(MotorStatus.STOPPED); door.Open(); Console.WriteLine("Opening the door"); }
public override void NotColliding(Model with) { if (with.GetType() != typeof(Character)) return; Character chara = (Character)with; if (mPlayerIndex != (PlayerIndex)chara.Index) return; mDoorStatus = DoorStatus.CLOSED; }
public GarageDoor(String name, List <IMyAirtightHangarDoor> doors) { this.name = name; this.doors = doors; DoorStatus iniStatus = doors[0].Status; open = (iniStatus == DoorStatus.Open || iniStatus == DoorStatus.Opening ? true : false); }
void OnTriggerStay(Collider other) { if (other.CompareTag(KeyTag) || other.CompareTag("Player")) { _door_timer = 0; Status = DoorStatus.OPEN; } }
IEnumerator Lift() { gameObject.transform.Translate(new Vector3(0, (float)0.7* Time.fixedDeltaTime, 0)); if(gameObject.transform.position.y > maxHeight){ state = DoorStatus.Drop; Debug.Log("Vamos para abajo"); } yield return null; }
IEnumerator Drop() { gameObject.transform.Translate(new Vector3(0, (float)-2.1 * Time.fixedDeltaTime, 0)); if(gameObject.transform.position.y <= f){ state = DoorStatus.Lift; Debug.Log("Vamos para arriba"); } yield return null; }
public async Task UpdateDoorStateAsync(DoorStatus status) { var doors = await _unitOfWork.Door.GetAllAsync().ConfigureAwait(false); var door = doors[0]; door.DoorStatus = status; await _unitOfWork.Door.UpdateValue(x => x.BsonObjectId, door.BsonObjectId, x => x.DoorStatus, door.DoorStatus).ConfigureAwait(false); }
public void SetInitialStatus() { switch (startStatus){ case DoorStatus.Close: Close(); break; case DoorStatus.Open: Open(); break; case DoorStatus.Opened: ForcePosition(slideDestiny); break; } currentStatus = startStatus; }
public Door(string street, string number, int doorNumber, int entrance, DoorStatus status, IList <iCode> codes) : base(street, number) { DoorNumber = doorNumber; Entrance = entrance; Status = status; Codes = codes; }
private void Moving() { transform.position = Vector3.Lerp(transform.position, targetPosition, Time.deltaTime * speed); if ((transform.position - targetPosition).sqrMagnitude < positionThreshold) { transform.position = targetPosition; currentStatus = targetStatus; } }
public override void Collided(Model with, Displayable.CollisionStatus status) { if (status == Displayable.CollisionStatus.TOP) return; if (with.GetType() != typeof(Character)) return; Character chara = (Character)with; if (mPlayerIndex != (PlayerIndex)chara.Index) return; mDoorStatus = DoorStatus.OPEN; }
public void Toggle() { if (status != DoorStatus.DESTROYED) { status = (status == DoorStatus.CLOSED) ? DoorStatus.OPEN : DoorStatus.CLOSED; } SetDoorHingeAppearance(); }
IEnumerator EnterNew(int directTemp) { yield return(new WaitForSeconds(1f)); GameManager.Scene[GameManager.LastSceneNum].Reset(); GameManager.CreatScene().Enter(-directTemp); GameManager.InputEnable = true; Status = DoorStatus.Close; }
public void Open() { if (currentStatus == DoorStatus.closed || currentStatus == DoorStatus.closing) { currentStatus = DoorStatus.opening; targetPosition = openedPosition; targetStatus = DoorStatus.opened; mySound.Play(); } }
private void SetDoors(IEnumerable <iDoor> doors, DoorStatus status, params int[] numbers) { foreach (var i in numbers) { if (doors.FirstOrDefault(x => x.DoorNumber == i) is DoorVm find) { find.Status = status; } } }
private async Task OpenDoorAsync() { Cts = new CancellationTokenSource(); await LogMessageAsync("Opening Door..."); await Uln2003Driver.TurnAsync(90, TurnDirection.Left, Cts.Token); Status = DoorStatus.Open; await LogMessageAsync("Door is Open."); }
private async Task CloseDoorAsync() { Cts = new CancellationTokenSource(); await LogMessageAsync("Closing Door..."); await Uln2003Driver.TurnAsync(90, TurnDirection.Right, Cts.Token); Status = DoorStatus.Closed; await LogMessageAsync("Door is Closed."); }
internal void Toggle() { if (Status == DoorStatus.Opened) { Status = DoorStatus.Closed; } else { Status = DoorStatus.Opened; } }
/*////////////////////////////////////////////////////////////////////////////////////////////////*/ /// <summary> /// Activate /// </summary> /*///////////////////////////////////////////////////////////////////////////////////////////////*/ public override void Activate(SensorData _sensorData) { if(_SensorObjectType == SensorObjectType.AUTOMATIC) { //door is closed, open it if(_sensorData.status == SensorStatus.ENTERED) _DoorStatus = DoorStatus.OPEN; //door is open, close it else if(_sensorData.status == SensorStatus.EXITED) _DoorStatus = DoorStatus.CLOSED; } }
public ActionResult <RegisterDoorResponseModel> RegisterDoor(RegisterDoorRequestModel model) { if (model == null) { return new RegisterDoorResponseModel { Success = false } } ; if (string.IsNullOrEmpty(model.MacAddress)) { return new RegisterDoorResponseModel { Success = false } } ; DoorStatus status = MapLockBooleansToDoorStatus(model); var door = DataContext.Doors.FirstOrDefault(d => d.MacAddress == model.MacAddress); if (door == null) { door = new Door() { MacAddress = model.MacAddress, Name = "Unknown", Status = status, CreatedTimestamp = DateTime.Now }; DataContext.Add(door); } door.LastHeartbeatTimestamp = DateTime.Now; door.IsDeleted = false; door.Status = status; int remoteUnlockRequestSeconds = door.RemoteUnlockRequestSeconds ?? 0; if (remoteUnlockRequestSeconds != 0) { door.RemoteUnlockRequestSeconds = null; } DataContext.SaveChanges(); return(new RegisterDoorResponseModel { Success = true, DoorId = door.Id, RemoteUnlockRequestSeconds = remoteUnlockRequestSeconds }); }
private void OnTriggerEnter(Collider other) { if (other.tag == "Key") { audioSource.clip = keyFoundClip; audioSource.Play(); keyObatined = true; DoorState = DoorStatus.Opened; Destroy(other.gameObject); } }
IEnumerator ReturnToLast(int directTemp) { yield return(new WaitForSeconds(1f)); GameManager.Scene[GameManager.LastSceneNum].Enter(-directTemp); int Temp = GameManager.ThisSceneNum; GameManager.ThisSceneNum = GameManager.LastSceneNum; GameManager.LastSceneNum = Temp; GameManager.InputEnable = true; Status = DoorStatus.Close; }
public bool CheckDoorState(DoorStatus desiredState) { bool returnState = true; foreach (IMyAirtightHangarDoor door in doorList) { if (door.Status != desiredState) { returnState = false; } } return returnState }
public override string ToText(MonitorContent content) { switch (content.Subtype) { case "stat": return(EnumToText((int)DoorStatus, DoorStatus.ToString(), content)); case "open": return(BoolToText(Open, "Open", "", content)); case "close": return(BoolToText(Close, "Close", "", content)); default: return(base.ToText(content)); } }
private static IEnumerable <string> GetDoorStates(DoorStatus status) { if (status == null) { yield return(DoorStatusId.Unknown); } // Return open/closed state yield return(status.IsOpen ? DoorStatusId.Open : DoorStatusId.Closed); // Return add lock state yield return(status.IsLocked ? DoorStatusId.Locked : DoorStatusId.Unlocked); }
void Close() { print ("DOOR CLOSES : "+gameObject.name); Vector3 dest = doorObject.transform.position; switch (slideDestiny){ case SlideDestiny.Down: dest+=Vector3.up*moveDist; break; case SlideDestiny.Up: dest+=Vector3.down*moveDist; break; case SlideDestiny.Left: dest+=Vector3.right*moveDist; break; case SlideDestiny.Right: dest+=Vector3.left*moveDist; break; } LeanTween.move(doorObject,dest,moveTime).setEase(moveTween); currentStatus = DoorStatus.Closed; }
internal static string DoorStatusTostring(DoorStatus status) { switch (status) { default: case DoorStatus.Unknown: return "Unknown"; case DoorStatus.Offline: return "Offline"; case DoorStatus.Open: return "Open"; case DoorStatus.Opening: return "Opening"; case DoorStatus.Closed: return "Closed"; case DoorStatus.Closing: return "Closing"; } }
public void Tigger() { GameManager.Scene[GameManager.ThisSceneNum].Leave(); GameManager.InputEnable=false; Status=DoorStatus.Open; if(GameManager.gameMode==GameManager.GameMode.RandomMode) { RandomModeTigger(); } if(GameManager.gameMode==GameManager.GameMode.StoryMode) { StoryModeTigger(); } }
void Update() { if (DoorInfo == DoorStatus.IsClosed) { if (head.rotation == Quaternion.identity) DoorInfo = DoorStatus.IsThePosition; HeadRotation(Quaternion.identity); } else if (DoorInfo == DoorStatus.IsOpened) { if (targetObject == null) { DoorInfo = DoorStatus.IsClosing; anim.SetBool("Open", false); return; } var dir = targetObject.transform.position - transform.position; var angle = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg; var newRotation = Quaternion.AngleAxis(angle - 90, Vector3.forward); HeadRotation(newRotation); } }
protected override void Init(int param) { mDoorStatus = DoorStatus.CLOSED; mPlayerIndex = (PlayerIndex)param; }
///<summary> ///Handle messages sent to this door. ///</summary> ///<param name="msg">the message</param> ///<returns>true if message was handled by this door</returns> public override bool HandleMessage(Telegram msg) { if (msg.Msg == MessageTypes.OpenSesame) { if (_status != DoorStatus.Open) { _status = DoorStatus.Opening; } return true; } return false; }
private void EvaluateDoorState() { var down = _doorDownPin.Read(); var up = _doorUpPin.Read(); var newStatus = DoorStatus.Unknown; if (up == GpioPinValue.High && down == GpioPinValue.Low) newStatus = DoorStatus.Closed; else if (up == GpioPinValue.Low && down == GpioPinValue.High) newStatus = DoorStatus.Opened; else if (up == GpioPinValue.High && down == GpioPinValue.High) { if (_lastStatus == DoorStatus.Closed) newStatus = DoorStatus.Opening; else if (_lastStatus == DoorStatus.Opened) newStatus = DoorStatus.Closing; } if (newStatus != _lastStatus) { var elapsedTime = 0; if (newStatus== DoorStatus.Opening || newStatus == DoorStatus.Closing) { _stopWatch = Stopwatch.StartNew(); } else if ((newStatus== DoorStatus.Closed || newStatus == DoorStatus.Opened) && _stopWatch!=null) { _stopWatch.Stop(); elapsedTime = Convert.ToInt32(_stopWatch.ElapsedMilliseconds); } _producer.Signals.GarageDoorStateChanged(Convert.ToUInt32(_lastStatus), Convert.ToUInt32(newStatus), elapsedTime); _lastStatus = newStatus; } }
IEnumerator EnterNew(int directTemp) { yield return new WaitForSeconds(1f); GameManager.Scene[GameManager.LastSceneNum].Reset(); GameManager.CreatScene().Enter(-directTemp); GameManager.InputEnable=true; Status=DoorStatus.Close; }
///<summary> ///Update the door (part of the game update logic) ///TODO: should we cache the trigger objects? ///</summary> ///<param name="dt">time since last update</param> public override void Update(float dt) { switch (_status) { case DoorStatus.Opening: Open(); foreach (uint triggerId in _switchIds) { DoorButtonSceneObject trigger = TorqueObjectDatabase.Instance.FindObject<DoorButtonSceneObject>(triggerId); trigger.SetTransitioning(); } break; case DoorStatus.Closing: Close(); foreach (uint triggerId in _switchIds) { DoorButtonSceneObject trigger = TorqueObjectDatabase.Instance.FindObject<DoorButtonSceneObject>(triggerId); trigger.SetTransitioning(); } break; case DoorStatus.Open: { foreach (uint triggerId in _switchIds) { DoorButtonSceneObject trigger = TorqueObjectDatabase.Instance.FindObject<DoorButtonSceneObject>(triggerId); trigger.SetOpen(); } if (_numTicksCurrentlyOpen-- < 0) { _status = DoorStatus.Closing; } } break; default: foreach (uint triggerId in _switchIds) { DoorButtonSceneObject trigger = TorqueObjectDatabase.Instance.FindObject<DoorButtonSceneObject>(triggerId); trigger.SetClosed(); } break; } }
private void DoorUpdate() { switch (Status) { case DoorStatus.Close: if(transform.position.y>DoorPos.y) { transform.Translate(0,-Speed*Time.deltaTime,0); } else { transform.position=DoorPos; Status=DoorStatus.Still; } break; case DoorStatus.Open: if(transform.position.y<DoorPos.y+Height) { transform.Translate(0,Speed*Time.deltaTime,0); } else { Status=DoorStatus.Still; } break; default: break; } }
///<summary> ///close door ///</summary> protected void Close() { if (_status != DoorStatus.Closing) return; if (_currentSize == _doorSize) { _status = DoorStatus.Closed; return; } //reduce the current size _currentSize += 1; _currentSize = MathHelper.Clamp(_currentSize, 0, _doorSize); ChangePosition(_p1, _p1 + _toP2Norm*_currentSize); }
///<summary> ///open door ///</summary> protected void Open() { if (_status != DoorStatus.Opening) return; if (_currentSize < 2) //TODO: should be a parameter { _status = DoorStatus.Open; _numTicksCurrentlyOpen = _numTicksStayOpen; return; } //reduce the current size _currentSize -= 1; _currentSize = MathHelper.Clamp(_currentSize, 0, _doorSize); ChangePosition(_p1, _p1 + _toP2Norm*_currentSize); }
IEnumerator ReturnToLast(int directTemp) { yield return new WaitForSeconds(1f); GameManager.Scene[GameManager.LastSceneNum].Enter(-directTemp); int Temp = GameManager.ThisSceneNum; GameManager.ThisSceneNum = GameManager.LastSceneNum; GameManager.LastSceneNum = Temp; GameManager.InputEnable=true; Status=DoorStatus.Close; }
public void Enter() { transform.position=new Vector3(transform.position.x,transform.position.y+Height,transform.position.z); Status=DoorStatus.Close; }
void DoorInfoStatus(DoorStatus status) { DoorInfo = status; }
private bool OpenDoor() { try { Status = DoorStatus.Opening; _motor.Up(); var starttime = PowerState.Uptime; while (!!IsOpen()) { int elapsed = PowerState.Uptime.Subtract(starttime).Seconds; if (elapsed >= MaxOpenTimeInSec) { Logger.Instance.LogError("Failed to open door " + Name + " in " + elapsed + " sec"); Status = DoorStatus.Unknown; return false; } Thread.Sleep(100); } } catch (Exception ex) { Logger.Instance.LogException("Error opening door " + Name, ex); } finally { _motor.Off(); } // Door was opened Status = DoorStatus.Open; return true; }