public void When_TotalWeightCall_Should_ReturnTotalWeigh()
{
IPart part = new ShellPart("Cannon-KA2", 300, 500, 450);
vehicle.AddShellPart(part);
Assert.That(vehicle.TotalWeight, Is.EqualTo(400));
}
public void CheckOverrideToString()
{
string model = "Rhino-CE";
double weight = 12;
decimal price = 19;
int attack = 80;
int defense = 11;
int hitPoints = 3;
IAssembler assembler = new VehicleAssembler();
BaseVehicle testVehicle = new Revenger(model, weight, price, attack, defense, hitPoints, assembler);
IPart arsenalPart = new ArsenalPart("arse1", 1, 1, 2);
testVehicle.AddArsenalPart(arsenalPart);
IPart shellPart = new ShellPart("hel1", 6, 1, 8);
testVehicle.AddShellPart(shellPart);
IPart endurancePart = new EndurancePart("end1", 1, 3, 2);
testVehicle.AddEndurancePart(endurancePart);
string expectedMessage = "Revenger - Rhino-CE\r\nTotal Weight: 20.000\r\nTotal Price: 24.000\r\nAttack: 82\r\nDefense: 19\r\nHitPoints: 5\r\nParts: arse1, hel1, end1";
string actualMessage = testVehicle.ToString();
Assert.AreEqual(expectedMessage, actualMessage);
}
protected override bool DistanceCheck(Transform targetEntity)
{
var parts = targetEntity.GetComponentsInChildren <ShellPart>();
if (parts.Length == 0)
{
return(base.DistanceCheck(targetEntity));
}
else
{
float closestD = range;
nextTargetPart = null;
foreach (var part in parts)
{
var distance = Vector2.Distance(part.transform.position, transform.position);
if (distance < closestD)
{
closestD = distance;
nextTargetPart = part;
}
}
return(nextTargetPart);
}
}
public void TestMethods()
{
// All Valid
var vehicle = new Vanguard("SA-203", 100, 300, 1000, 450, 2000, new VehicleAssembler());
var arsenalPart = new ArsenalPart("Arsenal", 100, 300, 1000);
var shellPart = new ShellPart("Shell", 100, 300, 1000);
var shellTwoPart = new ShellPart("Shell2", 100, 300, 1000);
var endurancePart = new EndurancePart("Endurance", 100, 300, 1000);
// Test If AddArsenalPart adds new part
vehicle.AddArsenalPart(arsenalPart);
// Test If AddShellPart adds new part
vehicle.AddShellPart(shellPart);
vehicle.AddShellPart(shellTwoPart);
// Test if AddEndurancePart adds new part
vehicle.AddEndurancePart(endurancePart);
var partsList = (List <IPart>)vehicle.Parts;
string[] modelsList = new string[] { "Arsenal", "Shell", "Shell2", "Endurance" };
var typesList = new string[] { "ArsenalPart", "ShellPart", "ShellPart", "EndurancePart" };
for (int index = 0; index < partsList.Count; index++)
{
Assert.AreEqual(partsList[index].Model, modelsList[index]);
Assert.AreEqual(partsList[index].GetType().Name, typesList[index], "Incorrect part type!");
}
}
public string AddPart(IList <string> arguments)
{
string vehicleModel = arguments[0];
string partType = arguments[1];
string model = arguments[2];
double weight = double.Parse(arguments[3]);
decimal price = decimal.Parse(arguments[4]);
int additionalParameter = int.Parse(arguments[5]);
IPart part = null;
switch (partType)
{
case "Arsenal":
part = new ArsenalPart(model, weight, price, additionalParameter);
this.vehicles[vehicleModel].AddArsenalPart(part);
break;
case "Shell":
var shellPart = new ShellPart();
this.vehicles[vehicleModel].AddShellPart(part);
break;
case "Endurance":
part = new EndurancePart(model, weight, price, additionalParameter);
this.vehicles[vehicleModel].AddEndurancePart(part);
break;
}
return(string.Format(
GlobalConstants.PartSuccessMessage,
partType,
part.Model,
vehicleModel));
}
public void ValidateCalculatedProperty()
{
IVehicle vehicle = new Vanguard("SA-203", 100.00, 300m, 1000, 450, 2000, new VehicleAssembler());
IPart arsenalPart = new ArsenalPart("Cannon-KA2", 300, 500, 450);
IPart shellPart = new ShellPart("Shields-PI1", 200, 1000, 750);
IPart endurancePart = new EndurancePart("endurance", 200, 1000, 750);
double actualResultTotalWeight = 100;
Assert.AreEqual(actualResultTotalWeight, vehicle.TotalWeight);
decimal actualResultTotalPrice = 300;
Assert.AreEqual(actualResultTotalPrice, vehicle.TotalPrice);
long actualResultTotalAttack = 1000;
Assert.AreEqual(actualResultTotalAttack, vehicle.TotalAttack);
long actualResultTotalDefense = 450;
Assert.AreEqual(actualResultTotalDefense, vehicle.TotalDefense);
long actualResultTotalHitPoints = 2000;
Assert.AreEqual(actualResultTotalHitPoints, vehicle.TotalHitPoints);
}
public void BaseVehicleTest()
{
IAssembler assembler = new VehicleAssembler();
IVehicle vanguard = new Vanguard("Vanguard1", 500, 1000, 500, 500, 1000, assembler);
IPart arsenalPart = new ArsenalPart("Arsenal1", 100, 100, 100);
IPart shellPart = new ShellPart("Shell1", 100, 100, 100);
IPart endurancePart = new EndurancePart("Endurance1", 100, 100, 100);
vanguard.AddArsenalPart(arsenalPart);
vanguard.AddEndurancePart(endurancePart);
vanguard.AddShellPart(shellPart);
double totalWeight = vanguard.TotalWeight;
decimal totalPrice = vanguard.TotalPrice;
long totalAttack = vanguard.TotalAttack;
long totalDefense = vanguard.TotalDefense;
long totalHitPoints = vanguard.TotalHitPoints;
Assert.That(totalWeight, Is.EqualTo(800).NoClip);
Assert.That(totalPrice, Is.EqualTo(1300).NoClip);
Assert.That(totalAttack, Is.EqualTo(600).NoClip);
Assert.That(totalDefense, Is.EqualTo(600).NoClip);
Assert.That(totalHitPoints, Is.EqualTo(1100).NoClip);
string expectedResult = "Vanguard - Vanguard1\r\nTotal Weight: 800.000\r\nTotal Price: 1300.000\r\nAttack: 600\r\nDefense: 600\r\nHitPoints: 1100\r\nParts: Arsenal1, Endurance1, Shell1";
string actualResult = vanguard.ToString();
Assert.That(expectedResult, Is.EqualTo(actualResult).NoClip);
}
public void TestVehicleStatistices()
{
//Shell part effects on vehicle's weight, price and defense;
IPart shellPart = new ShellPart("Shell3", 100, 100, 100);
vehcleForStatistics.AddShellPart(shellPart);
string actual = vehcleForStatistics.ToString();
string expected = "Vanguard - Statistical\r\nTotal Weight: 200.000\r\n" +
"Total Price: 200.000\r\nAttack: 100\r\nDefense: 200\r\n" +
"HitPoints: 100\r\nParts: Shell3";
Assert.AreEqual(expected, actual);
//Shell part effects on vehicle's weight, price and attack;
IPart arsenalPart = new ArsenalPart("Ars", 100, 100, 100);
vehcleForStatistics.AddArsenalPart(arsenalPart);
actual = vehcleForStatistics.ToString();
expected = "Vanguard - Statistical\r\nTotal Weight: 300.000\r\n" +
"Total Price: 300.000\r\nAttack: 200\r\nDefense: 200\r\n" +
"HitPoints: 100\r\nParts: Shell3, Ars";
Assert.AreEqual(expected, actual);
//Endurance part effects on vehicle's weight, price and hitpoints;
IPart endurancePart = new EndurancePart("Endur", 100, 100, 100);
vehcleForStatistics.AddEndurancePart(endurancePart);
actual = vehcleForStatistics.ToString();
expected = "Vanguard - Statistical\r\nTotal Weight: 400.000\r\n" +
"Total Price: 400.000\r\nAttack: 200\r\nDefense: 200\r\n" +
"HitPoints: 200\r\nParts: Shell3, Ars, Endur";
Assert.AreEqual(expected, actual);
}
void OnTriggerEnter2D(Collider2D collision)
{
//TODO: Make this collision avoid hitting the core collider which may mess up the part damage calculation a bit (for missiles as well)
var hit = collision.transform.root; // grab collision, get the topmost GameObject of the hierarchy, which would have the craft component
var craft = hit.GetComponent <IDamageable>(); // check if it has a craft component
if (craft != null && !craft.GetIsDead() && owner) // check if the component was obtained
{
if (!FactionManager.IsAllied(faction, craft.GetFaction()) && CheckCategoryCompatibility(craft) && craft.GetTransform() != owner.GetTransform())
{
var residue = craft.TakeShellDamage(damage, pierceFactor, owner); // deal the damage to the target, no shell penetration
// if the shell is low, damage the part
ShellPart part = collision.transform.GetComponent <ShellPart>();
if (part)
{
part.TakeDamage(residue); // damage the part
}
damage = 0; // make sure, that other collision events with the same bullet don't do any more damage
Instantiate(hitPrefab, transform.position, Quaternion.identity);
Destroy(gameObject); // bullet has collided with a target, delete immediately
}
}
}
private void Domino(ShellPart part)
{
if (part.parent)
{
part.parent.children.Remove(part);
}
DominoHelper(part);
}
public void ShouldAddShellPart()
{
IPart shellPart = new ShellPart(partModel, partWeight, partPrice, attackMod);
IVehicle vehicle = new Vanguard(model, weight, price, attack, defense, hitPoints, assembler);
vehicle.AddShellPart(shellPart);
Assert.That(vehicle.TotalDefense > defense);
}
private void DominoHelper(ShellPart parent)
{
foreach (ShellPart part in parent.children.ToArray())
{
if (part)
{
RemovePart(part);
}
}
}
public override void RemovePart(ShellPart part)
{
if (part)
{
if (part.gameObject.name != "Shell Sprite")
{
Destroy(part.gameObject);
}
}
}
public void Init(WeaponTargetingSystem targetingSystem, Entity core, float range, ShellPart part, int tier)
{
this.targetingSystem = targetingSystem;
this.Core = core;
initialized = true;
this.range = range;
this.part = part;
this.tier = tier;
energyCost = energyC / tier;
}
public void CheckAddShellPartToAssembler()
{
assembler = new VehicleAssembler();
IDefenseModifyingPart shellPart = new ShellPart("shellModel", 10, 2000m, 700);
orderedParts = new List <string>();
this.assembler.AddShellPart(shellPart);
this.orderedParts.Add(shellPart.Model);
Assert.That(orderedParts.Count == 1);
Assert.That(assembler.ShellParts.Count == 1);
}
public void AddShellPartShouldAddThePartToAssembler()
{
//Arrange
var part = new ShellPart("part", 10, 10, 10);
IAssembler assembler = new VehicleAssembler();
IVehicle vehicle = new Revenger("revenger", 10, 10, 10, 10, 10, assembler);
//Action
vehicle.AddShellPart(part);
bool assemblerHasPart = assembler.ShellParts.Any(ap => ap.Equals(part));
//Assert
Assert.AreEqual(true, assemblerHasPart);
}
public void TotalDefenseShouldReturnCorrectValue()
{
var part = new ShellPart("model", 10, 10, 100);
IAssembler assembler = new VehicleAssembler();
assembler.AddShellPart(part);
IVehicle v = new Revenger("revenger", 10, 10, 10, 10, 10, assembler);
var expectedVehicleTotal = v.Defense + assembler.TotalDefenseModification;
var actualVehicleTotal = v.TotalDefense;
Assert.AreEqual(expectedVehicleTotal, actualVehicleTotal);
}
public void AddShellPart_ShouldAddPartCorrectly(string model,
double weight, decimal price, int attack, int defense, int hitPoints)
{
var vehicle = new Revenger(model, weight, price, attack, defense,
hitPoints, new VehicleAssembler());
IPart shellPart = new ShellPart(model, weight, price, 10);
vehicle.AddShellPart(shellPart);
var expected = 1;
var actual = vehicle.Parts.Count();
Assert.AreEqual(expected, actual);
}
public void CheckToString()
{
IVehicle vehicle = new Revenger("asd", 1, 3, 1, 3, 4, new VehicleAssembler());
var arsenal = new ArsenalPart("asd", 12, 3, 4);
var endurance = new EndurancePart("asd", 3, 3, 4);
var shell = new ShellPart("asd", 3, 3, 4);
vehicle.AddEndurancePart(endurance);
vehicle.AddArsenalPart(arsenal);
vehicle.AddShellPart(shell);
Assert.That(vehicle.Parts, Has.Member(arsenal));
Assert.That(vehicle.Parts, Has.Member(endurance));
Assert.That(vehicle.Parts, Has.Member(shell));
}
public void CheckIfReturnCorrectResult()
{
var assembler = new VehicleAssembler();
var tank = new Vanguard("SA - 203", 100, 300, 1000, 450, 2000, assembler);
var tank2 = new Revenger("AKU", 1000, 1000, 1000, 1000, 1000, assembler);
var part1 = new ArsenalPart("Cannon - KA2", 300, 500, 450);
var part2 = new ShellPart("Shields - PI1", 200, 1000, 750);
var expectedResult = tank.ToString();
var actualResult = "Vanguard - SA - 203\r\nTotal Weight: 100.000\r\nTotal Price: 300.000\r\nAttack: 1000\r\nDefense: 450\r\nHitPoints: 2000\r\nParts: None";
Assert.AreEqual(expectedResult, actualResult);
}
public void TestBaseVehicleClassReturnsCorrectOutput()
{
//Vehicle Vanguard SA-203 100 300 1000 450 2000
var assembler = new VehicleAssembler();
var vehicle = new Vanguard("SA-203", 100, 300, 1000, 450, 2000, assembler);
var part = new ShellPart("SA-203", 300, 100, 2);
vehicle.AddShellPart(part);
var actualResult = vehicle.ToString();
var expectedResult = "Vanguard - SA-203\r\nTotal Weight: 400.000\r\nTotal Price: 400.000\r\nAttack: 1000\r\nDefense: 452\r\nHitPoints: 2000\r\nParts: SA-203";
Assert.That(actualResult, Is.EqualTo(expectedResult));
}
public string AddPart(IList <string> arguments)
{
string vehicleModel = arguments[0];
string partType = arguments[1] + "Part";
string model = arguments[2];
double weight = double.Parse(arguments[3]);
decimal price = decimal.Parse(arguments[4]);
int additionalParameter = int.Parse(arguments[5]);
IPart part = null;
part = this.partFactory.CreatePart(partType, model, weight, price, additionalParameter);
//string partToMethod = "Add" + partType + "Part";
//var type = typeof(VehicleAssembler);
//var instance = Activator.CreateInstance(type, true);
//var methodI = type.GetMethods().FirstOrDefault(m => m.Name == partToMethod);
//var invoke = methodI.Invoke(vehicles[vehicleModel]., new object[] { part });
//this.vehicles[vehicleModel].AddShellPart(part);
switch (partType)
{
case "ArsenalPart":
part = new ArsenalPart(model, weight, price, additionalParameter);
this.vehicles[vehicleModel].AddArsenalPart(part);
this.parts.Add(model, part);
break;
case "ShellPart":
part = new ShellPart(model, weight, price, additionalParameter);
this.vehicles[vehicleModel].AddShellPart(part);
this.parts.Add(model, part);
break;
case "EndurancePart":
part = new EndurancePart(model, weight, price, additionalParameter);
this.vehicles[vehicleModel].AddEndurancePart(part);
this.parts.Add(model, part);
break;
}
return(string.Format(
GlobalConstants.PartSuccessMessage,
partType,
part.Model,
vehicleModel));
}
public void Test1()
{
ArsenalPart arsenalPart = new ArsenalPart("model", 0.5, 2.555m, 20);
ShellPart shellPart = new ShellPart("shell", 2, 3, 5);
EndurancePart endurancePart = new EndurancePart("hp", 2, 3, 6);
Vanguard vanguardVehicle = new Vanguard("moodle", 4, 5, 100, 100, 100, new VehicleAssembler());
vanguardVehicle.AddArsenalPart(arsenalPart);
vanguardVehicle.AddShellPart(shellPart);
vanguardVehicle.AddEndurancePart(endurancePart);
string expected = vanguardVehicle.ToString();
string actual = "Vanguard - moodle\r\nTotal Weight: 8.500\r\nTotal Price: 13.555\r\nAttack: 120\r\nDefense: 105\r\nHitPoints: 106\r\nParts: model, shell, hp";
Assert.AreEqual(expected, actual);
}
public void DoesTotalDefenseSumIsCorrest()
{
string model = "aaa";
double weight = 1;
decimal price = 1;
int attack = 1;
int defense = 1;
int hitpoint = 1;
var assembler = new VehicleAssembler();
var revenger = new Revenger(model, weight, price, attack, defense, hitpoint, assembler);
var shellpart = new ShellPart("aaa", 1, 1, 100);
revenger.AddShellPart(shellpart);
Assert.AreEqual(101, revenger.TotalDefense);
}
public virtual void RemovePart(ShellPart part)
{
if (part.GetComponent <Ability>())
{
part.GetComponent <Ability>().SetDestroyed(true);
}
entityBody.mass -= part.partMass;
weight -= part.partMass * weightMultiplier;
if (this as Craft)
{
(this as Craft).CalculatePhysicsConstants();
}
Domino(part);
part.Detach();
parts.Remove(part);
}
public void CheckAddingItemsAndModifiengProperties()
{
string model = "Rhino-CE";
double weight = 10;
decimal price = 10m;
int attack = 10;
int defense = 10;
int hitPoints = 10;
IAssembler assembler = new VehicleAssembler();
BaseVehicle testVehicle = new Revenger(model, weight, price, attack, defense, hitPoints, assembler);
IPart arsenalPart = new ArsenalPart("shel1", 1, 1, 2);
testVehicle.AddArsenalPart(arsenalPart);
Assert.That(testVehicle.Parts.Count() == 1 && testVehicle.Parts.Contains(arsenalPart), "Arsenal part not added properly");
IPart shellPart = new ShellPart("shel1", 1, 1, 2);
testVehicle.AddShellPart(shellPart);
Assert.That(testVehicle.Parts.Count() == 2 && testVehicle.Parts.Contains(shellPart), "Shell part not added properly");
IPart endurancePart = new EndurancePart("shel1", 1, 1, 2);
testVehicle.AddEndurancePart(endurancePart);
Assert.That(testVehicle.Parts.Count() == 3 && testVehicle.Parts.Contains(endurancePart), "Endurance part not added properly");
double TotalWeightExpected = 3 + 10;
Assert.AreEqual(TotalWeightExpected, testVehicle.TotalWeight);
decimal TotalPriceExpected = 3 + 10;
Assert.AreEqual(TotalPriceExpected, testVehicle.TotalPrice);
long TotalAttackExpected = 10 + 2;
Assert.AreEqual(TotalAttackExpected, testVehicle.TotalAttack);
long TotalDefenseExpected = 10 + 2;
Assert.AreEqual(TotalDefenseExpected, testVehicle.TotalDefense);
long TotalHitPointsExpected = 10 + 2;
Assert.AreEqual(TotalHitPointsExpected, testVehicle.TotalHitPoints);
}
public void ValidateAddArsenal()
{
IVehicle vehicle = new Vanguard("SA-203", 100.00, 300m, 1000, 450, 2000, new VehicleAssembler());
IPart arsenalPart = new ArsenalPart("Cannon-KA2", 300, 500, 450);
IPart shellPart = new ShellPart("Shields-PI1", 200, 1000, 750);
IPart endurancePart = new EndurancePart("endurance", 200, 1000, 750);
vehicle.AddArsenalPart(arsenalPart);
vehicle.AddShellPart(shellPart);
vehicle.AddEndurancePart(endurancePart);
Assert.That(vehicle.Parts.ToList().Count == 3);
}
public void TestAddPartCorrectly()
{
IAssembler assembler = new VehicleAssembler();
Revenger revenger = new Revenger("Test", 100, 100, 100, 100, 100, assembler);
ArsenalPart arsenalPart = new ArsenalPart("Arsenal", 23, 50, 5);
EndurancePart endurancePart = new EndurancePart("Endurance", 23, 50, 5);
ShellPart shellPart = new ShellPart("Shell", 23, 50, 5);
Assert.DoesNotThrow(() => revenger.AddArsenalPart(arsenalPart));
Assert.DoesNotThrow(() => revenger.AddEndurancePart(endurancePart));
Assert.DoesNotThrow(() => revenger.AddShellPart(shellPart));
string actualResult = revenger.ToString();
string expectedResult = "Revenger - Test\r\nTotal Weight: 169.000\r\nTotal Price: 250.000\r\nAttack: 105\r\nDefense: 105\r\nHitPoints: 105\r\nParts: Arsenal, Endurance, Shell";
Assert.AreEqual(actualResult, expectedResult);
}
public void AddShellPartShouldAddThePartToOrderedParts()
{
//Arrange
IPart part = new ShellPart("part", 10, 10, 10);
IAssembler assembler = new VehicleAssembler();
IVehicle vehicle = new Revenger("revenger", 10, 10, 10, 10, 10, assembler);
//Action
vehicle.AddShellPart(part);
FieldInfo orderedPartsField = vehicle.GetType().BaseType.GetField("orderedParts", BindingFlags.NonPublic | BindingFlags.Instance);
List <string> orderedParts = (List <string>)orderedPartsField.GetValue(vehicle);
//Assert
Assert.AreEqual(true, orderedParts[0] == part.Model);
}
public void PartsPropertyShouldReturnAllElements()
{
BasePart[] parts = new BasePart[3];
parts[0] = new ArsenalPart("ModelA", 150, 500, 100);
parts[1] = new ShellPart("ModelS", 250, 250, 100);
parts[2] = new EndurancePart("ModelE", 200, 250, 100);
vehicle.AddArsenalPart(parts[0]);
vehicle.AddShellPart(parts[1]);
vehicle.AddEndurancePart(parts[2]);
int index = 0;
foreach (var part in vehicle.Parts)
{
Assert.AreSame(part, parts[index++]);
}
}
