space_engineers/MechanicalDoor/Program.cs

using Sandbox.Game.EntityComponents;
using Sandbox.ModAPI.Ingame;
using Sandbox.ModAPI.Interfaces;
using SpaceEngineers.Game.ModAPI.Ingame;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Text;
using VRage;
using VRage.Collections;
using VRage.Game;
using VRage.Game.Components;
using VRage.Game.GUI.TextPanel;
using VRage.Game.ModAPI.Ingame;
using VRage.Game.ModAPI.Ingame.Utilities;
using VRage.Game.ObjectBuilders.Definitions;
using VRageMath;

namespace IngameScript
{
    public partial class Program : MyGridProgram
    {
        MyCommandLine cli;
        List<IEnumerator<bool>> jobs;
        Dictionary<string, Door> doors;
        int tickCount;


        public Program()
        {
            tickCount = 0;
            cli = new MyCommandLine();
            jobs = new List<IEnumerator<bool>>();

            doors = new Dictionary<string, Door>();

            List<IMyMotorStator> allHinges = new List<IMyMotorStator>();
            GridTerminalSystem.GetBlocksOfType(allHinges);
            foreach (IMyMotorStator hinge in allHinges)
            {
                if (hinge.CustomName.StartsWith("Door"))
                {
                    string doorName = hinge.CustomName.Split(' ')[0];
                    if (!doors.ContainsKey(doorName))
                    {
                        doors[doorName] = new Door();
                    }
                    doors[doorName].AddHinge(hinge);
                }
            }

            Echo($"Found {doors.Keys.Count} doors.");
        }

        public void Main(string argument, UpdateType updateSource)
        {
            Echo($"index: {tickCount++}");

            if (updateSource == UpdateType.Trigger || updateSource == UpdateType.Terminal)
            {
                // Create a new job
                cli.TryParse(argument);
                List<Door> doorsToControl = new List<Door>();

                if (cli.ArgumentCount == 0)
                {
                    Echo("No arguments passed. Controlling all doors.");
                    foreach (Door door in doors.Values)
                    {
                        if (!door.Locked())
                        {
                            continue;
                        }
                        doorsToControl.Add(door);
                    }
                }

                for (int i = 0; i < cli.ArgumentCount; i++)
                {
                    string key = "Door" + cli.Argument(i);
                    if (!doors.ContainsKey(key))
                    {
                        Echo($"Door with identifier {key} not found. Skipping.");
                        continue;
                    }
                    if (!doors[key].Locked())
                    {
                        Echo($"Door {key} already moving. Skipping.");
                        continue;
                    }
                    doorsToControl.Add(doors[key]);
                }

                if (doorsToControl.Count == 0)
                {
                    Echo("No doors found. Not creating new job.");
                }
                else
                {
                    Echo("Creating new job.");
                    if (cli.Switch("close")) jobs.Add(CloseDoors(doorsToControl));
                    else jobs.Add(OpenDoors(doorsToControl));
                    Runtime.UpdateFrequency = UpdateFrequency.Update1;
                }
            }

            // Process running jobs
            for (int i = 0; i < jobs.Count; i++)
            {
                if (!jobs[i].MoveNext())
                {
                    jobs[i].Dispose();
                    jobs.Remove(jobs[i]);
                    i--;
                    Echo("Operation Complete.");
                }
            }

            if (jobs.Count == 0)
            {
                Runtime.UpdateFrequency = UpdateFrequency.None;
            }
        }

        private IEnumerator<bool> OpenDoors(List<Door> doorsToControl)
        {
            Echo("Opening doors.");
            foreach (Door door in doorsToControl)
            {
                door.OpenDoor();
            }
            return ActuateDoors(doorsToControl);
        }

        private IEnumerator<bool> CloseDoors(List<Door> doorsToControl)
        {
            Echo("Closing doors.");
            foreach (Door door in doorsToControl)
            {
                door.CloseDoor();
            }
            return ActuateDoors(doorsToControl);
        }

        private IEnumerator<bool> ActuateDoors(List<Door> doorsToControl)
        {
            while (true)
            {
                Echo("Actuating doors.");
                bool done = true; // assume we've finished, then falsify it below
                foreach (Door door in doorsToControl)
                {
                    if (!door.Actuate())
                    {
                        done = false;
                    }
                }
                if (done) yield break;
                yield return true;
            }
        }
    }
}