public Responseo BeginProcess(Commando command)
{
switch (command.Action)
{
case CommandAction.MouseMove:
var(deltaX, deltaY) = command.GetInts();
MoveMouse(deltaX, deltaY);
return(Responseo.CreateResponse(command, CommandDispatchResult.Ack));
case CommandAction.MouseSet:
var(xPosition, yPosition) = command.GetInts();
SetMouse(xPosition, yPosition);
return(Responseo.CreateResponse(command, CommandDispatchResult.Ack));
case CommandAction.MouseClick:
var clickButton = command.GetEnum <MouseButton>();
ClickMouse(clickButton);
return(Responseo.CreateResponse(command, CommandDispatchResult.Ack));
case CommandAction.MouseWheel:
var(wheelDirection, wheelAmount) = command.GetEnumInt <MouseWheelDirection>();
WheelMouse(wheelDirection, wheelAmount);
return(Responseo.CreateResponse(command, CommandDispatchResult.Ack));
default:
return(Responseo.CreateResponse(command, CommandDispatchResult.Nack));
}
}
private void AddCommando(string id, string firstName, string lastName, string[] data)
{
decimal salary = decimal.Parse(data[4]);
bool isValidCorps = Enum.TryParse(data[5], out Corps corps);
if (!isValidCorps)
{
return;
}
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
for (int i = 6; i < data.Length; i += 2)
{
string missionCode = data[i];
bool isValidMissionState = Enum.TryParse(data[i + 1], out States missionState);
if (isValidMissionState)
{
commando.Missions.Add(new Mission(missionCode, missionState));
}
}
this.soldiers.Add(commando);
}
private ISoldier GetCommando(int id, string firstName, string lastName, decimal salary, string[] args)
{
//. In case of invalid corps the entire line should be skipped,
//in case of an invalid mission state only the mission should be skipped.
var isValidCorps = Enum.TryParse(args[5], out Corps corps);
if (!isValidCorps)
{
return(null);
}
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
for (int i = 6; i < args.Length; i += 2)
{
string codeName = args[i];
string missionState = args[i + 1];
var isValidState = Enum.TryParse(missionState, out State state);
if (!isValidState)
{
continue;
}
IMission mission = new Mission(codeName, state);
commando.Missions.Add(mission);
}
return(commando);
}
public static void Main()
{
string input;
List <ISoldier> army = new List <ISoldier>();
while ((input = Console.ReadLine()) != "End")
{
var args = input.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries).ToList();
string command = args[0];
switch (command)
{
case "Private":
ISoldier privPrivate = new Private(int.Parse(args[1]), args[2], args[3], double.Parse(args[4]));
army.Add(privPrivate);
break;
case "LeutenantGeneral":
List <string> inputPrivate = args.GetRange(5, args.Count - 5);
ISoldier general = new LeutenantGeneral(int.Parse(args[1]), args[2], args[3], double.Parse(args[4]), GetSoldiers(inputPrivate, army));
army.Add(general);
break;
case "Engineer":
if (args[5] != "Airforces" && args[5] != "Marines")
{
break;
}
string corp = args[5];
List <string> pairsInput = args.GetRange(6, args.Count - 6);
ISoldier engineer = new Engineer(int.Parse(args[1]), args[2], args[3], double.Parse(args[4]), corp, ExtractRepairsList(pairsInput));
army.Add(engineer);
break;
case "Commando":
if (args[5] != "Airforces" && args[5] != "Marines")
{
break;
}
corp = args[5];
List <string> inputMission = args.GetRange(6, args.Count - 6);
ISoldier comando = new Commando(int.Parse(args[1]), args[2], args[3], double.Parse(args[4]), corp, ExtractMission(inputMission));
army.Add(comando);
break;
case "Spy":
ISoldier spy = new Spy(int.Parse(args[1]), args[2], args[3], int.Parse(args[4]));
army.Add(spy);
break;
default:
Console.WriteLine("Invalid command");
break;
}
}
foreach (var soldier in army)
{
Console.WriteLine(soldier);
}
}
private static Soldier CreateCommando(int id, string firstName, string lastName, double salary, string corps, string[] cmdArgs)
{
Commando commando = null;
try
{
commando = new Commando(id, firstName, lastName, salary, corps);
}
catch (ArgumentException)
{
return(null);
}
for (int i = 6; i < cmdArgs.Length - 1; i += 2)
{
try
{
string codeName = cmdArgs[i];
string state = cmdArgs[i + 1];
commando.AddMission(new Mission(codeName, state));
}
catch (Exception)
{
continue;
}
}
return(commando);
}
public static void AddCommandoToArmy(string[] args, string id, string firstName, string lastName, decimal salary)
{
try
{
string corpsC = args[0];
Commando commando = CommandoFactory.CreateCommando(id, firstName, lastName, salary, corpsC);
string[] missionArgs = args.Skip(1).ToArray();
for (int i = 0; i < missionArgs.Length; i += 2)
{
Mission mission;
try
{
string codeName = missionArgs[i];
string state = missionArgs[i + 1];
mission = MissionFactory.CreateMission(codeName, state);
commando.AddMission(mission);
}
catch (InvalidStateExceprion ise)
{
continue;
}
}
Engine.army.Add(commando);
}
catch (InvalidCorpseException ice)
{
}
}
private ISoldier GetCommando(int id, string firstName, string lastName, decimal salary, string[] inputArgs)
{
string corpsAsString = inputArgs[5];
if (!Enum.TryParse(corpsAsString, out Corps corps))
{
return(null);
}
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
for (int counter = 6; counter < inputArgs.Length; counter += 2)
{
string codeName = inputArgs[counter];
string stateAsString = inputArgs[counter + 1];
if (!Enum.TryParse(stateAsString, out State state))
{
continue;
}
IMission mission = new Mission(codeName, state);
commando.Missions.Add(mission);
}
return(commando);
}
public static bool Init()
{
Commando.Setup();
Huntress.Setup();
Artificer.Setup();
Mercenary.Setup();
Engineer.Setup();
Acrid.Setup();
return(true);
//#region merc
//LoadoutAPI.AddSkill(typeof(VTStates.States.Mercenary.SummonClones));
//{
// SkillDef mySkillDef = ScriptableObject.CreateInstance<SkillDef>();
// mySkillDef.activationState = new SerializableEntityStateType(typeof(VTStates.States.Mercenary.SummonClones));
// mySkillDef.activationStateMachineName = "Weapon";
// mySkillDef.baseMaxStock = 2;
// mySkillDef.baseRechargeInterval = 16f;
// mySkillDef.beginSkillCooldownOnSkillEnd = false;
// mySkillDef.canceledFromSprinting = false;
// mySkillDef.fullRestockOnAssign = true;
// mySkillDef.interruptPriority = InterruptPriority.Any;
// mySkillDef.isBullets = false;
// mySkillDef.isCombatSkill = true;
// mySkillDef.mustKeyPress = true;
// mySkillDef.noSprint = false;
// mySkillDef.rechargeStock = 1;
// mySkillDef.requiredStock = 1;
// mySkillDef.shootDelay = 0f;
// mySkillDef.stockToConsume = 1;
// //mySkillDef.icon = Resources.Load<Sprite>()
// mySkillDef.skillDescriptionToken = "Summon a shadow clone that inherits your items";
// mySkillDef.skillName = "EXPANDEDSKILLS_SUMMONCLONE_SPECIAL";
// mySkillDef.skillNameToken = "Shadow Clones";
// LoadoutAPI.AddSkillDef(mySkillDef);
// GameObject gameObject = Resources.Load<GameObject>("prefabs/characterbodies/mercbody");
// SkillLocator component = gameObject.GetComponent<SkillLocator>();
// SkillFamily skillFamily = component.special.skillFamily;
// Array.Resize(ref skillFamily.variants, skillFamily.variants.Length + 1);
// skillFamily.variants[skillFamily.variants.Length - 1] = new SkillFamily.Variant
// {
// skillDef = mySkillDef,
// unlockableName = "",
// viewableNode = new ViewablesCatalog.Node(mySkillDef.skillNameToken, false, null)
// };
//}
//#endregion merc
#region commando
#endregion commando
}
public ICommando CreateCommando(string[] args)
{
string id = args[1];
string firstName = args[2];
string lastName = args[3];
decimal salary = decimal.Parse(args[4]);
string corpsStr = args[5];
string[] missionInfo = args.Skip(6).ToArray();
ICommando commando = new Commando(id, firstName, lastName, salary, corpsStr);
if (missionInfo.Length != 0)
{
for (int i = 0; i < missionInfo.Length; i += 2)
{
string codeName = missionInfo[i];
string status = missionInfo[i + 1];
try
{
Mission mission = new Mission(codeName, status);
commando.AddMission(mission);
}
catch (Exception)
{
}
}
}
return(commando);
}
private static void CreateCommando(List <ISoldier> soldiers, List <string> splittedInput, int id, string firstName, string lastName)
{
decimal salary = ParseSalary(splittedInput);
var corp = splittedInput[5];
if (!Enum.IsDefined(typeof(Corps), corp))
{
return;
}
ICommando commando = new Commando(id, firstName, lastName, salary, (Corps)Enum.Parse(typeof(Corps), corp));
splittedInput = Skipping(splittedInput, 6);
for (int i = 0; i < splittedInput.Count; i += 2)
{
var codeName = splittedInput[i];
var state = splittedInput[i + 1];
if (!Enum.IsDefined(typeof(MissionStates), state))
{
continue;
}
IMission mission = new Mission(codeName, (MissionStates)Enum.Parse(typeof(MissionStates), state));
commando.AddMission(mission);
}
soldiers.Add(commando);
}
internal string RegisterCommando(string id, string firstName, string lastName, double salary, string corps, string[] missionsData)
{
var missions = new Queue <IMission>();
for (int i = 0; i < missionsData.Length; i++)
{
var codeName = missionsData[i];
i++;
var state = missionsData[i];
try
{
missions.Enqueue(new Mission(codeName, state));
}
catch (ArgumentException)
{
continue;
}
}
var currentSoldier = new Commando(id, firstName, lastName, salary, corps, missions);
this.soldiers.Add(currentSoldier);
return(currentSoldier.ToString());
}
public void CanDeserialiseIntPairCommand()
{
var serialised = "0 0 MouseMove 10,11";
var c = Commando.Parse(serialised);
Assert.Equal((10, 11), c.GetInts());
}
public void CanDeserialiseCommand()
{
var serialised = "0 0 Unidentified";
var c = Commando.Parse(serialised);
Assert.Equal(CommandAction.Unidentified, c.Action);
}
private static ICommando CreateComando(string[] cmdArg, int id, string firstName, string lastName, decimal salary, string corps)
{
ICommando commando = new Commando(firstName, lastName, id, salary, corps);
string[] missions = cmdArg.Skip(6).ToArray();
for (int i = 0; i < missions.Length; i += 2)
{
try
{
string codeName = missions[i];
string state = missions[i + 1];
IMission mission = new Mission(codeName, state);
commando.AddMission(mission);
}
catch (InvalidMissionStateException)
{
continue;
}
}
return(commando);
}
private ICommando CreateCommando(string[] commandArgs, int id, string firstName, string lastName, decimal salary)
{
string corps = commandArgs[5];
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
string[] missionsArgs = commandArgs
.Skip(6)
.ToArray();
for (int i = 0; i < missionsArgs.Length; i += 2)
{
string codeName = missionsArgs[i];
string state = missionsArgs[i + 1];
try
{
IMission mission = new Mission(codeName, state);
commando.AddMission(mission);
}
catch (InvalidMissionException ime)
{
continue;
}
}
return(commando);
}
private ISoldier GetCommando(int id, string firstName, string lastName, decimal salary, string[] tokens)
{
string corpsAsString = tokens[5];
if (!Enum.TryParse(corpsAsString, out Corps corps))
{
return(null);
}
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
for (int i = 6; i < tokens.Length; i += 2)
{
string codeName = tokens[i];
string stateAsString = tokens[i + 1];
if (!Enum.TryParse(stateAsString, out State state))
{
continue;
}
IMission mission = new Mission(codeName, state);
commando.Missions.Add(mission);
}
return(commando);
}
private static ICommando GetCommando(string[] command, int id, string firstName, string lastName, decimal salary, string corps)
{
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
string[] missionArgs = command.Skip(6).ToArray();
for (int i = 0; i < missionArgs.Length; i += 2)
{
try
{
string missionCodeName = missionArgs[i];
string missionState = missionArgs[1];
IMission mission = new Mission(missionCodeName, missionState);
commando.AddMission(mission);
}
catch (InvalidMissionCompletionException imce)
{
continue;
}
}
return(commando);
}
private static void CreateAndPrintCommando(string[] tokens)
{
try
{
var commando = new Commando(int.Parse(tokens[1]),
tokens[2],
tokens[3],
decimal.Parse(tokens[4]),
tokens[5]);
for (int i = tokens.Length - 6; i < tokens.Length; i += 2)
{
if (tokens[i + 1] == "inProgress" || tokens[i + 1] == "Finished")
{
var codeName = tokens[i];
var state = tokens[i + 1];
commando.Missions.Add(new Mission(codeName, state));
}
}
Console.WriteLine(commando);
}
catch (Exception)
{
//ignored
}
}
/// <summary> Ejecuta sentencias de INSERT, DELETE y UPDATE
/// </summary>
/// <param name="tipoComando">Tipo de comando a Ejecutar</param>
/// <param name="query">Instruccion SQL a Ejecutar</param>
/// <returns>Un entero con el numero de registros Afectados</returns>
public Int32 ExecuteNonQuery(CommandType tipoComando, String query)
{
VerificarComando();
Commando.Connection = Conexion;
Commando.CommandType = tipoComando;
Commando.CommandText = query;
Int32 nRowsReturn;
try
{
nRowsReturn = Commando.ExecuteNonQuery();
}
catch (MySqlException ex)
{
nRowsReturn = -1; //
ErrorMessage = ex.Message;
}
catch (Exception ex)
{
nRowsReturn = -1; //
ErrorMessage = ex.Message;
}
return(nRowsReturn);
}
public static void AddCommando(string[] info, List <ISoldier> soldiers)
{
var id = int.Parse(info[1]);
var firstName = info[2];
var lastName = info[3];
double salary = double.Parse(info[4]);
string corps = info[5];
List <Mission> missions = new List <Mission>();
if (corps == "Airforces" || corps == "Marines")
{
for (int i = 6; i < info.Length; i += 2)
{
var missionCodeName = info[i];
var missionState = info[i + 1];
if (missionState == "inProgress" || missionState == "Finished")
{
Mission mission = new Mission(missionCodeName, missionState);
missions.Add(mission);
}
}
Commando engineer = new Commando(firstName, lastName, id, salary, corps, missions);
soldiers.Add(engineer);
}
}
private ISoldier GetCommandoType(int id, string firstName, string lastName, decimal salary, string[] newArgs)
{
ICommando commando = null;
Corp corp;
bool isCastToCorp = Enum.TryParse <Corp>(newArgs[0], out corp);
if (isCastToCorp)
{
commando = new Commando(id, firstName, lastName, salary, corp);
string codeName;
string state;
for (int i = 1; i < newArgs.Length; i += 2)
{
codeName = newArgs[i];
state = newArgs[i + 1];
//“Commando <id> <firstName> <lastName> <salary> <corps>
//<mission1CodeName> <mission1state> … <missionNCodeName> <missionNstate>”
//a missions cde name, description and state will always come together
//bool validMissionName = Enum.TryParse<State>(missionName, out newMission.State)
if (Enum.TryParse <State>(state, out State newState))
{
IMission validMissionName = new Mission(codeName, newState);
commando.AddMission(validMissionName);
}
}
}
return(commando);
}
/// <summary>Ejecuta sentencias SQL en la BAse de datos
/// </summary>
/// <param name="tipoComando">CommandType para saber que se hace con la instruccion</param>
/// <param name="query">La sentencia SQL a Ejecutar</param>
/// <returns>Un Datareader para ser recorrido</returns>
public MySqlDataReader ExecuteReader(CommandType tipoComando, String query)
{
MySqlDataReader DataReader = null;
VerificarComando();
Commando.Connection = Conexion;
//Commando.CommandTimeout = 240; // Este valor es en segundos
Commando.CommandType = tipoComando;
Commando.CommandText = query;
try
{
DataReader = Commando.ExecuteReader();
}
catch (MySqlException ex)
{
ErrorMessage = ex.Message;
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
}
return(DataReader);
}
private ISoldier GenerateCommando(int id, string firstName, string lastName, string[] args)
{
string corpsAsString = args[5];
if (!Enum.TryParse(corpsAsString, out Corps corps))
{
return(null);
}
ICommando commando = new Commando(firstName, lastName, id, decimal.Parse(args[4]), corps);
for (int i = 6; i < args.Length; i += 2)
{
string missionName = args[i];
string missionStateAsString = args[i + 1];
if (!Enum.TryParse(missionStateAsString, out State state))
{
continue;
}
IMission mission = new Mission(missionName, state);
commando.Missions.Add(mission);
}
return(commando);
}
private ISoldier GetCommando(int id, string firstName, string lastName, decimal salary, string[] inputArgs)
{
if (!Enum.TryParse(inputArgs[5], out Corps corps))
{
return(null);
}
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
for (int i = 6; i < inputArgs.Length; i += 2)
{
var codeName = inputArgs[i];
var isValidState = Enum.TryParse(inputArgs[i + 1], out State st);
if (isValidState)
{
IMission mission = new Mission(codeName, st);
commando.Missions.Add(mission);
}
else
{
continue;
}
}
return(commando);
}
private ISoldier GetCommando(int id, string firstName, string lastName, decimal salary,
string[] splitted)
{
string corpsVal = splitted[5];
if (!Enum.TryParse(corpsVal, out Corps corps))
{
return(null);
}
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
for (int i = 6; i < splitted.Length; i += 2)
{
string missionCodeName = splitted[i];
string missionState = splitted[i + 1];
if (!Enum.TryParse(missionState, out State state))
{
continue;
}
IMission mission = new Mission(missionCodeName, state);
commando.Missions.Add(mission);
}
return(commando);
}
private ISoldier GetCommando(int id, string firstName, string lastName, decimal salary, string[] input)
{
var corpsStr = input[5];
if (!Enum.TryParse(corpsStr, out Corps corps))
{
return(null);
}
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
State state;
for (int i = 6; i < input.Length; i += 2)
{
var codeName = input[i];
var stateStr = input[i + 1];
if (Enum.TryParse(stateStr, out state) == false)
{
continue;
}
IMission mission = new Mission(codeName, state);
commando.Missions.Add(mission);
}
return(commando);
}
private static Commando GetCommandoData(string[] soldierInfo)
{
var id = soldierInfo[1];
var firstName = soldierInfo[2];
var lastName = soldierInfo[3];
var salary = double.Parse(soldierInfo[4]);
var corps = soldierInfo[5];
var commando = new Commando(id, firstName, lastName, salary, corps);
var missions = soldierInfo.Skip(6).ToArray();
for (var i = 0; i < missions.Length - 1; i += 2)
{
var missionName = missions[i];
var missionState = missions[i + 1];
try
{
var mission = new Mission(missionName, missionState);
commando.Missions.Add(mission);
}
catch (Exception) { }
}
return(commando);
}
private ISoldier CreateCommando(string[] arguments)
{
var id = int.Parse(arguments[0]);
var firstName = arguments[1];
var lastName = arguments[2];
var salary = decimal.Parse(arguments[3]);
var corps = arguments[4];
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
var missions = arguments
.Skip(5)
.ToList();
for (int i = 0; i < missions.Count; i += 2)
{
try
{
var missionCodeName = missions[i];
var missionState = missions[i + 1];
IMission mission = new Mission(missionCodeName, missionState);
commando.AddMission(mission);
}
catch (InvalidStateException)
{
continue;
}
}
return(commando);
}
private static ISoldier CreateCommando(string[] arguments, int id, string firstName, string lastName, decimal salary, string corps)
{
ISoldier soldier;
Commando commando = new Commando(id, firstName, lastName, salary, corps);
string[] missionArguments = arguments.Skip(6).ToArray();
for (int i = 0; i < missionArguments.Length; i += 2)
{
try
{
string codeName = missionArguments[i];
string state = missionArguments[i + 1];
Mission missionToAdd = new Mission(codeName, state);
commando.AddMission(missionToAdd);
}
catch
{
continue;
}
}
soldier = commando;
return(soldier);
}
private static void ExecuteCommandoCommand(List <string> inputLineArgs)
{
int id = int.Parse(inputLineArgs[0]);
string firstName = inputLineArgs[1];
string lastName = inputLineArgs[2];
double salary = double.Parse(inputLineArgs[3]);
string corps = inputLineArgs[4];
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
var missionPairs = inputLineArgs.Skip(5).ToList();
for (int i = 0; i < missionPairs.Count - 1; i += 2)
{
try
{
string codeName = missionPairs[i];
string state = missionPairs[i + 1];
IMission mission = new Mission(codeName, state);
commando.Missions.Add(mission);
}
catch
{
}
}
Console.WriteLine(commando.ToString().Trim());
}
public Commando.collisiondetection.ConvexPolygonInterface getBounds(Commando.levels.HeightEnum height)
{
throw new NotImplementedException();
}
public Chasing(Soldier _soldier, Commando commando):base(_soldier){
this.commando = commando;
}
public RunOptions(Commando commando)
{
Command = commando.Command;
Arguments = commando.Arguments;
}
public ConvexPolygonInterface getBounds(Commando.levels.HeightEnum height)
{
return animation_.getBounds();
}
/// <summary>
/// Dummy function, overridden in ItemAbstract
/// </summary>
/// <param name="collisionDetector"></param>
public virtual void setCollisionDetector(Commando.collisiondetection.CollisionDetectorInterface collisionDetector)
{
// Dummy function, overridden in ItemAbstract
}
public Commando.collisiondetection.ConvexPolygonInterface getBounds(Commando.levels.HeightEnum height)
{
int animationSet = 0;
if (numberAnimations_ > numberActionLevels_)
{
animationSet = character_.getActuator().getCurrentAnimationSet();
}
if (height == Commando.levels.HeightEnum.HIGH)
{
return animation_[highActionLevel_ + animationSet].getBounds();
}
return animation_[lowActionLevel_ + animationSet].getBounds();
}
public Commando.collisiondetection.ConvexPolygonInterface getBounds(Commando.levels.HeightEnum height)
{
if (animation_.GetLength(0) > 1)
{
int animSet = character_.getActuator().getCurrentAnimationSet();
return animation_[animSet].getBounds();
}
return animation_[0].getBounds();
}
