public IEnumerator <bool> LaunchSequence()
{
foreach (var propellingRotor in propellingRotorArray)
{
propellingRotor.Displacement = 20;
}
yield return(true);
launchRotor.ApplyAction("Add Top Part");
foreach (var propellingRotor in propellingRotorArray)
{
propellingRotor.Displacement = -40;
}
yield return(true);
launchRotor.Detach();
yield return(true);
}
public AutoDoorProgram(IMyGridTerminalSystem grid, IMyProgrammableBlock me, Action <string> echo, TimeSpan elapsedTime)
{
GridTerminalSystem = grid;
Echo = echo;
ElapsedTime = elapsedTime;
Me = me;
doors = new List <IMyDoor>();
sensors = new List <IMySensorBlock>();
List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>();
grid.SearchBlocksOfName(PREFIX, blocks);
// Add some error handling for blocks not found
for (int i = 0; i < blocks.Count; i++)
{
IMyTerminalBlock block = blocks[i];
String blockType = block.DefinitionDisplayNameText;
String blockName = block.CustomName;
//Echo("Processing block " + blockName);
if (blockType.Equals("Sensor"))
{
IMySensorBlock sensor = block as IMySensorBlock;
sensor.ApplyAction("OnOff_On");
List <ITerminalProperty> properties = new List <ITerminalProperty>();
sensor.GetProperties(properties);
sensor.SetValueFloat("Back", SensorBack);
sensor.SetValueFloat("Bottom", SensorBottom);
sensor.SetValueFloat("Top", SensorTop);
sensor.SetValueFloat("Left", SensorLeft);
sensor.SetValueFloat("Right", SensorRight);
sensor.SetValueFloat("Front", SensorFront);
sensor.SetValueBool("Detect Asteroids", false);
sensor.SetValueBool("Detect Enemy", false);
sensor.SetValueBool("Detect Floating Objects", false);
sensor.SetValueBool("Detect Friendly", true);
sensor.SetValueBool("Detect Large Ships", false);
sensor.SetValueBool("Detect Neutral", false);
sensor.SetValueBool("Detect Owner", true);
sensor.SetValueBool("Detect Players", true);
sensor.SetValueBool("Detect Small Ships", false);
sensor.SetValueBool("Detect Stations", false);
sensor.SetValueBool("Audible Proximity Alert", false);
sensors.Add(sensor);
}
else if (blockType.Equals("Sliding Door") || blockType.Equals("Door"))
{
IMyDoor door = block as IMyDoor;
door.ApplyAction("Open_Off");
doors.Add(door);
}
else if (blockType.Equals("Rotor") || blockType.Equals("Advanced Rotor"))
{
rotor = block as IMyMotorStator;
rotor.ApplyAction("OnOff_On");
rotor.SetValueFloat("Torque", 3.36E+07f);
rotor.SetValueFloat("BrakingTorque", 3.36E+07f);
rotor.SetValueFloat("Velocity", rotorSpeed);
rotor.SetValueFloat("UpperLimit", float.PositiveInfinity);
rotor.SetValueFloat("LowerLimit", float.NegativeInfinity);
// Add config here
}
}
}
public AutoDoorProgram(IMyGridTerminalSystem grid, IMyProgrammableBlock me, Action<string> echo, TimeSpan elapsedTime)
{
GridTerminalSystem = grid;
Echo = echo;
ElapsedTime = elapsedTime;
Me = me;
doors = new List<IMyDoor>();
sensors = new List<IMySensorBlock>();
List<IMyTerminalBlock> blocks = new List<IMyTerminalBlock>();
grid.SearchBlocksOfName(PREFIX, blocks);
// Add some error handling for blocks not found
for (int i = 0; i < blocks.Count; i++)
{
IMyTerminalBlock block = blocks[i];
String blockType = block.DefinitionDisplayNameText;
String blockName = block.CustomName;
//Echo("Processing block " + blockName);
if (blockType.Equals("Sensor"))
{
IMySensorBlock sensor = block as IMySensorBlock;
sensor.ApplyAction("OnOff_On");
List<ITerminalProperty> properties = new List<ITerminalProperty>();
sensor.GetProperties(properties);
sensor.SetValueFloat("Back", SensorBack);
sensor.SetValueFloat("Bottom", SensorBottom);
sensor.SetValueFloat("Top", SensorTop);
sensor.SetValueFloat("Left", SensorLeft);
sensor.SetValueFloat("Right", SensorRight);
sensor.SetValueFloat("Front", SensorFront);
sensor.SetValueBool("Detect Asteroids", false);
sensor.SetValueBool("Detect Enemy", false);
sensor.SetValueBool("Detect Floating Objects", false);
sensor.SetValueBool("Detect Friendly", true);
sensor.SetValueBool("Detect Large Ships", false);
sensor.SetValueBool("Detect Neutral", false);
sensor.SetValueBool("Detect Owner", true);
sensor.SetValueBool("Detect Players", true);
sensor.SetValueBool("Detect Small Ships", false);
sensor.SetValueBool("Detect Stations", false);
sensor.SetValueBool("Audible Proximity Alert", false);
sensors.Add(sensor);
}
else if (blockType.Equals("Sliding Door") || blockType.Equals("Door"))
{
IMyDoor door = block as IMyDoor;
door.ApplyAction("Open_Off");
doors.Add(door);
}
else if (blockType.Equals("Rotor") || blockType.Equals("Advanced Rotor"))
{
rotor = block as IMyMotorStator;
rotor.ApplyAction("OnOff_On");
rotor.SetValueFloat("Torque", 3.36E+07f);
rotor.SetValueFloat("BrakingTorque", 3.36E+07f);
rotor.SetValueFloat("Velocity", rotorSpeed);
rotor.SetValueFloat("UpperLimit", float.PositiveInfinity);
rotor.SetValueFloat("LowerLimit", float.NegativeInfinity);
// Add config here
}
}
}
public SolarController()
{
// Get all solar panels
List <IMyTerminalBlock> panels = new List <IMyTerminalBlock>();
GridTerminalSystem.GetBlocksOfType <IMySolarPanel>(panels);
// Get current and total power output
int panelCnt = 0;
float curUse = 0f; // Amount of power currently being used
float genOut = 0f; // Power output potential
float lowestOut = 0f;
for (int i = 0; i < panels.Count; i++)
{
IMySolarPanel panel = panels[i] as IMySolarPanel;
if (panel != null && panel.IsFunctional)
{
panelCnt++;
float cur = panel.CurrentOutput;
float max = panel.MaxOutput;
curUse += cur;
genOut += max;
if (lowestOut == 0f || max < lowestOut)
{
lowestOut = max;
}
}
}
// Display status
pr(String.Format("Solar Panel Count: {0}", panelCnt));
pr(String.Format("Solar Power Usage: {0:0.0}/{1:0.0} MW", curUse, genOut));
// Nothing else to do if no panels
if (panelCnt == 0)
{
return;
}
// Rotor control
IMyMotorStator rotor = (IMyMotorStator)GridTerminalSystem.GetBlockWithName("Solar Panel Rotor");
float thresh = target * maxOut;
if (lowestOut < thresh)
{
float speed = ((thresh - lowestOut) / thresh) * 1.5f;
if (speed < 0.05f)
{
speed = 0.05f;
}
rotor.SetValue("Velocity", speed);
rotor.ApplyAction("OnOff_On");
pr(String.Format("Rotor Status: On ({0:0.00} rpm)", speed));
}
else
{
rotor.ApplyAction("OnOff_Off");
pr("Rotor Status: Off");
}
}
void Main()
{
IMyTextSurface screen = GridTerminalSystem.GetBlockWithName("LCD Solar Array") as IMyTextSurface;
IMyMotorStator rotorRight = GridTerminalSystem.GetBlockWithName("Rotor Solar Right") as IMyMotorStator;
IMyMotorStator rotorLeft = GridTerminalSystem.GetBlockWithName("Rotor Solar Left") as IMyMotorStator;
IMyBlockGroup solarArrayRightBlocks = GridTerminalSystem.GetBlockGroupWithName("Solar Array Right");
IMyBlockGroup solarArrayLeftBlocks = GridTerminalSystem.GetBlockGroupWithName("Solar Array Left");
if (solarArrayRightBlocks == null)
{
Echo("[Error] Right Solar Array Group Null");
}
if (solarArrayLeftBlocks == null)
{
Echo("[Error] Left Solar Array Group Null");
}
//IMyTextSurface surface = GridTerminalSystem.GetBlockWithName("LCD Panel") as IMyTextSurface;
IMyBatteryBlock battery = GridTerminalSystem.GetBlockWithName("Battery") as IMyBatteryBlock;
//float pwrNow;
//float pwrLast;
double rotorRightAngle = Math.Round((rotorRight.Angle * 180) / 3.14, 2); //1rad × 180/π = 57.296°
double rotorLeftAngle = Math.Round((rotorLeft.Angle * 180) / 3.14); //1rad × 180/π = 57.296°
List <IMySolarPanel> solarArrayRight = new List <IMySolarPanel>();
List <IMySolarPanel> solarArrayLeft = new List <IMySolarPanel>();
solarArrayRightBlocks.GetBlocksOfType <IMySolarPanel>(solarArrayRight);
solarArrayLeftBlocks.GetBlocksOfType <IMySolarPanel>(solarArrayLeft);
float solarRightInPower = (float)Math.Round(solarArrayRight[0].CurrentOutput * 1000, 2); //kW
float solarLeftInPower = (float)Math.Round(solarArrayLeft[0].CurrentOutput * 1000); //kW
float lastPowerReadingLeft = 0;
float lastPowerReadingRight = 0;
bool leftRotating = false;
bool rightRotating = true;
StringBuilder sb = new StringBuilder();
sb.AppendLine($"Total Power Generated: {GetTotalPower(solarArrayLeft, solarArrayRight)} kW");
//sb.AppendLine($"Right Array Solar Count: {solarArrayRight.Count}");
sb.AppendLine($"Left Array Solar Count: {solarArrayLeft.Count}");
//sb.AppendLine($"Right Panel Sample Charge: {Math.Round(solarRightInPower, 2)} kw");
sb.AppendLine($"Left Panel Sample Charge: {Math.Round(solarLeftInPower, 2)} kw");
sb.AppendLine($"Left Rotor Angle: {rotorLeftAngle}");
sb.AppendLine($"Left Rotor Angle Rounded: {Math.Round(rotorLeftAngle)}");
if (Storage == null)
{
sb.AppendLine("Storage Empty");
lastPowerReadingLeft = 0;
lastPowerReadingRight = 0;
}
else
{
string[] retrievedFromStorage = Storage.Split(',');
sb.AppendLine($"Length Of Storage: {retrievedFromStorage.Length}");
sb.AppendLine($"StorageLeft Reading: {retrievedFromStorage[0]} isRotatingLeft: {retrievedFromStorage[2]}");
if (retrievedFromStorage.Length < 4)
{
sb.AppendLine("Storage String Cannot be Parsed");
}
else
{
sb.AppendLine($"{retrievedFromStorage[0]} {retrievedFromStorage[1]} {retrievedFromStorage[2]} {retrievedFromStorage[3]}");
lastPowerReadingLeft = float.Parse(retrievedFromStorage[0]);
lastPowerReadingRight = float.Parse(retrievedFromStorage[1]);
leftRotating = bool.Parse(retrievedFromStorage[2]);
rightRotating = bool.Parse(retrievedFromStorage[3]);
}
}
//If no sun return to 0 degrees
if (solarLeftInPower == 0)
{
sb.AppendLine("Setting Left Array");
if (rotorLeftAngle == 45)
{
rotorLeft.TargetVelocityRPM = 0;
leftRotating = false;
}
else if (rotorLeftAngle > 180)
{
rotorLeft.TargetVelocityRPM = 1;
}
else
{
rotorLeft.TargetVelocityRPM = -1;
}
}
else if (solarLeftInPower < lastPowerReadingLeft)
{
sb.AppendLine($"LeftIn Power < lastPower Reading");
if (leftRotating)
{
rotorLeft.ApplyAction("Reverse");
}
else
{
rotorLeft.TargetVelocityRPM = -.25f;
}
}
else
{
sb.AppendLine($"LeftIn Power >= lastPower Reading");
sb.AppendLine("Stopped Left Array");
rotorLeft.TargetVelocityRPM = 0;
}
string storageString = $"{solarLeftInPower},{solarRightInPower},{leftRotating.ToString()},{rightRotating.ToString()}";
Storage = storageString;
screen.WriteText(sb.ToString());
}
public void Main(string argument, UpdateType updateSource)
{
if (refreshDisplay)
{
cursor[0] = 0;
cursor[1] = 0;
WriteNavigateDisplay(cursor);
refreshDisplay = false;
}
switch (argument)
{
case "extract":
{
RotorMain.UpperLimitDeg = float.MaxValue;
RotorMain.LowerLimitDeg = float.MinValue;
RotorMain.TargetVelocityRPM = 0;
RotorL.TargetVelocityRPM = 0;
RotorR.TargetVelocityRPM = 0;
AdRotL.TargetVelocityRPM = 0;
AdRotR.TargetVelocityRPM = 0;
if (action != Action.Automat2)
{
SetPiston(10);
}
action = Action.Extract;
WriteStatusDisplay();
break;
}
case "retrack":
{
RotorMain.UpperLimitDeg = float.MaxValue;
RotorMain.LowerLimitDeg = float.MinValue;
if (RotorMain.Angle * 57.2 > 340)
{
RotorMain.UpperLimitDeg = 0;
RotorMain.TargetVelocityRPM = 0.5f;
action = Action.Retrack1;
break;
}
if (RotorMain.Angle * 57.2 < 20)
{
RotorMain.LowerLimitDeg = 360;
RotorMain.TargetVelocityRPM = -0.5f;
action = Action.Retrack1;
break;
}
break;
}
case "automat":
{
if ((action == Action.Free) | (action == Action.Manual))
{
action = Action.Automat1;
}
else if (action == Action.Automat2)
{
action = Action.Free;
}
WriteStatusDisplay();
break;
}
case "on/off":
// Runtime.UpdateFrequency = (Runtime.UpdateFrequency == UpdateFrequency.Once) ? UpdateFrequency.Update10 : UpdateFrequency.Once;
break;
}
switch (action)
{
case Action.Free:
break;
case Action.Manual:
{
RotorMain.TargetVelocityRPM = (RemoteControl.RotationIndicator.Y) * sensivity;
if (RemoteControl.MoveIndicator.Y == -1)
{
RotorL.TargetVelocityRPM = 0;
RotorR.TargetVelocityRPM = 0;
AdRotL.TargetVelocityRPM = (RemoteControl.RotationIndicator.X) * sensivity;
AdRotR.TargetVelocityRPM = -(RemoteControl.RotationIndicator.X) * sensivity;
}
else
{
if (!isHoldHorizon)
{
RotorL.TargetVelocityRPM = (RemoteControl.RotationIndicator.X) * 0.1f;
RotorR.TargetVelocityRPM = -(RemoteControl.RotationIndicator.X) * 0.1f;
}
if (!isHoldFlat)
{
AdRotL.TargetVelocityRPM = 0;
AdRotR.TargetVelocityRPM = 0;
}
}
break;
}
case Action.Secure:
break;
case Action.Extract:
{
if (PistonsList[0].CurrentPosition == 10)
{
//RotorMain.LowerLimitDeg = float.MinValue;
//RotorMain.UpperLimitDeg = float.MaxValue;
RotorMain.RotorLock = false;
RotorL.RotorLock = false;
RotorR.RotorLock = false;
AdRotL.RotorLock = false;
AdRotR.RotorLock = false;
action = Action.Free;
WriteStatusDisplay();
}
break;
}
case Action.Retrack1:
{
isHoldFlat = false;
isHoldHorizon = false;
SetPiston(10);
AdRotL.TargetVelocityRPM = 2;
AdRotR.TargetVelocityRPM = -2;
RotorL.TargetVelocityRPM = -0.3f;
RotorR.TargetVelocityRPM = 0.3f;
action = Action.Retrack2;
WriteStatusDisplay();
refreshDisplay = true;
break;
}
case Action.Retrack2:
{
if ((RotorL.Angle * 57.2 < 0) && (AdRotL.Angle * 57.2 > -0.2f))
{
if ((RotorMain.Angle * 57.2 < 360) && (RotorMain.Angle * 57.2 > 0))
{
RotorL.TargetVelocityRPM = 0;
RotorR.TargetVelocityRPM = 0;
RotorMain.TargetVelocityRPM = 0;
RotorMain.RotorLock = true;
RotorL.RotorLock = true;
RotorR.RotorLock = true;
AdRotL.RotorLock = true;
AdRotR.RotorLock = true;
isHoldFlat = false;
RotorMain.LowerLimitDeg = float.MinValue;
RotorMain.UpperLimitDeg = float.MaxValue;
SetPiston(0);
action = Action.Retrack3;
}
}
break;
}
case Action.Retrack3:
{
if (PistonsList[0].CurrentPosition == 0)
{
action = Action.Secure;
WriteStatusDisplay();
}
break;
}
case Action.Automat1:
{
{
if ((RotorMain.Angle * 57.2f > zeroHeading + 180) | (RotorMain.Angle * 57.2f < zeroHeading))
{
RotorMain.TargetVelocityRPM = rotateSpeed;
}
else
{
RotorMain.TargetVelocityRPM = -rotateSpeed;
}
SetPiston(minDistance);
action = Action.Automat2;
}
break;
}
case Action.Automat2:
{
if (RotorMain.Angle * 57.2 > 180)
{
curHeading = RotorMain.Angle * 57.2f - 360;
}
else
{
curHeading = RotorMain.Angle * 57.2f;
}
if (((RotorMain.TargetVelocityRPM < 0) && (curHeading <= (zeroHeading - rotateAngle))) || ((RotorMain.TargetVelocityRPM > 0) && (curHeading >= (zeroHeading + rotateAngle))))
{
RotorMain.ApplyAction("Reverse");
SetPiston(PistonsList[0].CurrentPosition + pistonExtend * 0.1f);
rotateAngle -= pistonExtend * 0.25f;
if ((pistonExtend != 0) && (PistonsList[0].CurrentPosition == 10))
{
action = Action.Free;
RotorMain.TargetVelocityRPM = 0;
// MessageAllert("Program complete");
}
refreshDisplay = true;
}
break;
}
}
switch ((RemoteControl.RollIndicator).ToString())
{
case "0":
if (key1)
{
key1 = false;
}
break;
case "-1":
if (!key1)
{
isNavigate = !isNavigate;
if (isNavigate)
{
RemoteControl.ControlWheels = false;
}
else
{
RemoteControl.ControlWheels = true;
}
WriteStatusDisplay();
}
break;
case "1":
if (!key1)
{
if (action == Action.Free)
{
action = Action.Manual;
key1 = !key1;
}
else if (action == Action.Manual)
{
action = Action.Free;
key1 = !key1;
}
WriteStatusDisplay();
}
break;
} //Change control mode
if (isHoldHorizon)
{
Vector3D GravNorm = Vector3D.Normalize((Cockpit as IMyShipController).GetNaturalGravity());
float vecForward = (float)GravNorm.Dot((Cockpit as IMyShipController).WorldMatrix.Forward);
float vecUp = (float)GravNorm.Dot((Cockpit as IMyShipController).WorldMatrix.Up);
curElevation = -(float)Math.Atan2(vecForward, -vecUp) * 57.2f;
RotorL.TargetVelocityRPM = (sensivity / 2) * (curElevation - zeroElevation);
RotorR.TargetVelocityRPM = -RotorL.TargetVelocityRPM;
}
if (isHoldFlat)
{
Vector3D GravNorm = Vector3D.Normalize((Cockpit as IMyShipController).GetNaturalGravity());
float vecForward = (float)GravNorm.Dot((Cockpit as IMyShipController).WorldMatrix.Forward);
float vecUp = (float)GravNorm.Dot((Cockpit as IMyShipController).WorldMatrix.Up);
curElevation = -(float)Math.Atan2(vecForward, -vecUp) * 57.2f;
AdRotL.TargetVelocityRPM = 0.1f * (AdRotR.Angle * 57.2f + curElevation - zeroFlatAngle);
AdRotR.TargetVelocityRPM = -AdRotL.TargetVelocityRPM;
}
if (isNavigate)
{
switch ((RemoteControl.MoveIndicator.Z).ToString())
{
case "0":
if (key2)
{
key2 = false;
}
break;
case "-1": //w key pressed
if (!key2)
{
cursor[0]--;
key2 = true;
WriteNavigateDisplay(cursor);
}
break;
case "1": //s key pressed
if (!key2)
{
cursor[0]++;
key2 = true;
WriteNavigateDisplay(cursor);
}
break;
}
switch ((RemoteControl.MoveIndicator.X).ToString())
{
case "0":
if (key3)
{
key3 = false;
}
cursor[1] = 0;
break;
case "1": //D key pressed
if (!key3)
{
cursor[1] = 2;
if (Runtime.UpdateFrequency == UpdateFrequency.Update1)
{
key3 = true;
}
WriteNavigateDisplay(cursor);
}
break;
case "-1": //A key pressed
if (!key3)
{
cursor[1] = 1;
if (Runtime.UpdateFrequency == UpdateFrequency.Update1)
{
key3 = true;
}
WriteNavigateDisplay(cursor);
}
break;
}
}
//--------DEBUG---------
Cockpit.GetSurface(0).WriteText(cursor[0].ToString() + cursor[1].ToString(), false);
Cockpit.GetSurface(0).WriteText("\nflat: " + isHoldFlat.ToString(), true);
Cockpit.GetSurface(0).WriteText("\nCurrentHead: " + curHeading, true);
Cockpit.GetSurface(0).WriteText("\nMain Rotor Angle: " + (RotorMain.Angle * 57.2).ToString(), true);
Cockpit.GetSurface(0).WriteText("\nAdRotorAngle: " + (AdRotR.Angle * 57.2).ToString(), true);
Cockpit.GetSurface(0).WriteText("\n" + action.ToString(), true);
}
