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