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