private void ExecuteCommands(char[] commandsArray)
{
for (int i = 0; i < commandsArray.Length; i++)
{
if (!char.IsWhiteSpace(commandsArray[i]))
{
CommandEnum command = commandsArray[i].GetEnumFromCharValue <CommandEnum>();
switch (command)
{
case CommandEnum.SpinLeft:
SpinLeft();
break;
case CommandEnum.SpinRight:
SpinRight();
break;
case CommandEnum.MoveForward:
MoveForward();
break;
default:
throw new ArgumentException();
}
}
}
}
private unsafe ushort _createAndSendControlPayload(
CommandEnum command,
ReadOnlySpan <ushort> arguments = new ReadOnlySpan <ushort>()
)
{
Debug.Assert(Connected);
var id = _nextId++;
// the extra is for an id
var payloadSize = sizeof(CommandEnum) / 2 + arguments.Length + 1;
var payload = stackalloc ushort[payloadSize];
payload[0] = (ushort)command;
payload[1] = id;
for (var i = 0; i < arguments.Length; i++)
{
payload[i + 2] = arguments[i];
}
var payloadSpan = new ReadOnlySpan <byte>(payload, payloadSize * 2);
_control.Send(payloadSpan);
return(id);
}
protected void FireOnNewStateRequested(CommandEnum command)
{
if (OnNewStateRequested != null)
{
OnNewStateRequested(command);
}
}
public string getWay(CommandEnum commandEnum, string[] args, bool isHash)
{
string outputstring = "";
switch ((int)commandEnum)
{
case 1:
{
AsistMail mService = new AsistMail();
outputstring = mService.execute(args, isHash);
};
break;
case 2:
{ GetMail mail = new GetMail();
outputstring = mail.execute(args, isHash); };
break;
case 3:
{
SearchMail searchMail = new SearchMail();
outputstring = searchMail.execute(args, isHash);
};
break;;
case 4:
{
SearchMail searchMail = new SearchMail();
outputstring = searchMail.execute(args, isHash);
};
break;
}
return(outputstring);
}
public bool TryToSendNewOffsets(out CommandEnum command)
{
Dashboard.Sgt.LogAsync($"I will send new offsets to the server.");
try
{
var rand = new Random((int)DateTime.Now.Millisecond);
_fakeCoffeMachine.Signals.CoffeeMin = (float)rand.NextDouble();
_fakeCoffeMachine.Signals.CoffeeMax = (float)rand.NextDouble() + 4;
_fakeCoffeMachine.Signals.SugarMin = (float)rand.NextDouble();
_fakeCoffeMachine.Signals.SugarMax = (float)rand.NextDouble() + 4;
_fakeCoffeMachine.Signals.WaterMin = (float)rand.NextDouble();
_fakeCoffeMachine.Signals.WaterMax = (float)rand.NextDouble() + 4;
var request = _ardRequestFac.Offsets();
RegistrationResponse response;
var ack = Send(request, out response, _serverApiUrl + REGISTRATION_ROUTE);
command = ack ? response.c : CommandEnum.Undef;
if (ack)
{
Dashboard.Sgt.LogAsync($"Offsets have been reset on the server.");
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
command = CommandEnum.Undef;
return(false);
}
}
/// <summary>Get the data size associated with a command.</summary>
/// <param name="command">Command</param>
/// <returns>int</returns>
public static int GetCommandDataSize(CommandEnum command)
{
FieldInfo fi = typeof(CommandEnum).GetRuntimeField(command.ToString());
Attribute attr = fi.GetCustomAttribute(typeof(CommandDataSize));
return(((CommandDataSize)attr).DataSize);
}
public static void AddCommand(string commandName, CommandEnum @enum, ICommand command)
{
mtx.WaitOne();
stringToCommand.Add(commandName, @enum);
enumToCommand.Add(@enum, command);
mtx.ReleaseMutex();
}
/// <summary>
/// parsing from CommunicationProtocol to ServiceInfoEventArgs.
/// </summary>
public static ServiceInfoEventArgs Parse(CommunicationProtocol e)
{
CommandEnum ce = (CommandEnum)e.Command_Id;
string[] args = e.Command_Args;
if (args == null)
{
return(null);
}
ServiceInfoEventArgs siea = new ServiceInfoEventArgs();
if (ce == CommandEnum.GetConfigCommand)
{
ClientServerArgsParser.GetConfigCommand(siea, args);
}
else if (ce == CommandEnum.CloseHandlerCommand)
{
ClientServerArgsParser.CloseHandlerCommand(siea, args);
}
else if (ce == CommandEnum.GetLogCommand)
{
ClientServerArgsParser.GetLogCommand(siea, args);
}
return(siea);
}
/// <summary>
/// Messages from server.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="CommandEventArgs" /> instance containing the event data.</param>
public void MessageFromServer(object sender, CommandEventArgs args)
{
CommandEnum commandID = args.CommandID;
if (commandID == CommandEnum.GetAllLogsCommand)
{
GUIClient client = (GUIClient)sender;
string message = args.CommandArgs[0];
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject <List <MessageRecievedEventArgs> >(message);
List <MessageRecievedEventArgs> logs = (List <MessageRecievedEventArgs>)obj;
logs.Reverse();
foreach (MessageRecievedEventArgs log in (List <MessageRecievedEventArgs>)obj)
{
ReceivedLog?.Invoke(this, log);
}
//for (int i = logs.Count - 1; i >= 0; i++) { ReceivedLog?.Invoke(this, logs[i]); }
}
else if (commandID == CommandEnum.LogCommand)
{
GUIClient client = (GUIClient)sender;
string message = args.CommandArgs[0];
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject <MessageRecievedEventArgs>(args.CommandArgs[0]);
//string log = message.Substring(1);
// string log = message;
// MessageRecievedEventArgs logInfo = ParseLogFromString(log);
MessageRecievedEventArgs logInfo = (MessageRecievedEventArgs)obj;
ReceivedLog?.Invoke(this, logInfo);
}
}
public ResultEnum hleUtilsBufferCopyWithRange(byte* Out, int outsize, byte* In, int insize, CommandEnum Command, bool do_check = true)
{
switch (Command)
{
case CommandEnum.PSP_KIRK_CMD_DECRYPT_PRIVATE: return (ResultEnum)kirk_CMD1(Out, In, insize, do_check);
case CommandEnum.PSP_KIRK_CMD_ENCRYPT: return (ResultEnum)kirk_CMD4(Out, In, insize);
case CommandEnum.PSP_KIRK_CMD_ENCRYPT_FUSE:
throw(new NotImplementedException());
//return kirk_CMD5(Out, In, insize);
case CommandEnum.PSP_KIRK_CMD_DECRYPT: return (ResultEnum)kirk_CMD7(Out, In, insize);
case CommandEnum.PSP_KIRK_CMD_DECRYPT_FUSE:
throw(new NotImplementedException());
//return executeKIRKCmd8(Out, In, insize);
case CommandEnum.PSP_KIRK_CMD_PRIV_SIG_CHECK: return (ResultEnum)kirk_CMD10(In, insize);
case CommandEnum.PSP_KIRK_CMD_SHA1_HASH: return (ResultEnum)kirk_CMD11(Out, In, insize);
case CommandEnum.PSP_KIRK_CMD_ECDSA_GEN_KEYS:
throw(new NotImplementedException());
//return executeKIRKCmd12(Out, outsize);
case CommandEnum.PSP_KIRK_CMD_ECDSA_MULTIPLY_POINT:
throw (new NotImplementedException());
//return executeKIRKCmd13(Out, outsize, In, insize);
case CommandEnum.PSP_KIRK_CMD_PRNG: return (ResultEnum)kirk_CMD14(Out, insize);
case CommandEnum.PSP_KIRK_CMD_ECDSA_SIGN:
throw(new NotImplementedException());
//return executeKIRKCmd16(Out, outsize, In, insize);
case CommandEnum.PSP_KIRK_CMD_ECDSA_VERIFY:
throw(new NotImplementedException());
//return executeKIRKCmd17(In, insize);
default:
return ResultEnum.PSP_KIRK_INVALID_OPERATION; // Dummy.
}
}
public void WriteEnums(List <CommandEnum> enums, List <string> enumValues)
{
this.WriteUVarInt((uint)enums.Count);
for (int i = 0; i < enums.Count; ++i)
{
CommandEnum enumData = enums[i];
int count = enumData.Values.Length;
string name = enumData.Name;
if (string.IsNullOrEmpty(name))
{
continue;
}
this.WriteString(name);
this.WriteUVarInt((uint)count);
for (int j = 0; j < count; ++j)
{
if (enumValues.Count < 0x100)
{
this.WriteByte((byte)enumValues.IndexOf(enumData.Values[j]));
}
else if (enumValues.Count < 0x10000)
{
this.WriteLShort((ushort)enumValues.IndexOf(enumData.Values[j]));
}
else
{
this.WriteLInt((uint)enumValues.IndexOf(enumData.Values[j]));
}
}
}
}
/**public bool ConnectToServer()
* {
* IPEndPoint ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8000);
* client = new TcpClient();
* try
* {
* client.Connect(ep);
* isConnected = true;
* Console.WriteLine("You are connected");
* return true;
* }
* catch
* {
* Console.WriteLine("Unable to connect to server. Please check your connection.");
* isConnected = false;
* return false;
* }
* }*/
/// <summary>
/// Sends the message to server.
/// </summary>
/// <param name="commandID">The command identifier.</param>
/// <param name="args">The arguments.</param>
public void SendMessageToServer(CommandEnum commandID, string[] args)
{
Task.Run(() => clientChannel.SendMessageToServer(new CommandEventArgs()
{
CommandID = commandID, CommandArgs = args
}));
}
/// <summary>
/// Ejecuta un comando en la consola de Windows
/// </summary>
/// <param name="arguments"></param>
public void Exec(string arguments, CommandEnum type)
{
string output = string.Empty;
ProcessStartInfo processStartInfo = new ProcessStartInfo();
switch (type)
{
case CommandEnum.Adb:
processStartInfo.FileName = $@"{NoxPath}";
break;
case CommandEnum.Ocr:
processStartInfo.FileName = $@"{OcrPath}";
break;
default:
break;
}
processStartInfo.WorkingDirectory = $@"{Directory.GetCurrentDirectory()}";
processStartInfo.Arguments = $@"{arguments}";
processStartInfo.CreateNoWindow = true;
processStartInfo.WindowStyle = ProcessWindowStyle.Hidden;
processStartInfo.UseShellExecute = true;
process = Process.Start(processStartInfo);
process.Dispose();
}
/// <summary>
/// Initializes a new instance of the <see cref="ImageController"/> class.
/// </summary>
/// <param name="modal">The modal.</param>
public ImageController(IImageServiceModal modal, ILoggingService loggingService)
{
m_modal = modal; // Storing the Modal Of The System
CommandEnum y = CommandEnum.NewFileCommand;
CommandEnum g = CommandEnum.GetConfigCommand;
CommandEnum l = CommandEnum.LogCommand;
//CommandEnum a = CommandEnum.AddLog;
CommandEnum c = CommandEnum.CloseCommand;
CommandEnum d = CommandEnum.DeleteFileCommand;
// CommandEnum cc = CommandEnum.CloseClient;
commands = new Dictionary <int, ICommand>()
{
// For Now will contain NEW_FILE_COMMAND
{ (int)y, new NewFileCommand(m_modal) },
{ (int)g, new GetConfigCommand() },
{ (int)l, new LogCommand(loggingService) },
//{ (int)a, new AddLog(m_modal)},
{ (int)c, new CloseCommand(m_modal) },
{ (int)d, new DeleteFileCommand(m_modal) },
// { (int)ch, new CloseHandlerCommand(imageServer)}
// { (int)cc, new CloseClient()}
};
}
public ICommand CreateInstance(string value)
{
string[] words = value.Split(' ');
CommandEnum commandEnum = CommandEnum.none;
Enum.TryParse(words[0], true, out commandEnum);
switch (commandEnum)
{
case CommandEnum.move:
return(CreateMoveCommandInstance(words));
case CommandEnum.set:
return(CreateSetCommandInstance(words));
case CommandEnum.turnend:
return(CreateTurnEndCommandInstance(words));
case CommandEnum.extend:
return(CreateExtendCommandInstance(words));
case CommandEnum.undo:
return(CreateUndoCommandInstance(words));
case CommandEnum.quit:
return(CreateQuitCommandInstance(words));
default:
return(null);
}
}
private CommandDefinition.CommandFormat ReplyCreate(CommandEnum command, BooleanValue isAck, ActionEnum action, byte subAction, byte[] data)
{
CommandDefinition.CommandAckStruct /*can't name it command*/ cmd = new CommandDefinition.CommandAckStruct(command, BooleanValue.False, isAck);
CommandDefinition.ActionStruct /*can't name it action*/ act = new CommandDefinition.ActionStruct(ActionEnum.Response, subAction);
CommandDefinition.CommandFormat packet = new CommandDefinition.CommandFormat(cmd, act, data);
return packet;
}
public string ExecuteCommand(CommandEnum commandID, string[] args, out bool resultSuccesful)
{
ICommand value;
Commands.TryGetValue(commandID, out value);
return(value.Execute(args, out resultSuccesful));
}
public RegistrationResponse RegistrationOK(CommandEnum command = CommandEnum.Void)
=> new RegistrationResponse()
{
c = command,
e = ErrorEnum.Void,
rc = ResponseCodeEnum.OK
};
public void MessageFromServer(object sender, CommandEventArgs args)
{
CommandEnum commandID = args.CommandID;
if (commandID == CommandEnum.GetAllLogsCommand)
{
Client client = (Client)sender;
string message = args.CommandArgs[0];
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject <List <MessageRecievedEventArgs> >(message);
List <MessageRecievedEventArgs> logs = (List <MessageRecievedEventArgs>)obj;
logs.Reverse();
foreach (MessageRecievedEventArgs log in (List <MessageRecievedEventArgs>)obj)
{
ReceivedLog?.Invoke(this, log);
}
}
else if (commandID == CommandEnum.LogCommand)
{
Client client = (Client)sender;
string message = args.CommandArgs[0];
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject <MessageRecievedEventArgs>(args.CommandArgs[0]);
MessageRecievedEventArgs SpecificLogView = (MessageRecievedEventArgs)obj;
ReceivedLog?.Invoke(this, SpecificLogView);
}
}
private CommandDefinition.CommandFormat ReplyCreate(CommandEnum command, BooleanValue isAck, ActionEnum action, byte subAction, byte[] data)
{
CommandDefinition.CommandAckStruct /*can't name it command*/ cmd = new CommandDefinition.CommandAckStruct(command, BooleanValue.False, isAck);
CommandDefinition.ActionStruct /*can't name it action*/ act = new CommandDefinition.ActionStruct(ActionEnum.Response, subAction);
CommandDefinition.CommandFormat packet = new CommandDefinition.CommandFormat(cmd, act, data);
return(packet);
}
public void Dispose(bool Dispose)
{
if (!Disposed)
{
if (Dispose)
{
if (Token != null)
{
Token = null;
}
if (Header != null)
{
Header = null;
}
if (Command != 0)
{
Command = 0;
}
if (Response != 0)
{
Response = 0;
}
if (!string.IsNullOrEmpty(Username))
{
Username = null;
}
if (!string.IsNullOrEmpty(Argument))
{
Argument = null;
}
}
Disposed = true;
}
}
/// <summary>
/// Messages from server.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="CommandEventArgs"/> instance containing the event data.</param>
public void MessageFromServer(object sender, CommandEventArgs args)
{
CommandEnum commandID = args.CommandID;
if (commandID == CommandEnum.GetAllLogsCommand)
{
Client client = (Client)sender;
string message = args.CommandArgs[0];
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject <List <MessageRecievedEventArgs> >(message);
List <MessageRecievedEventArgs> logs = (List <MessageRecievedEventArgs>)obj;
logs.Reverse();
foreach (MessageRecievedEventArgs log in (List <MessageRecievedEventArgs>)obj)
{
String StatusString = ConvertEnumType(log.Status);
LogEntries.Add(new Log {
EntryType = log.Status, Message = log.Message, Status = StatusString
});
}
}
else if (commandID == CommandEnum.LogCommand)
{
Client client = (Client)sender;
string message = args.CommandArgs[0];
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject <MessageRecievedEventArgs>(args.CommandArgs[0]);
MessageRecievedEventArgs SpecificLogView = (MessageRecievedEventArgs)obj;
String StatusString = ConvertEnumType(SpecificLogView.Status);
LogEntries.Insert(0, new Log {
EntryType = SpecificLogView.Status, Message = SpecificLogView.Message,
Status = StatusString
});
}
}
/// <summary>Commands the specified command.</summary>
/// <param name="command">The command.</param>
/// <param name="inputs">The inputs.</param>
/// <returns></returns>
/// <exception cref="InvalidCommandException">Robot does not exist
/// or
/// Invalid command</exception>
public string Command(CommandEnum command, string inputs = "")
{
if (command != CommandEnum.PLACE && robot == null)
{
throw new InvalidCommandException("Robot does not exist");
}
switch (command)
{
case CommandEnum.PLACE:
Place(inputs);
break;
case CommandEnum.MOVE:
robot.Move();
break;
case CommandEnum.LEFT:
robot.RotateLeft();
break;
case CommandEnum.RIGHT:
robot.RotateRight();
break;
case CommandEnum.REPORT:
return(robot.Report());
default:
throw new InvalidCommandException("Invalid command");
}
return("");
}
private CommandDefinition.CommandFormat ConstructCommand(CommandEnum command, BooleanValue ackReq, ActionEnum action, byte subAction)
{
CommandDefinition.CommandAckStruct cmdAck = new CommandDefinition.CommandAckStruct(command, ackReq, BooleanValue.False);
CommandDefinition.ActionStruct a = new CommandDefinition.ActionStruct(action, subAction);
CommandDefinition.CommandFormat cmd = new CommandDefinition.CommandFormat(cmdAck.CommandWithAck, a.ActionAndSubAction);
return(cmd);
}
/// <summary>
///
/// </summary>
/// <param name="Out"></param>
/// <param name="OutSize"></param>
/// <param name="In"></param>
/// <param name="InSize"></param>
/// <param name="Command"></param>
/// <param name="DoChecks"></param>
/// <returns></returns>
public ResultEnum hleUtilsBufferCopyWithRange(byte* Out, int OutSize, byte* In, int InSize, CommandEnum Command, bool DoChecks = true)
{
try
{
switch (Command)
{
case CommandEnum.PSP_KIRK_CMD_DECRYPT_PRIVATE: kirk_CMD1(Out, In, InSize, DoChecks); break;
case CommandEnum.PSP_KIRK_CMD_ENCRYPT: kirk_CMD4(Out, In, InSize); break;
case CommandEnum.PSP_KIRK_CMD_ENCRYPT_FUSE: kirk_CMD5(Out, In, InSize); break;
case CommandEnum.PSP_KIRK_CMD_DECRYPT: kirk_CMD7(Out, In, InSize); break;
case CommandEnum.PSP_KIRK_CMD_DECRYPT_FUSE: executeKIRKCmd8(Out, In, InSize); break;
case CommandEnum.PSP_KIRK_CMD_PRIV_SIG_CHECK: kirk_CMD10(In, InSize); break;
case CommandEnum.PSP_KIRK_CMD_SHA1_HASH: KirkSha1(Out, In, InSize); break;
case CommandEnum.PSP_KIRK_CMD_ECDSA_GEN_KEYS: executeKIRKCmd12(Out, OutSize); break;
case CommandEnum.PSP_KIRK_CMD_ECDSA_MULTIPLY_POINT: executeKIRKCmd13(Out, OutSize, In, InSize); break;
case CommandEnum.PSP_KIRK_CMD_PRNG: kirk_CMD14(Out, InSize); break;
case CommandEnum.PSP_KIRK_CMD_ECDSA_SIGN: executeKIRKCmd16(Out, OutSize, In, InSize); break;
case CommandEnum.PSP_KIRK_CMD_ECDSA_VERIFY: executeKIRKCmd17(In, InSize); break;
default: throw(new KirkException(ResultEnum.PSP_KIRK_INVALID_OPERATION));
}
return ResultEnum.OK;
}
catch (KirkException KirkException)
{
return KirkException.Result;
}
}
private void ExecuteAction(object sender, IncomingMessage receivedMessage)
{
Entity owner = networkedScene.EntityManager.Find(receivedMessage.ReadString());
Entity other = networkedScene.EntityManager.Find(receivedMessage.ReadString());
if (owner != null && !owner.IsDisposed && other != null && !other.IsDisposed)
{
WorldObject wo = owner.FindComponent <WorldObject>();
CommandEnum cmd = (CommandEnum)receivedMessage.ReadInt32();
foreach (ActionBehavior act in wo.allActions)
{
if (act.GetCommand() == cmd)
{
bool store = receivedMessage.ReadBoolean();
if (store)
{
wo.EnqueueAction(() => act.Act(other.FindComponent <WorldObject>()));
}
else
{
act.Act(other.FindComponent <WorldObject>());
}
break;
}
}
}
}
public QueueCommand(PackageClass packageClass, CommandEnum oper)
{
Date = DateTime.Now;
CommandEnum = oper;
TargetId = packageClass.GeneralInfo.Id;
TargetVersion = packageClass.GeneralInfo.Version;
}
public QueueCommand(PackageClass packageClass, CommandEnum oper)
{
Date = DateTime.Now;
CommandEnum = oper;
TargetId = packageClass.GeneralInfo.Id;
TargetVersion = packageClass.GeneralInfo.Version;
}
private void WaitForKey(object sender, EventArgs e)
{
CustomButton b = sender as CustomButton;
CommandEnum action;
if (Enum.TryParse(b.Text, out action))
{
if (!rewriting || current != action)
{
Cancel();
lastClicked = b.number;
blocks[lastClicked].IsBorder = true;
blocks[lastClicked].BorderColor = Color.Blue;
buttons[lastClicked].BorderColor = Color.Blue;
rewriting = true;
current = action;
}
else
{
Cancel();
}
}
WaveServices.Layout.PerformLayout(this);
}
public ReportResponse ReportOK(CommandEnum command = CommandEnum.Void)
=> new ReportResponse()
{
c = command,
e = ErrorEnum.Void,
rc = ResponseCodeEnum.OK
};
/// <summary>
/// send command to all the handlers.
/// </summary>
/// <param name="commandId"> the command required to be performed </param>
/// <param name="args"> the arguments for the command </param>
/// <param name="path"> the path related to the command </param>
public void sendCommand(CommandEnum commandId, string[] args, string path)
{
CommandRecievedEventArgs cmdEventArgs = new CommandRecievedEventArgs((int)commandId, args, path);
CommandRecieved?.Invoke(this, cmdEventArgs);
m_logging.Log(path + " - " + commandId, Logging.Modal.MessageTypeEnum.INFO);
}
public void SendCommand(CommandEnum commandID, string[] args)
{
client.SendMessageToServer(new CommandEventArgs()
{
CommandID = commandID, CommandArgs = args
});
}
/// <summary>
/// Get an array of bytes to use as the default arguments for a
/// command when no arguments are given; we have to specify the
/// expected data/response size as the arguments instead.
/// </summary>
/// <param name="command">Command</param>
/// <returns>byte[]</returns>
public static byte[] GetCommandDefaultArgumentsBytes(CommandEnum command)
{
ByteStream bytes = new ByteStream();
bytes.BinaryWriter.Write(CommandHelper.GetCommandDataSize(command));
return(bytes.GetBytes());
}
private void WriteCommandParameter(CommandParameter parameter, List <string> enumValues, BinaryStream stream)
{
stream.WriteString(parameter.Name);
int type = parameter.Type;
if (parameter.CommandEnum != null && parameter.CommandEnum.Values.Length > 0)
{
CommandEnum commandEnum = parameter.CommandEnum;
List <string> realValue = new List <string>();
for (int k = 0; k < commandEnum.Values.Length; ++k)
{
string value = commandEnum.Values[k];
if (enumValues.Contains(value))
{
realValue.Add(value);
}
else
{
enumValues.Add(value);
realValue.Add(value);
}
}
CommandEnum c = new CommandEnum(commandEnum.Name, realValue.ToArray());
int enumIndex = -1;
if (this.Enums.Contains(c, new CommandEnumComparer()))
{
enumIndex = this.Enums.IndexOf(c) & 0xffff;
}
else
{
this.Enums.Add(c);
enumIndex = this.Enums.IndexOf(c) & 0xffff;
}
type = CommandParameter.ARG_FLAG_ENUM | CommandParameter.ARG_FLAG_VALID | enumIndex;
}
else if (!string.IsNullOrEmpty(parameter.Postfix))
{
int key = -1;
string postFix = parameter.Postfix;
if (this.PostFixes.Contains(postFix))
{
key = this.PostFixes.IndexOf(postFix) & 0xffff;
}
else
{
this.PostFixes.Add(postFix);
key = this.PostFixes.IndexOf(postFix) & 0xffff;
}
type = CommandParameter.ARG_FLAG_POSTFIX | CommandParameter.ARG_FLAG_VALID | key;
}
else
{
type |= CommandParameter.ARG_FLAG_VALID;
}
stream.WriteLInt((uint)type);
stream.WriteBool(parameter.Optional);
stream.WriteByte(parameter.UnknownByte);
}
private bool DefineSquirrelOption(ArgumentSyntax syntax, string name, CommandEnum command, bool hasVersion)
{
Argument<string> option = syntax.DefineOption(name, ref SquirrelVersion, hasVersion, string.Empty);
option.IsHidden = true;
if (option.IsSpecified)
{
Command = command;
return true;
}
return false;
}
public void exec(CommandEnum command, List<string> attributes, Organism.Organism organism)
{
switch (command)
{
case CommandEnum.born:
Born born = new Born(organism);
born.exec(attributes);
break;
default:
break;
}
}
public void CallCommand(CommandEnum requested, RaycastHit clicked)
{
if(clicked.Equals(null) || team == null) return;
switch((CommandEnum)requested){
case CommandEnum.Move:
team.AddCommand(new MoveCommand(team, clicked.transform.position));
break;
case CommandEnum.ArmMine:
team.AddCommand(new MineCommand(team));
break;
case CommandEnum.BlowDoor:
throw new System.NotImplementedException("BlowDoor");
break;
case CommandEnum.BlowWindow:
throw new System.NotImplementedException("BlowWindow");
break;
case CommandEnum.CoverHostage:
throw new System.NotImplementedException("CoverHostage");
break;
case CommandEnum.ForceDoor:
throw new System.NotImplementedException("ForceDoor");
break;
case CommandEnum.OpenDoor:
team.AddCommand(new DoorCommand(team, clicked.transform.gameObject));
break;
case CommandEnum.OpenWindow:
team.AddCommand(new OpenWIndowCommand(team, clicked.transform.gameObject.GetComponent<Window>()));
break;
case CommandEnum.ThrowFragGrenade:
team.AddCommand(new FragGrenadeCommand(team));
break;
case CommandEnum.ThrowFlashGrenade:
throw new System.NotImplementedException("FlashGrenade");
break;
case CommandEnum.Wait:
throw new System.NotImplementedException("WaitPoint");
break;
default:
break;
}
}
public CommandAckStruct(CommandEnum cmd, BooleanValue ackReq, BooleanValue isAck)
{
_commandWithAck = (byte)(((byte)cmd << 2) | ((byte)ackReq << 1) | (byte)isAck);
}
private string CommandReplyValidate(CommandDefinition.CommandFormat? reply, CommandEnum expectedCommand)
{
string result = /*OK*/ string.Empty;
if (/*fail?*/ reply == null)
result = "null reply";
else if (/*fail?*/ !reply.HasValue)
result = "reply has no value (!.HasValue)";
else if (/*fail?*/ reply.Value.CommandAck.Command != expectedCommand)
result = ".Value.CommandAck.Command(" + reply.Value.CommandAck.Command.ToString() + ") != " + expectedCommand.ToString();
else if (/*fail?*/ reply.Value.Action.Action != ActionEnum.Response)
result = ".Value.Action.Action(" + reply.Value.Action.Action.ToString() + ") != " + ActionEnum.Response.ToString();
return result;
}
private string CommandReplyValidate(CommandDefinition.CommandFormat? reply, CommandEnum expectedCommand, byte expectedSubAction)
{
string result = CommandReplyValidate(reply, expectedCommand);
if (/*OK?*/ string.IsNullOrWhiteSpace(result))
if (/*fail?*/ reply.Value.CommandAck.IsAck != BooleanValue.True)
result = ".Value.CommandAck.IsAck(" + reply.Value.CommandAck.IsAck.ToString() + ") != BooleanValue.True";
else if (/*fail?*/ reply.Value.Action.SubAction != expectedSubAction)
result = ".Value.Action.SubAction(" + reply.Value.Action.SubAction.ToString() + ") != " + expectedSubAction.ToString();
return result;
}
private void Apcs_ApcsUpdate(CommandEnum command, ActionEnum action, byte subAction, object data)
{
if (command == CommandEnum.PulseWidth && action == ActionEnum.Response)
_currentPulseWidth = (PulseWidth)PulseWidth.ToObject(typeof(PulseWidth), subAction);
else if (command == CommandEnum.ScanMode && action == ActionEnum.Response)
_currentApcsEnergyMode = (ScanEnergyMode)ScanEnergyMode.ToObject(typeof(ScanEnergyMode), subAction);
}
private CommandDefinition.CommandFormat CommandMake(CommandEnum commandCode, BooleanValue acknowledgeIsRequested, ActionEnum actionCode, byte subAction)
{
CommandDefinition.CommandAckStruct acknowledgement = new CommandDefinition.CommandAckStruct(commandCode, acknowledgeIsRequested, BooleanValue.False);
CommandDefinition.ActionStruct action = new CommandDefinition.ActionStruct(actionCode, subAction);
CommandDefinition.CommandFormat returnedCommand = new CommandDefinition.CommandFormat(acknowledgement.CommandWithAck, action.ActionAndSubAction);
return returnedCommand;
}
private bool ConfirmSetActionResponse(CommandDefinition.CommandFormat? response, CommandEnum command, byte subAction)
{
return (response != null &&
response.Value.CommandAck.Command == command &&
response.Value.Action.Action == ActionEnum.Response &&
response.Value.CommandAck.IsAck == BooleanValue.True &&
response.Value.Action.SubAction == subAction);
}
private CommandDefinition.CommandFormat ConstructCommand(CommandEnum command, BooleanValue ackReq, ActionEnum action, byte subAction)
{
CommandDefinition.CommandAckStruct cmdAck = new CommandDefinition.CommandAckStruct(command, ackReq, BooleanValue.False);
CommandDefinition.ActionStruct a = new CommandDefinition.ActionStruct(action, subAction);
CommandDefinition.CommandFormat cmd = new CommandDefinition.CommandFormat(cmdAck.CommandWithAck, a.ActionAndSubAction);
return cmd;
}
public void AddCommand(CommandEnum command, string commandData)
{
this.commands.Add(new KeyValuePair<CommandEnum, string>(command, commandData));
}
public void AddCommand(CommandEnum command)
{
this.commands.Add(new KeyValuePair<CommandEnum, string>(command, null));
}
public CopyDataTransport(CommandEnum command, string commandData)
: this()
{
AddCommand(command, commandData);
}
public CopyDataTransport(CommandEnum command)
: this()
{
AddCommand(command, null);
}
public byte Size; // Size - 1 byte - Indicates number of packet(s) following the Command Packet
public CommandPacket(CommandEnum command, TypeEnum type)
{
Reserved_1 = 0x16;
Reserved_2 = 0x16;
Reserved_3 = 0x16;
Reserved_4 = 0x16;
this.Command = command;
this.Type = type;
Size = 0;
Reserved2 = 0;
}