public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine attackingMachine = this.machines.FirstOrDefault(m => m.Name == attackingMachineName);
if (attackingMachine == null)
{
return(string.Format(OutputMessages.MachineNotFound, attackingMachineName));
}
IMachine defendingMachine = this.machines.FirstOrDefault(m => m.Name == defendingMachineName);
if (defendingMachine == null)
{
return(string.Format(OutputMessages.MachineNotFound, defendingMachineName));
}
//TODO: Check if it can be below zero- keep in mind that there is no checking in the property
if (attackingMachine.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, attackingMachine.Name));
}
if (defendingMachine.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, defendingMachine.Name));
}
attackingMachine.Attack(defendingMachine);
return(string.Format(OutputMessages.AttackSuccessful, defendingMachine.Name, attackingMachine.Name, defendingMachine.HealthPoints));
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine attackingMachine = null;
IMachine defendingMachine = null;
for (int i = 0; i < machines.Count; i++)
{
if (machines[i].Name == attackingMachineName)
{
attackingMachine = machines[i];
}
if (machines[i].Name == defendingMachineName)
{
defendingMachine = machines[i];
}
}
if (attackingMachine == null)
{
return($"Machine { attackingMachineName} could not be found");
}
else if (defendingMachine == null)
{
return($"Machine {defendingMachineName} could not be found");
}
else if (attackingMachine.HealthPoints == 0)
{
return($"Dead machine {attackingMachineName} cannot attack or be attacked");
}
else if (defendingMachine.HealthPoints == 0)
{
return($"Dead machine {defendingMachineName} cannot attack or be attacked");
}
attackingMachine.Attack(defendingMachine);
return($"Machine {defendingMachine.Name} was attacked by machine {attackingMachine.Name} - current health: {defendingMachine.HealthPoints:F2}");
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine attackingMachine = machines.FirstOrDefault(m => m.Name == attackingMachineName);
if (attackingMachine is null)
{
return(string.Format(OutputMessages.MachineNotFound, attackingMachineName));
}
if (attackingMachine.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, attackingMachineName));
}
IMachine defendingMachine = machines.FirstOrDefault(m => m.Name == defendingMachineName);
if (defendingMachine is null)
{
return(string.Format(OutputMessages.MachineNotFound, defendingMachineName));
}
if (defendingMachine.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, defendingMachineName));
}
attackingMachine.Attack(defendingMachine);
return(string.Format(OutputMessages.AttackSuccessful, defendingMachineName, attackingMachineName, defendingMachine.HealthPoints));
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine attackingMachine = this.machines.FirstOrDefault(x => x.Name == attackingMachineName);
IMachine defendingMachine = this.machines.FirstOrDefault(x => x.Name == defendingMachineName);
if (attackingMachine == null)
{
return($"Machine {attackingMachineName} could not be found");
}
else if (defendingMachine == null)
{
return($"Machine {defendingMachineName} could not be found");
}
else if (attackingMachine.HealthPoints == 0)
{
return($"Dead machine {attackingMachineName} cannot attack or be attacked");
}
else if (defendingMachine.HealthPoints == 0)
{
return($"Dead machine {defendingMachineName} cannot attack or be attacked");
}
else
{
attackingMachine.Attack(defendingMachine);
return($"Machine {defendingMachineName} was attacked by machine {attackingMachineName} - current health: {defendingMachine.HealthPoints:F2}");
}
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
if (this.machines.ContainsKey(attackingMachineName) == false)
{
return($"Machine {attackingMachineName} could not be found");
}
if (this.machines.ContainsKey(defendingMachineName) == false)
{
return($"Machine {defendingMachineName} could not be found");
}
IMachine attackingMachine = this.machines[attackingMachineName];
IMachine defendingMachine = this.machines[defendingMachineName];
if (attackingMachine.HealthPoints <= 0)
{
return($"Dead machine {attackingMachineName} cannot attack or be attacked");
}
if (defendingMachine.HealthPoints <= 0)
{
return($"Dead machine {defendingMachine} cannot attack or be attacked");
}
attackingMachine.Attack(defendingMachine);
return($"Machine {defendingMachine.Name} was attacked by machine {attackingMachine.Name} - current health: {defendingMachine.HealthPoints:F2}");
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
if (this.machines.FirstOrDefault(n => n.Name == attackingMachineName) == null)
{
return($"Machine {attackingMachineName} could not be found");
}
if (this.machines.FirstOrDefault(n => n.Name == defendingMachineName) == null)
{
return($"Machine {defendingMachineName} could not be found");
}
if (this.machines.FirstOrDefault(n => n.Name == attackingMachineName).HealthPoints <= 0)
{
return($"Dead machine {attackingMachineName} cannot attack or be attacked");
}
if (this.machines.FirstOrDefault(n => n.Name == defendingMachineName).HealthPoints <= 0)
{
return($"Dead machine {defendingMachineName} cannot attack or be attacked");
}
IMachine attaackingMachine = this.machines.FirstOrDefault(n => n.Name == attackingMachineName);
IMachine defendingMachine = this.machines.FirstOrDefault(n => n.Name == defendingMachineName);
attaackingMachine.Attack(defendingMachine);
return($"Machine {defendingMachineName} was attacked by machine {attackingMachineName} - current health: {defendingMachine.HealthPoints:f2}");
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine attacker = this.machines.FirstOrDefault(x => x.Name == attackingMachineName);
IMachine defender = this.machines.FirstOrDefault(x => x.Name == defendingMachineName);
if (!CheckIfMachineExists(attackingMachineName))
{
return(string.Format(OutputMessages.MachineNotFound, attackingMachineName));
}
if (!CheckIfMachineExists(defendingMachineName))
{
return(string.Format(OutputMessages.MachineNotFound, defendingMachineName));
}
if (CheckIfDead(attacker))
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, attacker.Name));
}
if (CheckIfDead(defender))
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, defender.Name));
}
attacker.Attack(defender);
return(string.Format(OutputMessages.AttackSuccessful, defender.Name, attacker.Name, defender.HealthPoints));
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine attackingMachine = (IMachine)this.machineRepository.GetByName(attackingMachineName);
IMachine defendingMachine = (IMachine)this.machineRepository.GetByName(defendingMachineName);
if (attackingMachine == null)
{
return(string.Format(OutputMessages.MachineNotFound, attackingMachineName));
}
if (defendingMachine == null)
{
return(string.Format(OutputMessages.MachineNotFound, defendingMachineName));
}
if (attackingMachine.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, attackingMachineName));
}
if (defendingMachine.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, defendingMachineName));
}
attackingMachine.Attack(defendingMachine);
return(string.Format(OutputMessages.AttackSuccessful,
defendingMachine.Name, attackingMachine.Name, defendingMachine.HealthPoints));
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
if (this.machines.Any(m => m.Name == attackingMachineName) == false)
{
return(string.Format(OutputMessages.MachineNotFound, attackingMachineName));
}
if (this.machines.Any(m => m.Name == defendingMachineName) == false)
{
return(string.Format(OutputMessages.MachineNotFound, defendingMachineName));
}
IMachine attacker = this.machines.First(m => m.Name == attackingMachineName);
IMachine deffender = this.machines.First(m => m.Name == defendingMachineName);
if (attacker.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, attackingMachineName));
}
if (deffender.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, defendingMachineName));
}
attacker.Attack(deffender);
return(string.Format(OutputMessages.AttackSuccessful, deffender.Name, attacker.Name, deffender.HealthPoints));
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine attackingMachine = null;
IMachine defendingMachine = null;
if (!machines.ContainsKey(attackingMachineName))
{
return(string.Format(OutputMessages.MachineNotFound, attackingMachineName));
}
attackingMachine = machines[attackingMachineName];
if (!machines.ContainsKey(defendingMachineName))
{
return(string.Format(OutputMessages.MachineNotFound, defendingMachineName));
}
defendingMachine = machines[defendingMachineName];
if (attackingMachine.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, attackingMachineName));
}
if (defendingMachine.HealthPoints == 0)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, defendingMachineName));
}
attackingMachine.Attack(defendingMachine);
return(string.Format(OutputMessages.AttackSuccessful, defendingMachineName, attackingMachineName, defendingMachine.HealthPoints));
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine attackingMachine = this.machines.FirstOrDefault(x => x.Name == attackingMachineName);
IMachine defendingMachine = this.machines.FirstOrDefault(x => x.Name == defendingMachineName);
string result = string.Empty;
if (attackingMachine == null)
{
result = $"Machine {attackingMachineName} could not be found";
}
else if (defendingMachine == null)
{
result = $"Machine {defendingMachineName} could not be found";
}
else if (attackingMachine.HealthPoints <= 0)
{
result = $"Dead machine {attackingMachineName} cannot attack or be attacked";
}
else if (defendingMachine.HealthPoints <= 0)
{
result = $"Dead machine {defendingMachineName} cannot attack or be attacked";
}
else
{
attackingMachine.Attack(defendingMachine);
attackingMachine.Targets.Add(defendingMachine.Name);
result = $"Machine {defendingMachineName} was attacked by machine {attackingMachineName} - current health: {defendingMachine.HealthPoints:F2}";
}
return(result);
}
public string AttackMachines(
string attackingMachineName,
string defendingMachineName)
{
IMachine attacker = this.machines
.FirstOrDefault(m => m.Name == attackingMachineName);
IMachine defender = this.machines
.FirstOrDefault(m => m.Name == defendingMachineName);
if (attacker == null || defender == null)
{
string searchName = attacker == null
? attackingMachineName
: defendingMachineName;
return(string.Format(
OutputMessages.MachineNotFound,
searchName));
}
if (attacker.HealthPoints <= 0 ||
defender.HealthPoints <= 0)
{
string searchName = attacker == null
? attackingMachineName
: defendingMachineName;
return(string.Format(
OutputMessages.DeadMachineCannotAttack,
searchName));
}
attacker.Attack(defender);
return(string.Format(
OutputMessages.AttackSuccessful,
defendingMachineName,
attackingMachineName,
defender.HealthPoints));
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
if (!IsThatMachineExist(attackingMachineName))
{
return(String.Format(
OutputMessages.MachineNotFound,
attackingMachineName));
}
if (!IsThatMachineExist(defendingMachineName))
{
return(String.Format(
OutputMessages.MachineNotFound,
defendingMachineName));
}
IMachine attackingMachine = this.machines[attackingMachineName];
IMachine defendingMachine = this.machines[defendingMachineName];
if (attackingMachine.HealthPoints <= 0)
{
return(String.Format(
OutputMessages.DeadMachineCannotAttack,
attackingMachineName));
}
if (defendingMachine.HealthPoints <= 0)
{
return(String.Format(
OutputMessages.DeadMachineCannotAttack,
defendingMachineName));
}
attackingMachine.Attack(defendingMachine);
return(String.Format(OutputMessages.AttackSuccessful, defendingMachineName, attackingMachineName, defendingMachine.HealthPoints));
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
string result = string.Empty;
IMachine attackMachine = this.machines.FirstOrDefault(m => m.Name == attackingMachineName);
if (attackMachine == null)
{
result = string.Format(OutputMessages.MachineNotFound, attackingMachineName);
return(result);
}
IMachine defendingMachine = this.machines.FirstOrDefault(m => m.Name == defendingMachineName);
if (defendingMachine == null)
{
result = string.Format(OutputMessages.MachineNotFound, defendingMachineName);
return(result);
}
if (attackMachine.HealthPoints <= 0)
{
result = string.Format(OutputMessages.DeadMachineCannotAttack, attackingMachineName);
return(result);
}
if (defendingMachine.HealthPoints <= 0)
{
result = string.Format(OutputMessages.DeadMachineCannotAttack, defendingMachineName);
return(result);
}
attackMachine.Attack(defendingMachine);
result = string.Format(OutputMessages.AttackSuccessful, defendingMachine.Name, attackMachine.Name, defendingMachine.HealthPoints);
return(result);
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine machineOne = (IMachine)this.machines.FirstOrDefault(m => m.Name == attackingMachineName);
IMachine machineTwo = (IMachine)this.machines.FirstOrDefault(m => m.Name == defendingMachineName);
if (machineOne == null || machineTwo == null)
{
string name = machineOne == null ? attackingMachineName : defendingMachineName;
return(string.Format(OutputMessages.MachineNotFound, name));
}
else if (machineOne.HealthPoints == 0 || machineTwo.HealthPoints == 0)
{
string name = machineOne.HealthPoints == 0 ? attackingMachineName : defendingMachineName;
return(string.Format(OutputMessages.DeadMachineCannotAttack, name));
}
else
{
machineOne.Attack(machineTwo);
return(string.Format(OutputMessages.AttackSuccessful,
defendingMachineName,
attackingMachineName,
machineTwo.HealthPoints));
}
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
IMachine machineToAttack = this.machines.FirstOrDefault(m => m.Name == attackingMachineName);
bool isAttackingMachineExists = machineToAttack != null;
IMachine machineToDefend = this.machines.FirstOrDefault(m => m.Name == defendingMachineName);
bool isDefendingMachineExists = machineToDefend != null;
bool isAttackingDead = machineToAttack?.HealthPoints == 0.0;
bool isDefendingDead = machineToDefend?.HealthPoints == 0.0;
if (!isAttackingMachineExists)
{
return(string.Format(OutputMessages.MachineNotFound, attackingMachineName));
}
if (!isDefendingMachineExists)
{
return(string.Format(OutputMessages.MachineNotFound, defendingMachineName));
}
if (isAttackingDead)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, attackingMachineName));
}
if (isDefendingDead)
{
return(string.Format(OutputMessages.DeadMachineCannotAttack, defendingMachineName));
}
machineToAttack.Attack(machineToDefend);
return(string.Format(OutputMessages.AttackSuccessful, machineToDefend.Name, machineToAttack.Name, machineToDefend.HealthPoints));
}
public string AttackMachines(string attackingMachineName, string defendingMachineName)
{
string result;
IMachine attackingMachine = machines.FirstOrDefault(m => m.Name == attackingMachineName);
IMachine defendingMachine = machines.FirstOrDefault(m => m.Name == defendingMachineName);
if (attackingMachine == null)
{
result = string.Format(OutputMessages.MachineNotFound, attackingMachineName);
}
else if (defendingMachine == null)
{
result = string.Format(OutputMessages.MachineNotFound, defendingMachineName);
}
else if (attackingMachine.HealthPoints == 0)
{
result = string.Format(OutputMessages.DeadMachineCannotAttack, attackingMachine.Name);
}
else if (defendingMachine.HealthPoints == 0)
{
result = string.Format(OutputMessages.DeadMachineCannotAttack, defendingMachine.Name);
}
else
{
attackingMachine.Attack(defendingMachine);
result = string.Format(OutputMessages.AttackSuccessful,
defendingMachine.Name,
attackingMachine.Name,
defendingMachine.HealthPoints);
}
//if (attackingMachine != null && defendingMachine != null)
//{
// if (attackingMachine.HealthPoints > 0 && defendingMachine.HealthPoints > 0)
// {
// attackingMachine.Attack(defendingMachine);
// result = string.Format(OutputMessages.AttackSuccessful, defendingMachine.Name, attackingMachine.Name, defendingMachine.HealthPoints);
// }
// else
// {
// if (attackingMachine.HealthPoints <= 0)
// {
// result = string.Format(OutputMessages.DeadMachineCannotAttack, attackingMachineName);
// }
// else
// {
// result = string.Format(OutputMessages.DeadMachineCannotAttack, defendingMachineName);
// }
// }
//}
//else
//{
// if (attackingMachine == null)
// {
// result = string.Format(OutputMessages.MachineNotFound, attackingMachineName);
// }
// else
// {
// result = string.Format(OutputMessages.MachineNotFound, defendingMachineName);
// }
//}
return(result);
}
