public bool TryParse(string line) { bool success = myCommandLine.TryParse(line); if (success) { Subsystem = myCommandLine.Argument(0); int index = line.IndexOf(Subsystem); line = line.Remove(index, Subsystem.Length); success = myCommandLine.TryParse(line); } return(success); }
private void RunCommand(string argument) { if (argument != null) { commandLine.TryParse(argument); var command = commandLine.Argument(0); if (command != null) { } else { Init(); Search(); } string current_group = ""; if (commandLine.ArgumentCount > 1) { current_group = commandLine.Argument(1); } if (Airlocks != null) { Airlocks.ForEach(delegate(Airlock airlock) { if (current_group.Equals("") || airlock.GroupFilter.Contains(current_group)) { airlock.RunCommand(argument); } }); } } }
private bool ParseArgs(string args) { CommandLine.TryParse(args); if (CommandLine.Argument(0) == null) { return(true); } bool valid = false; bool result = true; if (Commands.Keys.Any(x => x == CommandLine.Argument(0))) { if (Commands[CommandLine.Argument(0)].MinumumArguments < CommandLine.ArgumentCount) { result = Commands[CommandLine.Argument(0)].Action(CommandLine); valid = true; } } SaveEvent("Command:" + (valid?"":"invalid:") + "\"" + args + "\""); return(result); }
public void Main(string argument, UpdateType source) { if (m_instance == null && !Init()) { return; } if ((source & (UpdateType.Mod | UpdateType.Script | UpdateType.Terminal | UpdateType.Trigger)) != 0) { if (m_command.TryParse(argument)) { m_instance.onCommand(m_command); } else { Echo("Rescanning"); m_instance.ScanBlocks(GridTerminalSystem); // with on args, rescan blocks } } if ((source & (UpdateType.IGC)) != 0) { m_instance.onIGCMessage(); } if ((source & (UpdateType.Update1 | UpdateType.Update10 | UpdateType.Update100)) != 0) { m_instance.onTick(source); } }
public void Main(string argument, UpdateType updateSource) { if (commandLine.TryParse(argument)) { Action commandAction; string command = commandLine.Argument(0); if (command == null) { Echo("No command specified"); } else if (commands.TryGetValue(command, out commandAction)) { // We have found a command. Invoke it. commandAction(); } else { echoBuilder.AppendLine($"Unknown command {command}"); } } else { echoBuilder.Clear(); echoBuilder.Append(setupBuilder.ToString()); Action updateAction; if (updates.TryGetValue(currentState, out updateAction)) { updateAction(); } doDisplay(); } }
private void ProcessCommand(string command) { if (Cmd.TryParse(command) && Cmd.ArgumentCount > 0) { switch (Cmd.Argument(0)) { case "id": Message($"Drone computer IGC ID: 0x{IGC.Me:X}"); break; case "start": Start(Cmd.Argument(1)); break; case "capture": CaptureScanned(); break; case "grind": Grind(); break; case "halt": Halt("Warning: drone halted."); break; case "reload": Reload(); break; case "recall": Recall(); break; case "process_message": ProcessUnicast(); break; default: Start(command); break; } } }
public void Main(string argument, UpdateType updateSource) { if (_commandLine.TryParse(argument)) { string command = _commandLine.Argument(0); if (command == null) { Echo("No command specified"); } else if (!command.Equals("land") && !command.Equals("scan")) { Echo("Wrong command issued, should be 'scan' or 'land'"); } else if (command.Equals("scan")) { ExecuteScan(); } else if (command.Equals("land")) { ExecuteLanding(); } } Echo("Status: " + Status); Scan(); Land(); }
public void Main(string argument, UpdateType updateSource) { if ((updateSource & ~(UpdateType.Update1 | UpdateType.Update10 | UpdateType.Update100)) != 0) { if (Cmd.TryParse(argument)) { switch (Cmd.Argument(0)) { case "fly": FlyForward(); break; case "dock": PerformDocking(); break; case "scan": QuickScan(); break; case "halt": QuickHalt(); break; default: Log($"Unknown command: {Cmd.Argument(0)}"); break; } } } if ((updateSource & (UpdateType.Update1 | UpdateType.Update10 | UpdateType.Update100)) != 0) { if (Pilot.Tasks.Count > 0) { Pilot.Update(Runtime.TimeSinceLastRun.TotalSeconds); } if (Cockpit.IsUnderControl) { UpdateShipInfo(); UpdateStorageInfo(); } } }
public void Main(string argument, UpdateType updateSource) { // MDK command parsing if (_commandLine.TryParse(argument)) { Action commandAction; // Retrieve the first argument. Switches are ignored. string command = _commandLine.Argument(0); // Now we must validate that the first argument is actually specified, // then attempt to find the matching command delegate. if (command == null) { Echo("No command specified"); } else if (_commands.TryGetValue(_commandLine.Argument(0), out commandAction)) { // We have found a command. Invoke it. commandAction(); } else { Echo($"Unknown command {command}"); } } }
public void Main(string arg, UpdateType updateSource) { if (_commandLine.TryParse(arg)) { Action commandAction; string command = _commandLine.Argument(0); if (_commands.TryGetValue(_commandLine.Argument(0), out commandAction)) { commandAction(); message = command + "\n" + message; } else { message = $"Unknown command {command}"; } } message = "Drill Deployed:\n" + status["deployed"]; CheckDeploy(); Echo(message); Echo("\nExecution Time: " + Runtime.LastRunTimeMs.ToString() + "ms"); Me.GetSurface(0).WriteText(message); }
void MessageEntered(string msg, ref bool send) { try { if (!msg.StartsWith(MAIN_COMMAND)) { return; } if (!argParser.TryParse(msg)) { Utils.ShowColoredChatMessage(PaintGunMod.MOD_NAME, $"Couldn't parse command \"{msg}\" for some reason, please report!", MyFontEnum.Red); Log.Error($"Couldn't parse command for some reason. Text entered: \"{msg}\""); return; } send = false; string alias = argParser.Argument(1) ?? string.Empty; CommandHandlerBase handler; if (AliasToCommandHandler.TryGetValue(alias, out handler)) { handler.Execute(argParser); } else { Utils.ShowColoredChatMessage(PaintGunMod.MOD_NAME, $"Unknown command: {MAIN_COMMAND} {alias}", MyFontEnum.Red); } } catch (Exception e) { Log.Error(e); } }
/* * * * * * * * * * * Main & Commands * * * * * * * * * * */ public void Main(string argument, UpdateType updateSource) { //shit run every tick if ((updateSource & UpdateType.Update1) != 0) { //if we use the elevator if (useElevator && stations != null && stations.Count != 0) { for (int i = 0; i < stations.Count; i++) { if (stations[i].Update()) { broadcasts.Enqueue("request " + stations[i].name); } } } } //shit with arguments if ((updateSource & (UpdateType.Antenna | UpdateType.Trigger | UpdateType.Terminal)) != 0) { //if arguments are actually given if (cline.TryParse(argument)) { Action cAction; String command = cline.Argument(0); if (command == null) { writeLog("No Command was given!"); } else if (commands.TryGetValue(command, out cAction)) { cAction(); } else { writeLog("Unknown Command: " + command); } } } //at the end of every run we transmit one of the queued messages if (antenna != null && broadcasts.Count > 0) { if (sendable) { antenna.TransmitMessage(broadcasts.Dequeue()); sendable = false; } else { sendable = true; } } }
async void ServerFunction() { while (true) { using (var stream = new NamedPipeServerStream(_pipeName, PipeDirection.InOut, 4, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) { stream.ReadTimeout = 500; stream.WriteTimeout = 500; var message = new MyCommandLine(); await stream.WaitForConnectionAsync(_cancellation.Token); if (_cancellation.IsCancellationRequested) { return; } var writer = new StreamWriter(stream); var reader = new StreamReader(stream); writer.WriteLine($"ID \"{_identity}\""); var messageSrc = reader.ReadLine(); if (string.IsNullOrWhiteSpace(messageSrc) || !message.TryParse(messageSrc)) { writer.WriteLine("400"); continue; } var completion = new TaskCompletionSource <string>(); _synchronizationContext.Post(OnRequest, new Request(message, completion)); try { var response = completion.Task.Result; if (response == null) { writer.WriteLine("400"); } else { writer.WriteLine($"200 {response}"); } } catch (Exception exception) { void logError(object state) { MyLog.Default.WriteLine("MDKListenerPlugin Error"); MyLog.Default.WriteLine((Exception)state); } _synchronizationContext.Post(logError, exception); writer.WriteLine("500"); } } } }
public void Main(string argument, UpdateType updateSource) { Echo(updateSource.Equals(UpdateFrequency.Update10) ? "Stopped" : "Running"); if (_commandLine.TryParse(argument).Equals("stop")) { Runtime.UpdateFrequency = UpdateFrequency.None; } if (_commandLine.TryParse(argument).Equals("fix")) { Me.CustomData = "Battery.Empty"; } LoadData(); if ((updateSource & UpdateType.Update10) != 0 && !_commandLine.TryParse(argument).Equals("stop")) { StartStopHydrogenEngine(); } }
public void Main(string argument, UpdateType updateSource) { subsystemManager.UpdateTime(); if (commandLine.TryParse(argument)) { subsystemManager.Command(commandLine.Argument(0), commandLine.Argument(1), commandLine.ArgumentCount > 2 ? commandLine.Argument(2) : null); } else { subsystemManager.Update(updateSource); Echo(subsystemManager.GetStatus()); } }
public void Main(string argument, UpdateType updateSource) { if (commandLine.TryParse(argument)) { Action action; string command = commandLine.Argument(0); if (command == null) { Echo("No command specified"); } else if (commands.TryGetValue(command, out action)) { action(); } } string[] entries = Storage.Split(';'); if (entries.Length == 5) { bool.TryParse(entries[0], out enableAltitude); bool.TryParse(entries[1], out enableProximity); bool.TryParse(entries[2], out firstRun); Enum.TryParse(entries[3], out gearState); double.TryParse(entries[4], out previousAltitude); } Echo("Altitude: " + enableAltitude.ToString()); Echo("Proximity: " + enableProximity.ToString()); if (enableProximity) { SetUpProximity(); } if (enableAltitude) { SetUpAltitude(); } if (firstRun) { //Calibrate gearState in case gear has never been deployed before List <IMyLandingGear> landingGear = new List <IMyLandingGear>(); GridTerminalSystem.GetBlocksOfType(landingGear); CalibrateGearState(landingGear); firstRun = false; } }
/// <summary>Executes a command as if it was entered by user.</summary> public void ExecuteCommand(string command) { Log($">{command}"); Action <MyCommandLine> handler; if (CmdLine.TryParse(command) && Commands.TryGetValue(CmdLine.Items[0], out handler)) { handler?.Invoke(CmdLine); } else { Log($"Invalid command"); } }
public void Main(string argument, UpdateType updateSource) { echoBuilder.Clear(); if (!isSetup) { SetUp(); } echoBuilder.Append(setupBuilder.ToString()); echoBuilder.AppendLine($"Current state >> {currentState.ToString()}"); GetBlocks(); if (commandLine.TryParse(argument)) { Action commandAction; // Retrieve the first argument. Switches are ignored. string command = commandLine.Argument(0); // Now we must validate that the first argument is actually specified, // then attempt to find the matching command delegate. if (command == null) { Echo("No command specified"); } else if (commands.TryGetValue(command, out commandAction)) { // We have found a command. Invoke it. commandAction(); } else { echoBuilder.AppendLine($"Unknown command {command}"); } } else { Action updateAction; if (updates.TryGetValue(currentState, out updateAction)) { updateAction(); } } doDisplay(); }
private void RunCommand(string argument) { if (argument != null) { commandLine.TryParse(argument); var command = commandLine.Argument(0); switch (command) { case "reset": Prepare(); break; } } }
public void ParseCommand(string argument) { if (_commandLine.TryParse(argument)) { switch (_commandLine.Argument(0)) { case Constants.C_ASSIGN: myProgram.platformController.AddCommandToStack(_commandLine); break; default: myProgram.Echo($"No valid command specified: {_commandLine.Argument(0)}"); break; } } }
private void RunCommand(string argument) { MyProperty.Load(); if (argument != null) { commandLine.TryParse(argument); var command = commandLine.Argument(0); switch (command) { default: machine_state = StateMachine.TrakingLat; last_power = 0f; break; } } }
public static T Deserialise <T>(this IConfigurationReader <T> reader, T defaultConfiguration, string serialised) where T : new() { var commandLine = new MyCommandLine(); if (String.IsNullOrWhiteSpace(serialised) || !commandLine.TryParse(serialised)) { Debug.Write(Debug.Level.Info, "No stored configuration."); return(defaultConfiguration); } var configuration = new T(); if (!reader.Read(configuration, commandLine.Items)) { Debug.Write(Debug.Level.Error, "Unable to read the stored configuration. Resetting to defaults."); return(defaultConfiguration); } return(configuration); }
private void ProcessCommand(string argument) { if (CommandLine.TryParse(argument)) { switch (CommandLine.Argument(0).ToLower()) { case "initialize": case "init": Output.AppendLine("Reinitializing"); Initialize(); break; default: ProcessAirlockCommand(); break; } } }
public void Main(string argument, UpdateType updateSource) { Echo($"Time since last execute: {Runtime.TimeSinceLastRun}"); previousState = currentState; if (_commandLine.TryParse(argument)) { var newTargetState = _commandLine.Argument(0); if (String.Equals(newTargetState, "park", StringComparison.OrdinalIgnoreCase)) { targetState = MiningArmTargetState.PARK; } else if (String.Equals(newTargetState, "deploy", StringComparison.OrdinalIgnoreCase)) { targetState = MiningArmTargetState.DEPLOYED; foreach (var hinge in miningArmBlocks.hinges) { hinge.TargetVelocityRPM = -1 * hinge.TargetVelocityRPM; } } else if (String.Equals(newTargetState, "drill", StringComparison.OrdinalIgnoreCase)) { targetState = MiningArmTargetState.DRILLING; } else { Echo("Unknown Command: " + newTargetState); } } currentState = DetectCurrentState(); Echo("TagetState: " + targetState); Echo("CurrentState: " + currentState); Echo("drillRotorOrientation: " + miningArmBlocks.drillRotor.Orientation); Echo("ArmGridPosition: " + miningArmBlocks.referenceHinge.TopGrid.GetPosition().ToString()); Echo("Hinge Angle: " + miningArmBlocks.referenceHinge.Angle); Echo(""); Echo("Executed instructions: " + Runtime.CurrentInstructionCount + "/" + Runtime.MaxInstructionCount); }
void CommandParser(string argument) { if (argument != null) { commandLine.TryParse(argument); var command = commandLine.Argument(0); switch (command) { case "reset": lcd_ore.Search("ORE"); controller_refinery.Search(); controller_cargo_ore.Search(); controller_cargo_ingot.Search(); controller_refinery.RefineryInit(); RefineryOreCleanup(); RefineryIngotCleanup(); DisplayOre(); break; case "test": Echo("Test"); Lcd lcd_test = new Lcd(this); lcd_test.Search("Test"); if (lcd_test.IsEmpty) { Echo("Not found lcd Test"); } else { Echo("Found lcd Test"); lcd_test.GetDrawing().Test(); lcd_test.GetDrawing().Dispose(); } break; default: //Echo("Command:"); //Echo(" reset"); break; } } }
private void RunCommand(string argument) { if (argument != null) { commandLine.TryParse(argument); var command = commandLine.Argument(0); switch (command) { case "reset": Init(); break; default: Search(); break; } } }
public void Main(string argument, UpdateType updateSource) { debug = SleepMode() ? "sleeping\n" : "working\n"; if (solarMoving) { debug += solarRaising ? "solar raising\n" : "solar lowering\n"; } if (drillMoving) { debug += drillRaising ? "drill raising\n" : "drill lowering\n"; } LCD.GetSurface(0).WriteText(debug); if (_commandLine.TryParse(argument)) { Action commandAction; string command = _commandLine.Argument(0); if (_commands.TryGetValue(_commandLine.Argument(0), out commandAction)) { commandAction(); } else { Echo($"Unknown command {command}"); } } if (SleepMode()) { return; } if (solarMoving) { SolarToggle(); } else if (drillMoving) { DrillArmToggle(); } }
private void RunCommand(string argument) { Init(); if (argument != null) { commandLine.TryParse(argument); var command = commandLine.Argument(0); if (command != null) { command = command.Trim().ToLower(); } switch (command) { default: search = true; Search(); break; } } }
private void RunCommand(string argument) { Init(); if (argument != null) { commandLine.TryParse(argument); var command = commandLine.Argument(0); string tag = commandLine.Argument(1); switch (command) { case "prefix": RenamePrefix(tag); break; case "unprefix": UnRenamePrefix(tag); break; } } }
public void Main(string argument, UpdateType updateSource) { Clock.AddTime(Runtime.TimeSinceLastRun); if (current == null) { Debug.ClearBuffer(); } else { Debug.RestoreBuffer(); } if (commandLine.TryParse(argument)) { var command = commandLine.Argument(0); switch (command?.ToLower()) { case "configure": configuration = new ConfigurationReader().UpdateFromCommandLine(configuration, commandLine.Items.Skip(1)); instance = null; break; case "reset": configuration = new RequestedConfiguration(); instance = null; break; case "rescan": Rescan(); break; } } EnsureInitialised(); if ((updateSource & (UpdateType.Update1 | UpdateType.Update10 | UpdateType.Update100)) != 0) { HandlePeriodicUpdate(); } }