static void evaluateWeaponAttackOnVehicle(float expectedDamage, Weapon w, ref DamageExpectationRecord damageExpectationRecord, Vector3 attackerPosition, Vehicle targetVehicle, Vector3 targetPosition, Quaternion targetRotation)
{
// use hit table to figure out where this will go
Dictionary <VehicleChassisLocations, float> locations = GetLocationDictionary(attackerPosition, targetVehicle, targetPosition, targetRotation);
foreach (KeyValuePair <VehicleChassisLocations, float> locKVP in locations)
{
VehicleChassisLocations loc = locKVP.Key;
float probability = locKVP.Value;
DamageExpectationRecord locRecord = new DamageExpectationRecord();
damageExpectationRecord.AddChildRecord(probability, locRecord);
float existingArmor = targetVehicle.ArmorForLocation((int)loc);
float armorThatWillBeRemoved = Mathf.Min(existingArmor, expectedDamage);
float damageRemaining = expectedDamage - existingArmor;
locRecord.AddVehicleArmorDamage(armorThatWillBeRemoved, loc);
if (damageRemaining > 0)
{
// some goes in to the structure
float currentStructure = targetVehicle.GetCurrentStructure(loc);
float structureDamage = Mathf.Min(damageRemaining, currentStructure);
//float damageAfterStructure = damageRemaining - structureDamage;
locRecord.AddVehicleStructureDamage(structureDamage, loc);
}
}
}
static void evaluateWeaponAttackOnMech(float expectedDamage, Weapon w, ref DamageExpectationRecord damageExpectationRecord, Vector3 attackerPosition, Mech targetMech, Vector3 targetPosition, Quaternion targetRotation)
{
// use hit table to figure out where this will go
Dictionary <ArmorLocation, float> locations = GetLocationDictionary(attackerPosition, targetMech, targetPosition, targetRotation);
foreach (KeyValuePair <ArmorLocation, float> locKVP in locations)
{
ArmorLocation loc = locKVP.Key;
float probability = locKVP.Value;
DamageExpectationRecord locRecord = new DamageExpectationRecord();
damageExpectationRecord.AddChildRecord(probability, locRecord);
float existingArmor = targetMech.ArmorForLocation((int)loc);
float armorThatWillBeRemoved = Mathf.Min(existingArmor, expectedDamage);
float damageRemaining = expectedDamage - existingArmor;
locRecord.AddArmorDamage(armorThatWillBeRemoved, loc);
ChassisLocations sLoc = MechStructureRules.GetChassisLocationFromArmorLocation((ArmorLocation)loc);
// there's a chance this hit will be a critical hit
if (!targetMech.IsLocationDestroyed(sLoc))
{
float critChance = targetMech.Combat.CritChance.GetCritChance(targetMech, sLoc, w);
if (critChance > 0)
{
DamageExpectationRecord critRecord = new DamageExpectationRecord();
locRecord.AddChildRecord(critChance, critRecord);
// iterate over components, apply one point of damage to each location.
Dictionary <ComponentLocator, float> componentDict = getComponentDictionary(targetMech, sLoc);
float probOfHittingAmmo = 0.0f;
foreach (KeyValuePair <ComponentLocator, float> componentKVP in componentDict)
{
ComponentLocator compLoc = componentKVP.Key;
MechComponent component = compLoc.GetComponent();
float componentProbability = componentKVP.Value;
DamageExpectationRecord componentRecord = new DamageExpectationRecord();
critRecord.AddChildRecord(componentProbability, componentRecord);
componentRecord.AddComponentDamage(1.0f, compLoc);
// if this component is ammo, there's a chance we could lose this location and all child locations
if (component.componentType == ComponentType.AmmunitionBox)
{
AmmunitionBox abComponent = component as AmmunitionBox;
int remainingAmmo = abComponent.CurrentAmmo;
int capacity = abComponent.ammunitionBoxDef.Capacity;
float percentage = ((float)remainingAmmo) / ((float)capacity);
if (percentage > 0.5f)
{
probOfHittingAmmo += componentProbability;
}
}
}
if (probOfHittingAmmo > 0.0f)
{
DamageExpectationRecord ammoBlownRecord = new DamageExpectationRecord();
locRecord.AddChildRecord(probOfHittingAmmo, ammoBlownRecord);
foreach (KeyValuePair <ComponentLocator, float> componentKVP in componentDict)
{
ComponentLocator compLoc = componentKVP.Key;
ammoBlownRecord.AddComponentDamage(2.0f, compLoc);
}
}
}
}
if (damageRemaining > 0)
{
// some goes in to the structure
float currentStructure = targetMech.GetCurrentStructure(sLoc);
float structureDamage = Mathf.Min(damageRemaining, currentStructure);
float damageAfterStructure = damageRemaining - structureDamage;
locRecord.AddStructureDamage(structureDamage, sLoc);
if (damageAfterStructure > 0)
{
// some hits a component
Dictionary <ComponentLocator, float> componentDict = getComponentDictionary(targetMech, sLoc);
float probOfHittingAmmo = 0.0f;
foreach (KeyValuePair <ComponentLocator, float> componentKVP in componentDict)
{
ComponentLocator compLoc = componentKVP.Key;
MechComponent component = compLoc.GetComponent();
float componentProbability = componentKVP.Value;
DamageExpectationRecord componentRecord = new DamageExpectationRecord();
locRecord.AddChildRecord(componentProbability, componentRecord);
componentRecord.AddComponentDamage(1.0f, compLoc);
// if this component is ammo, there's a chance we could lose this location and all child locations
if (component.componentType == ComponentType.AmmunitionBox)
{
AmmunitionBox abComponent = component as AmmunitionBox;
int remainingAmmo = abComponent.CurrentAmmo;
int capacity = abComponent.ammunitionBoxDef.Capacity;
float percentage = ((float)remainingAmmo) / ((float)capacity);
if (percentage > 0.5f)
{
probOfHittingAmmo += componentProbability;
}
}
}
if (probOfHittingAmmo > 0)
{
DamageExpectationRecord ammoBlownRecord = new DamageExpectationRecord();
locRecord.AddChildRecord(probOfHittingAmmo, ammoBlownRecord);
foreach (KeyValuePair <ComponentLocator, float> componentKVP in componentDict)
{
ComponentLocator compLoc = componentKVP.Key;
ammoBlownRecord.AddComponentDamage(2.0f, compLoc);
}
}
}
}
}
}
static public DamageExpectationRecord EvaluateAttack(AbstractActor attacker, Vector3 attackerPosition, ICombatant target, Vector3 targetPosition, Quaternion targetRotation, List <Weapon> weapons, MeleeAttackType attackType)
{
// for all weapons in an attack
// figure out the locations that are likely to be hit
// use HitTable to figure this out
// for each location, figure out the chance to
// - do criticals (without breaching armor?)
// - breach armor
// - do structural damage
// - do component damage (weapons get damaged, then destroyed)
// - trigger ammo explosion
// - lose the location
// - lose sub-locations
// - kill the mech
// types.cs ConsolidateCriticalHitInfo
// Mech.cs CheckForCrit
// CombatCritChance GetCritChance
DamageExpectationRecord root = new DamageExpectationRecord();
for (int weaponIndex = 0; weaponIndex < weapons.Count; ++weaponIndex)
{
Weapon w = weapons[weaponIndex];
// figure out chance to hit the target
AbstractActor targetActor = target as AbstractActor;
bool targetIsEvasive = (targetActor != null) && (targetActor.IsEvasive);
float toHitProbability = w.GetToHitFromPosition(target, 1, attackerPosition, targetPosition, true, targetIsEvasive);
DamageExpectationRecord weaponDamageExpectationRecord = new DamageExpectationRecord();
root.AddChildRecord(toHitProbability, weaponDamageExpectationRecord);
float expectedDamage = w.ShotsWhenFired * w.DamagePerShotFromPosition(attackType, attackerPosition, target);
Mech targetMech = target as Mech;
Vehicle targetVehicle = target as Vehicle;
Turret targetTurret = target as Turret;
Building targetBuilding = target as Building;
if (targetMech != null)
{
evaluateWeaponAttackOnMech(expectedDamage, w, ref weaponDamageExpectationRecord, attackerPosition, targetMech, targetPosition, targetRotation);
}
else if (targetVehicle != null)
{
evaluateWeaponAttackOnVehicle(expectedDamage, w, ref weaponDamageExpectationRecord, attackerPosition, targetVehicle, targetPosition, targetRotation);
}
else if (targetTurret != null)
{
evaluateWeaponAttackOnTurret(expectedDamage, w, ref weaponDamageExpectationRecord, attackerPosition, targetTurret, targetPosition, targetRotation);
}
else if (targetBuilding != null)
{
evaluateWeaponAttackOnBuilding(expectedDamage, w, ref weaponDamageExpectationRecord, attackerPosition, targetBuilding, targetPosition, targetRotation);
}
}
consolidateDamageExpectationRecord(ref root, target);
return(root);
}
