public string Attack(string[] args)
{
string attackerName = args[0];
string receiverName = args[1];
var attacker = party.FirstOrDefault(c => c.Name == attackerName);
var receiver = party.FirstOrDefault(c => c.Name == receiverName);
ExeptionTracker.DoesCharacterExist(attacker, attackerName);
ExeptionTracker.DoesCharacterExist(receiver, receiverName);
ExeptionTracker.AttackableCharacter(attacker);
((Warrior)attacker).Attack(receiver);
var output = $"{attackerName} attacks {receiverName} for {attacker.AbilityPoints} hit points!" +
$" {receiverName} has {receiver.Health}/{receiver.BaseHealth} HP " +
$"and {receiver.Armor}/{receiver.BaseArmor} AP left!";
if (!receiver.IsAlive)
{
output += $"\n{receiver.Name} is dead!";
}
return(output);
}
public Vehicle GetVehicle(int garageSlot)
{
ExeptionTracker.IsValidGarageSlot(garageSlot, this);
ExeptionTracker.IsVehicleInside(this.garage[garageSlot]);
return(this.garage[garageSlot]);
}
public void Rest()
{
ExeptionTracker.IsAlive(this);
var increase = this.BaseHealth * this.RestHealMultiplier;
this.Health += increase;
}
public void Destroy(string hardwareName)
{
var hardware = this.dumpedHardware.FirstOrDefault(x => x.Name == hardwareName);
ExeptionTracker.IsValidHardware(hardware);
this.dumpedHardware.Remove(hardware);
}
public void Restore(string hardwareName)
{
var hardware = this.dumpedHardware.FirstOrDefault(x => x.Name == hardwareName);
ExeptionTracker.IsValidHardware(hardware);
this.allHardwares.Add(hardware);
}
public void Heal(Character character)
{
ExeptionTracker.IsAlive(this, character);
ExeptionTracker.IsEnemyHealing(this, character);
character.Health += this.AbilityPoints;
}
public void Dump(string hardwareName)
{
var hardware = allHardwares.FirstOrDefault(x => x.Name == hardwareName);
ExeptionTracker.IsValidHardware(hardware);
allHardwares.Remove(hardware);
this.dumpedHardware.Add(hardware);
}
public void LoadProduct(Product product)
{
if (this.IsFull)
{
ExeptionTracker.FullVehicle();
}
this.products.Add(product);
}
public void Attack(Character character)
{
ExeptionTracker.IsAlive(this, character);
ExeptionTracker.IsSelfAttack(this, character);
ExeptionTracker.IsFriendlyFire(this, character);
character.TakeDamage(this.AbilityPoints);
}
public void ReleaseSoftwareComponent(string[] tokens)
{
var hardwareName = tokens[1];
var softwareName = tokens[2];
var hardware = this.allHardwares.FirstOrDefault(h => h.Name == hardwareName);
ExeptionTracker.IsValidHardware(hardware);
hardware.ReleaseSoftware(softwareName);
}
public void ReleaseSoftware(string softwareName)
{
var software = this.implementedSoftwares.FirstOrDefault(x => x.Name == softwareName);
ExeptionTracker.IsValidSoftware(software);
this.implementedSoftwares.Remove(software);
this.CurrentCapacity += software.CapacityConsumption;
this.CurrentMemory += software.MemoryConsumption;
}
public Item GetItem(string name)
{
ExeptionTracker.IsBagEmpty(listItems);
var wantedItem = listItems.FirstOrDefault(i => i.GetType().Name == name);
ExeptionTracker.IsItemInBag(wantedItem, name);
listItems.Remove(wantedItem);
return(wantedItem);
}
public void RegisterSoftware(string[] tokens)
{
var softFactory = new SoftwareFactory();
var software = softFactory.Create(tokens);
var hardwareName = tokens[1];
var hardware = this.allHardwares.FirstOrDefault(h => h.Name == hardwareName);
ExeptionTracker.IsValidHardware(hardware);
hardware.ImplementSoftware(software);
}
public Product Unload()
{
if (this.IsEmpty)
{
ExeptionTracker.NoProductsInVehicle();
}
var lastProduct = this.products.Last();
this.products.Remove(lastProduct);
return(lastProduct);
}
public void TakeDamage(double hitPoints)
{
ExeptionTracker.IsAlive(this);
var leftHitPoints = this.Armor - hitPoints;
this.Armor -= hitPoints;
if (leftHitPoints < 0)
{
this.Health -= Math.Abs(leftHitPoints);
}
}
public string UseItem(string[] args)
{
var characterName = args[0];
var itemName = args[1];
var character = party.FirstOrDefault(c => c.Name == characterName);
ExeptionTracker.DoesCharacterExist(character, characterName);
var item = character.Bag.GetItem(itemName);
character.UseItem(item);
return($"{character.Name} used {itemName}.");
}
public string PickUpItem(string[] args)
{
var characterName = args[0];
var character = party.FirstOrDefault(c => c.Name == characterName);
ExeptionTracker.DoesCharacterExist(character, characterName);
ExeptionTracker.IsPoolEmpty(pool);
var item = pool.Last();
pool.Remove(item);
character.Bag.AddItem(item);
return($"{characterName} picked up {item.GetType().Name}!");
}
public int UnloadVehicle(int garageSlot)
{
ExeptionTracker.IsFullStorage(this.IsFull);
ExeptionTracker.IsValidGarageSlot(garageSlot, this);
ExeptionTracker.IsVehicleInside(this.garage[garageSlot]);
var vehicle = this.garage[garageSlot];
var countOfUnloadedProducts = 0;
while (this.IsFull != true && vehicle.IsEmpty != true)
{
this.products.Add(vehicle.Unload());
countOfUnloadedProducts++;
}
return(countOfUnloadedProducts);
}
public string GiveCharacterItem(string[] args)
{
string giverName = args[0];
string receiverName = args[1];
string itemName = args[2];
var giver = party.FirstOrDefault(c => c.Name == giverName);
var receiver = party.FirstOrDefault(c => c.Name == receiverName);
ExeptionTracker.DoesCharacterExist(giver, giverName);
ExeptionTracker.DoesCharacterExist(receiver, receiverName);
Item item = giver.Bag.GetItem(itemName);
giver.GiveCharacterItem(item, receiver);
return($"{giverName} gave {receiverName} {itemName}.");
}
public string Heal(string[] args)
{
string healerName = args[0];
string healingReceiverName = args[1];
var healer = party.FirstOrDefault(c => c.Name == healerName);
var receiver = party.FirstOrDefault(c => c.Name == healingReceiverName);
ExeptionTracker.DoesCharacterExist(healer, healerName);
ExeptionTracker.DoesCharacterExist(receiver, healingReceiverName);
ExeptionTracker.HealableCharacter(healer);
((Cleric)healer).Heal(receiver);
return($"{healer.Name} heals {receiver.Name} for {healer.AbilityPoints}!" +
$" {receiver.Name} has {receiver.Health} health now!");
}
public int SendVehicleTo(int garageSlot, Storage deliveryLocation)
{
ExeptionTracker.IsValidGarageSlot(garageSlot, this);
ExeptionTracker.IsVehicleInside(this.garage[garageSlot]);
var vehicle = this.garage[garageSlot];
for (int i = 0; i < deliveryLocation.garage.Length; i++)
{
if (deliveryLocation.garage[i] == null)
{
deliveryLocation.garage[i] = vehicle;
this.garage[garageSlot] = null;
return(i);
}
}
throw new InvalidOperationException(ExeptionTracker.NoRoomInGarage());
}
public void AddItem(Item item)
{
ExeptionTracker.IsBagCapacityFull(this, item);
listItems.Add(item);
}
public void ReceiveItem(Item item)
{
ExeptionTracker.IsAlive(this);
this.Bag.AddItem(item);
}
public void GiveCharacterItem(Item item, Character character)
{
ExeptionTracker.IsAlive(this, character);
character.Bag.AddItem(item);
}
public void UseItemOn(Item item, Character character)
{
ExeptionTracker.IsAlive(this, character);
item.AffectCharacter(character);
}
public void UseItem(Item item)
{
ExeptionTracker.IsAlive(this);
item.AffectCharacter(this);
}
public virtual void AffectCharacter(Character character)
{
ExeptionTracker.IsAlive(character);
}