public void Update(TimeSpan span) { if (Timeout > 0 && Door.Status == DoorStatus.Open) { Interval += span.TotalSeconds; if (Interval >= Timeout) { Door.CloseDoor(); } } else { Interval = 0; } if (Opposite != null) { if (Opposite.IsFunctional && Opposite.Status != DoorStatus.Closed) { if (Door.Enabled = (Door.Status != DoorStatus.Closed)) { Door.CloseDoor(); } } else { Door.Enabled = true; } } }
//returns wether the door was attempted to be opened or not. //in other words, if the elevator should go to this station or not public bool Update() { //if the door is being opened at the time since the last call of open() is more than 7 seconds ago //without the time check the door would automatically close everytime the station tries to open it. if (door.Status == DoorStatus.Opening && DateTime.Now.Ticks - opened.Ticks > 30000000) { door.CloseDoor(); return(true); } if (door.Status == DoorStatus.Open && DateTime.Now.Ticks - opened.Ticks > 30000000) { door.CloseDoor(); } return(false); }
private void Cycle(bool?pressurize = null) { if (_status == VentStatus.Depressurizing || _status == VentStatus.Pressurizing || pressurize == AirlockHasPressure || !_enabled) { return; } if (pressurize ?? !AirlockHasPressure) { _status = VentStatus.Pressurizing; _outerDoor.CloseDoor(); } else { _status = VentStatus.Depressurizing; _innerDoor.CloseDoor(); } }
public static void ToggleOpenAndEnable(this IMyDoor door, Boolean open, Boolean enabled) { switch (door.Status) { case DoorStatus.Open: if (open) { door.Enabled = enabled; } else { door.Enabled = true; door.CloseDoor(); } break; case DoorStatus.Opening: if (!open) { door.Enabled = true; door.CloseDoor(); } break; case DoorStatus.Closing: if (open) { door.Enabled = true; door.OpenDoor(); } break; case DoorStatus.Closed: if (open) { door.Enabled = true; door.OpenDoor(); } else { door.Enabled = enabled; } break; } }
public void Close() { if (!door.IsWorking) { door.Enabled = true; } door.CloseDoor(); }
public void setState(bool open) { if (open) { door.OpenDoor(); } else { door.CloseDoor(); } }
void ProcessJobs() { if (schedule.Count > 0 && schedule[0].TTJ <= 0) { Job curr = schedule[0]; schedule.RemoveAt(0); string name = "ANTI-"; IMyDoor antiDoor = GridTerminalSystem.GetBlockWithName("[NO-RENAME] Anti Door " + curr.misNo) as IMyDoor; switch (curr.type) { case JobType.OpenDoor: if (antiDoor != null) { antiDoor.OpenDoor(); } break; case JobType.Launch: IMyProgrammableBlock missile = GridTerminalSystem.GetBlockWithName(name + curr.misNo) as IMyProgrammableBlock; if (missile == null) { string message = "ABORTING LAUNCH: MISSILE DOES NOT EXIST: \"" + name + curr.misNo + "\""; Output(message); Function(false); //ErrorOutput(message); return; } else { Entry target; long id; if (curr.code.Length > 0 && long.TryParse(curr.code, out id) && TryGetAMT(id, out target)) { missile.TryRun("prep " + target.Position.X + " " + target.Position.Y + " " + target.Position.Z + " " + curr.code); } } break; case JobType.CloseDoor: if (antiDoor != null) { antiDoor.CloseDoor(); } break; } } foreach (Job job in schedule) { --job.TTJ; } }
public void Update(double seconds) { if (settingsInput != door.CustomData) { string[] configuration_attributes = door.CustomData.Split('\n'); doNotIgnore = true; customDoorOpenTime = null; foreach (string configuration_attribute in configuration_attributes) { string trimmed_configuration_attribute = configuration_attribute.Trim(); string[] key_value_pair = trimmed_configuration_attribute.Trim().Split(':'); string key = ((key_value_pair.Length > 0) ? key_value_pair[0] : string.Empty); string value = ((key_value_pair.Length > 1) ? ((trimmed_configuration_attribute.Length > (key.Length + 1)) ? trimmed_configuration_attribute.Substring(key.Length + 1).Trim() : string.Empty) : string.Empty); switch (key.Trim()) { case "ignore": doNotIgnore = false; break; case "openTime": float open_time; if (float.TryParse(value, out open_time)) { customDoorOpenTime = open_time; } break; } } settingsInput = door.CustomData; } if (doNotIgnore && door.IsWorking && (Status == DoorStatus.Open)) { elapsedOpenTime += seconds; if (elapsedOpenTime >= OpenTime) { door.CloseDoor(); elapsedOpenTime = 0.0; } } else { elapsedOpenTime = 0.0; } }
private void ForceClose(IMyDoor door) { if (!(door.Status == DoorStatus.Closed)) { if (door.Status == DoorStatus.Open || door.Status == DoorStatus.Opening) { if (!door.Enabled) { door.Enabled = true; } door.CloseDoor(); manager.output.Print(tag + " force closing " + door.CustomName); } } else { door.Enabled = (door.Status != DoorStatus.Closed); } }
public void Check() { if (D1.OpenRatio != 0) { D2.Enabled = false; if (d1DateTime == DateTime.MinValue) { d1DateTime = DateTime.Now; } if (d1DateTime.AddSeconds(MaxSeconds) < DateTime.Now) { D1.CloseDoor(); } } else { D2.Enabled = true; d1DateTime = DateTime.MinValue; } if (D2.OpenRatio != 0) { D1.Enabled = false; if (d2DateTime == DateTime.MinValue) { d2DateTime = DateTime.Now; } if (d2DateTime.AddSeconds(MaxSeconds) < DateTime.Now) { D2.CloseDoor(); } } else { D1.Enabled = true; d2DateTime = DateTime.MinValue; } }
public void Main(string argument, UpdateType updateSource) { Runtime.UpdateFrequency = UpdateFrequency.Update10; IMyTextPanel codeScreen = (IMyTextPanel)GridTerminalSystem.GetBlockWithName("KodePanel"); IMyTextPanel acceptScreen = (IMyTextPanel)GridTerminalSystem.GetBlockWithName("AcceptScreen"); IMyDoor myDoor = (IMyDoor)GridTerminalSystem.GetBlockWithName("CommandDoor"); IMyButtonPanel buttonPanel = (IMyButtonPanel)GridTerminalSystem.GetBlockWithName("Button"); string inputPassword = codeScreen.GetText(); if (inputPassword == passcode) { myDoor.OpenDoor(); acceptScreen.WriteText("Code Accepted"); } else { myDoor.CloseDoor(); } }
public void Close() { _block.CloseDoor(); }
void closeDoor(IMyDoor door) { door.CloseDoor(); this.mainProcess.Spawn(pc => this.handledDoors.Remove(door.EntityId), $"cleanup-door {door.DisplayNameText}", period: GRACE_PERIOD, useOnce: true); }
public void ControlDoors() { if (_InsideDoorTicks != -1) { --_InsideDoorTicks; } if (_OutsideDoorTicks != -1) { --_OutsideDoorTicks; } if (_InsideDoorTicks == 0) { _InsideDoor.CloseDoor(); _InsideDoorTicks = -1; _DoorNeedsClosing = false; } if (_OutsideDoorTicks == 0) { _OutsideDoor.CloseDoor(); _OutsideDoorTicks = -1; _DoorNeedsClosing = false; } if (_InsideDoor.Status == DoorStatus.Closed && _OutsideDoor.Status == DoorStatus.Closed && _AirVent.GetOxygenLevel() == 0.0f) { _InsideDoor.Enabled = true; _OutsideDoor.Enabled = true; _InsideDoorTicks = -1; _OutsideDoorTicks = -1; _DoorNeedsClosing = false; } if (_OutsideDoor.Status == DoorStatus.Open || _OutsideDoor.Status == DoorStatus.Opening) { _InsideDoor.CloseDoor(); _InsideDoor.Enabled = false; if (!_DoorNeedsClosing) { _OutsideDoorTicks = DOOR_DELAY; _DoorNeedsClosing = true; } } if (_InsideDoor.Status == DoorStatus.Open || _InsideDoor.Status == DoorStatus.Opening) { _OutsideDoor.CloseDoor(); _OutsideDoor.Enabled = false; if (!_DoorNeedsClosing) { _InsideDoorTicks = DOOR_DELAY; _DoorNeedsClosing = true; } } }
public void Update() { if (autoClose) { if (P.Time > autoCloseTime) { //Close door after set time door.CloseDoor(); ProgramClosing = true; autoCloseTime = TimeSpan.MaxValue; } else if (door.Status == DoorStatus.Open && autoCloseTime == TimeSpan.MaxValue) { //Queue door closing //Don't need to check if the program or the user is opening the door, as the program will set auto close on its own when opening a door if (timeOpenEntering >= 0) { autoCloseTime = P.Time + TimeSpan.FromSeconds(timeOpenEntering); } } } if (lockRequest && door.Status == DoorStatus.Closed) { door.Enabled = false; lockRequest = false; } //Check if door status has changed. If it has, trigger event. if (door.Status != lastStatus) { //Launch auto close time once door is open. if (autoClose && autoCloseInSecondsOnceOpen >= 0 && door.Status == DoorStatus.Open) { autoCloseTime = P.Time + TimeSpan.FromSeconds(autoCloseInSecondsOnceOpen); autoCloseInSecondsOnceOpen = -1; } //reset ProgramOpening once the door is closed again. Have it remain while closed, so what we know who closed it. if (door.Status == DoorStatus.Closed) { ProgramOpening = false; } //reset ProgramClosing once the door is open again. Have it remain while open, so what we know who opened it. if (door.Status == DoorStatus.Open) { ProgramOpening = false; } //Trigger event foreach (var action in EventActions) { action(); } foreach (var func in EventFuncs) { func(this); } } lastStatus = door.Status; }
public DoorHandler(string doorName, IMyGridTerminalSystem gts) { name = doorName; // TODO: find the door. doorObj = (IMyDoor)gts.GetBlockWithName(name); // initialize the statemachine doorStateMachine = new StateMachine(); doorStateMachine.overrideState("closing"); // Set up the transititions, default to locked if no door. doorStateMachine.transitions.Add("enable", () => { if (doorObj == null) { return("locked"); } return((doorObj.Enabled) ? "opening" : "enable"); }); doorStateMachine.transitions.Add("opening", () => { if (doorObj == null) { return("locked"); } return((doorObj.Status == DoorStatus.Open) ? "open_wait" : "opening"); }); doorStateMachine.transitions.Add("timer_wait", () => { if (doorObj == null) { return("locked"); } return((doorStateMachine.timerActive()) ? "timer_wait" : "closing"); }); doorStateMachine.transitions.Add("closing", () => { if (doorObj == null) { return("locked"); } return((doorObj.Status == DoorStatus.Closed) ? "locked" : "closing"); }); // no transition for locked. doorStateMachine.actions.Add("enable", () => { if (doorObj == null) { return; } doorObj.Enabled = true; }); doorStateMachine.actions.Add("opening", () => { if (doorObj == null) { return; } if (doorObj.Status == DoorStatus.Opening) { return; } doorObj.OpenDoor(); }); doorStateMachine.actions.Add("open_wait", () => { if (doorObj == null) { return; } doorStateMachine.startTimer(5); doorStateMachine.overrideState("timer_wait"); }); doorStateMachine.actions.Add("closing", () => { if (doorObj == null) { return; } if (doorObj.Status == DoorStatus.Closing) { return; } doorObj.Enabled = true; doorObj.CloseDoor(); }); doorStateMachine.actions.Add("locked", () => { if (doorObj == null) { return; } doorObj.Enabled = false; }); }
public void Close() => block_.CloseDoor();
public void ControlDoors(IMyProgrammableBlock owner) { if (_InsideDoorTicks != -1) { --_InsideDoorTicks; } if (_OutsideDoorTicks != -1) { --_OutsideDoorTicks; } if (_InsideDoorTicks == 0) { _InsideDoor.CloseDoor(); _InsideDoorTicks = -1; _DoorNeedsClosing = false; } if (_OutsideDoorTicks == 0) { _OutsideDoor.CloseDoor(); _OutsideDoorTicks = -1; _DoorNeedsClosing = false; } int storedOxygenPercentage = Int32.Parse(owner.CustomData); if (_InsideDoor.Status == DoorStatus.Closed && _OutsideDoor.Status == DoorStatus.Closed && (storedOxygenPercentage > 95 || _AirVent.GetOxygenLevel() == 0.0f)) { _InsideDoor.Enabled = true; _OutsideDoor.Enabled = true; _InsideDoorTicks = -1; _OutsideDoorTicks = -1; _DoorNeedsClosing = false; } if (_OutsideDoor.Status == DoorStatus.Open || _OutsideDoor.Status == DoorStatus.Opening) { _InsideDoor.CloseDoor(); _InsideDoor.Enabled = false; if (!_DoorNeedsClosing) { _OutsideDoorTicks = DOOR_DELAY; _DoorNeedsClosing = true; } } if (_InsideDoor.Status == DoorStatus.Open || _InsideDoor.Status == DoorStatus.Opening) { _OutsideDoor.CloseDoor(); _OutsideDoor.Enabled = false; if (!_DoorNeedsClosing) { _InsideDoorTicks = DOOR_DELAY; _DoorNeedsClosing = true; } } }