/// <summary>
/// Gets the result of a ContactType on a set of PhysicalAttributes
/// </summary>
/// <param name="attacker">The BattleEntity performing the attack</param>
/// <param name="contactType">The ContactType performed</param>
/// <param name="physAttributes">The set of PhysicalAttributes to test against</param>
/// <param name="attributesToIgnore">A set of PhysicalAttributes to ignore</param>
/// <returns>A ContactResultInfo of the interaction</returns>
public static ContactResultInfo GetContactResult(BattleEntity attacker, ContactTypes contactType, PhysicalAttributes[] physAttributes, params PhysicalAttributes[] attributesToIgnore)
{
//Return the default value
if (ContactTable.ContainsKey(contactType) == false || physAttributes == null)
{
Debug.LogWarning($"{nameof(physAttributes)} array is null or {nameof(ContactTable)} does not contain the ContactType {contactType}!");
return(ContactResultInfo.Default);
}
//Look through the attributes and find the first match
for (int i = 0; i < physAttributes.Length; i++)
{
Dictionary <PhysicalAttributes, ContactResultInfo> tableForContact = ContactTable[contactType];
PhysicalAttributes attribute = physAttributes[i];
//If this attribute is ignored, move onto the next
if (attributesToIgnore?.Contains(attribute) == true)
{
continue;
}
if (tableForContact.ContainsKey(attribute) == true)
{
ContactResultInfo contactResult = tableForContact[attribute];
//If the ContactResult is a Success if the entity has the same PhysicalAttribute as the one tested, set its result to Success
if (contactResult.SuccessIfSameAttr == true && attacker.EntityProperties.HasPhysAttributes(true, attribute) == true)
{
contactResult.ContactResult = ContactResult.Success;
}
return(contactResult);
}
}
return(ContactResultInfo.Default);
}
public InteractionResult Calculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
StepResult = new InteractionResult(curResult);
StepContactResultInfo = curContactResult;
OnCalculate(damageInfo, curResult, curContactResult);
return(StepResult);
}
/// <summary>
/// Determines the result of contact, based on the type of contact made, when it's made with this entity.
/// <para>Contacts that aren't a Success are prioritized over any Payback.
/// If a ContactResult of Success is found, then the Payback for this entity is added if it exists
/// and the ContactResult becomes a PartialSuccess.</para>
/// </summary>
/// <param name="attacker">The entity attacking this one</param>
/// <param name="contactType">The type of contact made with this entity</param>
/// <returns>A ContactResultInfo containing the result of the interaction</returns>
public ContactResultInfo GetContactResult(BattleEntity attacker, ContactTypes contactType)
{
ContactResultInfo contactResultInfo = Interactions.GetContactResult(attacker, contactType, GetAllPhysAttributes(), attacker.EntityProperties.GetContactExceptions(contactType));
//On a Success, check if this Entity has any Payback and add it if so
if ((contactResultInfo.ContactResult == ContactResult.Success || contactResultInfo.ContactResult == ContactResult.PartialSuccess) && HasPayback() == true)
{
PaybackHolder paybackholder;
//Factor in the contact's Payback on a PartialSuccess
if (contactResultInfo.ContactResult == ContactResult.PartialSuccess)
{
paybackholder = GetPayback(contactResultInfo.Paybackholder);
}
//Get only the BattleEntity's Payback on a Success
else
{
paybackholder = GetPayback();
}
//Since there's Payback, the result is now a PartialSuccess
contactResultInfo.ContactResult = ContactResult.PartialSuccess;
contactResultInfo.Paybackholder = paybackholder;
}
return(contactResultInfo);
}
/// <summary>
/// Calculates and returns the entire damage interaction between two BattleEntities.
/// <para>This returns all the necessary information for both BattleEntities, including the total amount of damage dealt,
/// the type of Elemental damage to deal, the Status Effects to inflict, and whether the attack successfully hit or not.</para>
/// </summary>
/// <param name="interactionParam">An InteractionParamHolder containing the BattleEntities interacting and data about their interaction.</param>
/// <returns>An InteractionResult containing InteractionHolders for both the victim and the attacker.</returns>
public static InteractionResult GetDamageInteraction(InteractionParamHolder interactionParam)
{
InteractionResult finalInteraction = new InteractionResult();
ContactResultInfo contactResultInfo = new ContactResultInfo();
for (int i = 0; i < DamageCalculationSteps.Count; i++)
{
finalInteraction = DamageCalculationSteps[i].Calculate(interactionParam, finalInteraction, contactResultInfo);
contactResultInfo = DamageCalculationSteps[i].StepContactResultInfo;
}
return(finalInteraction);
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
//Factor in Double Pain for the Victim
int doublePainCount = StepResult.VictimResult.Entity.GetEquippedBadgeCount(BadgeGlobals.BadgeTypes.DoublePain);
StepResult.VictimResult.TotalDamage *= (1 + doublePainCount);
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
//If the attack didn't hit, don't factor in DamageEffects
if (StepResult.VictimResult.Hit == false)
{
StepResult.VictimResult.DamageEffect = DamageEffects.None;
}
//If the current result has no DamageEffects (whether the move didn't have any or a Defensive Action removed them)
//or if the BattleEntity isn't vulnerable to any DamageEffects, then don't bother doing anything else
if (StepResult.VictimResult.DamageEffect == DamageEffects.None ||
StepResult.VictimResult.Entity.EntityProperties.HasDamageEffectVulnerabilities() == false)
{
return;
}
//The DamageEffects stored in the result
DamageEffects resultEffects = DamageEffects.None;
//Get all the DamageEffects
DamageEffects[] damageEffects = UtilityGlobals.GetEnumValues <DamageEffects>();
//Start at index 1, as 0 is the value of None indicating no DamageEffects
for (int i = 1; i < damageEffects.Length; i++)
{
DamageEffects curEffect = damageEffects[i];
//If the move has the DamageEffect and the entity is affected by it, add it to the result
//This approach is easier and more readable than removing effects
if (UtilityGlobals.EnumHasFlag(StepResult.VictimResult.DamageEffect, curEffect) == true &&
StepResult.VictimResult.Entity.EntityProperties.IsVulnerableToDamageEffect(curEffect) == true)
{
resultEffects |= curEffect;
}
}
//Set the result
StepResult.VictimResult.DamageEffect = resultEffects;
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
//Defense added from Damage Dodge Badges upon a successful Guard
int damageDodgeDefense = 0;
//Defensive actions take priority. If the attack didn't hit, don't check for defensive actions
BattleGlobals.DefensiveActionHolder?victimDefenseData = null;
if (StepResult.VictimResult.Hit == true)
{
victimDefenseData = StepResult.VictimResult.Entity.GetDefensiveActionResult(StepResult.VictimResult.TotalDamage,
StepResult.VictimResult.StatusesInflicted, StepResult.VictimResult.DamageEffect);
}
//A Defensive Action has been performed
if (victimDefenseData.HasValue == true)
{
StepResult.VictimResult.TotalDamage = victimDefenseData.Value.Damage;
StepResult.VictimResult.StatusesInflicted = victimDefenseData.Value.Statuses;
StepResult.VictimResult.DamageEffect = victimDefenseData.Value.DamageEffect;
//Store the damage dealt to the attacker, if any
if (victimDefenseData.Value.ElementHolder.HasValue == true)
{
ElementDamageHolder elementHolder = victimDefenseData.Value.ElementHolder.Value;
//If the Defensive action dealt damage and the contact was direct
//the Defensive action has caused a Failure for the Attacker (Ex. Superguarding)
if (StepResult.VictimResult.ContactType == ContactTypes.TopDirect ||
StepResult.VictimResult.ContactType == ContactTypes.SideDirect)
{
StepContactResultInfo.ContactResult = ContactResult.Failure;
//Use the damage from the Defensive Action
StepResult.AttackerResult.TotalDamage = elementHolder.Damage;
//Update the Paybackholder to use the Payback data from the Defensive Action
StepContactResultInfo.Paybackholder = new PaybackHolder(PaybackTypes.Constant, elementHolder.Element, elementHolder.Damage);
}
StepResult.AttackerResult.DamageElement = victimDefenseData.Value.ElementHolder.Value.Element;
}
//Factor in the additional Guard defense for all DefensiveActions (for now, at least)
//If it's not Piercing, this will be subtracted, in addition to the Victim's Defense, from the damage dealt to the Victim
damageDodgeDefense = StepResult.VictimResult.Entity.GetEquippedBadgeCount(BadgeGlobals.BadgeTypes.DamageDodge);
}
//Subtract Defense on non-piercing damage
if (StepResult.VictimResult.Piercing == false)
{
int totalDefense = StepResult.VictimResult.Entity.BattleStats.TotalDefense + damageDodgeDefense;
StepResult.VictimResult.TotalDamage -= totalDefense;
}
//Store the final unscaled damage in the Attacker's result if there was no Defensive Action payback, as it will use it later
if (victimDefenseData.HasValue == false || victimDefenseData.Value.ElementHolder.HasValue == false)
{
StepResult.AttackerResult.TotalDamage = StepResult.VictimResult.TotalDamage;
}
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
//If the move cannot miss, hit is set to true
if (damageInfo.CantMiss == true)
{
StepResult.VictimResult.Hit = true;
}
else
{
StepResult.VictimResult.Hit = StepResult.AttackerResult.Entity.AttemptHitEntity(StepResult.VictimResult.Entity);
}
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
//Check if the Attacker is Invincible. If so, ignore all damage and Status Effects
if (StepResult.AttackerResult.Entity.EntityProperties.GetAdditionalProperty <bool>(AdditionalProperty.Invincible) == true)
{
StepResult.AttackerResult.TotalDamage = 0;
StepResult.AttackerResult.ElementResult = ElementInteractionResult.Damage;
StepResult.AttackerResult.StatusesInflicted = null;
}
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
StepResult.AttackerResult.TotalDamage =
UtilityGlobals.Clamp(StepResult.AttackerResult.TotalDamage, BattleGlobals.MinDamage, BattleGlobals.MaxDamage);
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
Elements element = StepResult.VictimResult.DamageElement;
BattleEntity victim = StepResult.VictimResult.Entity;
//Retrieve an overridden type of Elemental damage to inflict based on the Victim's PhysicalAttributes
//(Ex. The Ice Power Badge only deals Ice damage to Fiery entities)
ElementOverrideHolder newElement = StepResult.AttackerResult.Entity.EntityProperties.GetTotalElementOverride(victim);
if (newElement.Element != Elements.Invalid)
{
/*NOTE: Idea for stacking weaknesses
* (Ex. 1 Ice Power is 1 weakness, Ice Power + Ice Smash = 2 weaknesses)
*
* Ex. damage = 2
* player inflicts ice 2 times: ice power & ice smash
*
* ice_inflicted_times = 2
* if (enemy weak to ice)
* damage += ice_inflicted_times
* end
*
#damage = 4
*/
//Add the number of element overrides to the damage if the element used already exists as an override and the victim has a Weakness
//to the Element. This allows Badges such as Ice Power to deal more damage if used in conjunction with attacks
//that deal the same type of damage (Ex. Ice Power and Ice Smash deal 2 additional damage total rather than 1).
//If any new knowledge is discovered to improve this, this will be changed
//Ice Power is the only Badge of its kind across the first two PM games that does anything like this
if (element == newElement.Element && victim.EntityProperties.HasWeakness(element) == true)
{
StepResult.VictimResult.TotalDamage += newElement.OverrideCount;
}
StepResult.VictimResult.DamageElement = newElement.Element;
}
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
BattleEntity victim = StepResult.VictimResult.Entity;
BattleEntity attacker = StepResult.AttackerResult.Entity;
//Get contact results
StepContactResultInfo = victim.EntityProperties.GetContactResult(attacker, StepResult.VictimResult.ContactType);
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
StepResult.AttackerResult.Entity = damageInfo.Attacker;
StepResult.VictimResult.Entity = damageInfo.Victim;
StepResult.VictimResult.ContactType = damageInfo.ContactType;
StepResult.VictimResult.DamageElement = damageInfo.DamagingElement;
StepResult.VictimResult.StatusesInflicted = damageInfo.Statuses;
StepResult.VictimResult.TotalDamage = damageInfo.Damage;
StepResult.VictimResult.Piercing = damageInfo.Piercing;
StepResult.VictimResult.DamageEffect = damageInfo.DamageEffect;
}
protected abstract void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult);
public static InteractionResult GetDamageInteractionOld(InteractionParamHolder interactionParam)
{
InteractionResult finalInteractionResult = new InteractionResult();
BattleEntity attacker = interactionParam.Attacker;
BattleEntity victim = interactionParam.Victim;
ContactTypes contactType = interactionParam.ContactType;
Elements element = interactionParam.DamagingElement;
StatusChanceHolder[] statuses = interactionParam.Statuses;
int damage = interactionParam.Damage;
bool piercing = interactionParam.Piercing;
//Get contact results
ContactResultInfo contactResultInfo = victim.EntityProperties.GetContactResult(attacker, contactType);
ContactResult contactResult = contactResultInfo.ContactResult;
//Retrieve an overridden type of Elemental damage to inflict based on the Victim's PhysicalAttributes
//(Ex. The Ice Power Badge only deals Ice damage to Fiery entities)
ElementOverrideHolder newElement = attacker.EntityProperties.GetTotalElementOverride(victim);
if (newElement.Element != Elements.Invalid)
{
//Add the number of element overrides to the damage if the element used already exists as an override and the victim has a Weakness
//to the Element. This allows Badges such as Ice Power to deal more damage if used in conjunction with attacks
//that deal the same type of damage (Ex. Ice Power and Ice Smash deal 2 additional damage total rather than 1).
//If any new knowledge is discovered to improve this, this will be changed
//Ice Power is the only Badge of its kind across the first two PM games that does anything like this
if (element == newElement.Element && victim.EntityProperties.HasWeakness(element) == true)
{
damage += newElement.OverrideCount;
}
element = newElement.Element;
}
/*Get the total damage dealt to the Victim. The amount of Full or Half Payback damage dealt to the Attacker
* uses the resulting damage value from this because Payback uses the total damage that would be dealt to the Victim.
* This occurs before factoring in elemental resistances/weaknesses from the Attacker*/
ElementDamageResultHolder victimElementDamage = GetElementalDamage(victim, element, damage);
int unscaledVictimDamage = victimElementDamage.Damage;
//Subtract damage reduction (P-Up, D-Down and P-Down, D-Up Badges)
unscaledVictimDamage -= victim.BattleStats.DamageReduction;
//Check if the attack hit. If not, then don't consider defensive actions
bool attackHit = interactionParam.CantMiss == true ? true : attacker.AttemptHitEntity(victim);
//Defense added from Damage Dodge Badges upon a successful Guard
int damageDodgeDefense = 0;
//Defensive actions take priority. If the attack didn't hit, don't check for defensive actions
BattleGlobals.DefensiveActionHolder?victimDefenseData = null;
if (attackHit == true)
{
victimDefenseData = victim.GetDefensiveActionResult(unscaledVictimDamage, statuses, interactionParam.DamageEffect);
}
if (victimDefenseData.HasValue == true)
{
unscaledVictimDamage = victimDefenseData.Value.Damage;
statuses = victimDefenseData.Value.Statuses;
//If the Defensive action dealt damage and the contact was direct
//the Defensive action has caused a Failure for the Attacker (Ex. Superguarding)
if ((contactType == ContactTypes.TopDirect || contactType == ContactTypes.SideDirect) && victimDefenseData.Value.ElementHolder.HasValue == true)
{
contactResult = ContactResult.Failure;
}
//Factor in the additional Guard defense for all DefensiveActions (for now, at least)
damageDodgeDefense = victim.GetEquippedBadgeCount(BadgeGlobals.BadgeTypes.DamageDodge);
}
//Subtract Defense on non-piercing damage
if (piercing == false)
{
int totalDefense = victim.BattleStats.TotalDefense + damageDodgeDefense;
unscaledVictimDamage -= totalDefense;
}
int scaledVictimDamage = unscaledVictimDamage;
//Factor in Double Pain for the Victim
scaledVictimDamage *= (1 + victim.GetEquippedBadgeCount(BadgeGlobals.BadgeTypes.DoublePain));
//Factor in Last Stand for the Victim, if the Victim is in Danger or Peril
if (victim.IsInDanger == true)
{
//PM rounds down, whereas TTYD rounds up. We're going with the latter
//TTYD always ceilings the value (Ex. 3.2 turns to 4)
int lastStandDivider = (1 + victim.GetEquippedBadgeCount(BadgeGlobals.BadgeTypes.LastStand));
scaledVictimDamage = (int)Math.Ceiling(scaledVictimDamage / (float)lastStandDivider);
}
/*If the Victim is Invincible, ignore all damage and Status Effects
* If the Attacker is Invincible, ignore all Payback damage and Status Effects
*
* It won't ignore the Payback's effects automatically; that has to be done manually by adding
* contact exceptions or something else*/
//Clamp Victim damage
scaledVictimDamage = UtilityGlobals.Clamp(scaledVictimDamage, BattleGlobals.MinDamage, BattleGlobals.MaxDamage);
#region Victim Damage Dealt
//Calculating damage dealt to the Victim
if (contactResult == ContactResult.Success || contactResult == ContactResult.PartialSuccess)
{
//Get the Status Effects to inflict on the Victim
StatusChanceHolder[] victimInflictedStatuses = GetFilteredInflictedStatuses(victim, statuses);
//Check if the Victim is Invincible. If so, ignore all damage and Status Effects
if (victim.EntityProperties.GetAdditionalProperty <bool>(AdditionalProperty.Invincible) == true)
{
scaledVictimDamage = 0;
victimElementDamage.InteractionResult = ElementInteractionResult.Damage;
victimInflictedStatuses = null;
}
finalInteractionResult.VictimResult = new InteractionHolder(victim, scaledVictimDamage, element,
victimElementDamage.InteractionResult, contactType, piercing, victimInflictedStatuses, attackHit, DamageEffects.None);
}
#endregion
#region Attacker Damage Dealt
//Calculating damage dealt to the Attacker
if (contactResult == ContactResult.Failure || contactResult == ContactResult.PartialSuccess)
{
//The damage the Attacker dealt to the Victim
int damageDealt = unscaledVictimDamage;
PaybackHolder paybackHolder = contactResultInfo.Paybackholder;
//Override the PaybackHolder with a Defensive Action's results, if any
if (victimDefenseData.HasValue == true && victimDefenseData.Value.ElementHolder.HasValue == true)
{
damageDealt = victimDefenseData.Value.ElementHolder.Value.Damage;
paybackHolder = new PaybackHolder(PaybackTypes.Constant, victimDefenseData.Value.ElementHolder.Value.Element, damageDealt);
}
//Get the damage done to the Attacker, factoring in Weaknesses/Resistances
ElementDamageResultHolder attackerElementDamage = GetElementalDamage(attacker, paybackHolder.Element, damageDealt);
//Get Payback damage - Payback damage is calculated after everything else, including Constant Payback.
//However, it does NOT factor in Double Pain or any sort of Defense modifiers.
int paybackDamage = paybackHolder.GetPaybackDamage(attackerElementDamage.Damage);
//If Constant Payback, update the damage value to use the element
if (paybackHolder.PaybackType == PaybackTypes.Constant)
{
paybackDamage = GetElementalDamage(attacker, paybackHolder.Element, paybackDamage).Damage;
}
//Clamp Attacker damage
attackerElementDamage.Damage = UtilityGlobals.Clamp(paybackDamage, BattleGlobals.MinDamage, BattleGlobals.MaxDamage);
//Get the Status Effects to inflict
StatusChanceHolder[] attackerInflictedStatuses = GetFilteredInflictedStatuses(attacker, paybackHolder.StatusesInflicted);
//Check if the Attacker is Invincible. If so, ignore all damage and Status Effects
if (attacker.EntityProperties.GetAdditionalProperty <bool>(AdditionalProperty.Invincible) == true)
{
attackerElementDamage.Damage = 0;
attackerElementDamage.InteractionResult = ElementInteractionResult.Damage;
attackerInflictedStatuses = null;
}
finalInteractionResult.AttackerResult = new InteractionHolder(attacker, attackerElementDamage.Damage, paybackHolder.Element,
attackerElementDamage.InteractionResult, ContactTypes.None, true, attackerInflictedStatuses, true, DamageEffects.None);
}
#endregion
return(finalInteractionResult);
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
//Factor in Last Stand for the Victim, if the Victim is in Danger or Peril
if (StepResult.VictimResult.Entity.IsInDanger == true)
{
//PM rounds down, whereas TTYD rounds up. We're going with the latter
//TTYD always ceilings the value (Ex. 3.2 turns to 4)
int lastStandCount = StepResult.VictimResult.Entity.GetEquippedBadgeCount(BadgeGlobals.BadgeTypes.LastStand);
int lastStandDivider = (1 + lastStandCount);
StepResult.VictimResult.TotalDamage = (int)Math.Ceiling(StepResult.VictimResult.TotalDamage / (float)lastStandDivider);
}
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
//The unscaled damage the Attacker dealt to the Victim
//This will be the Payback damage dealt from a Defensive Action if one that deals damage has been performed
int unscaledAttackerDamage = StepResult.AttackerResult.TotalDamage;
int damageDealt = unscaledAttackerDamage;
PaybackHolder paybackHolder = StepContactResultInfo.Paybackholder;
//Get the damage done to the Attacker, factoring in Weaknesses/Resistances
ElementDamageResultHolder attackerElementDamage = GetElementalDamage(StepResult.AttackerResult.Entity,
paybackHolder.Element, damageDealt);
//Get Payback damage - Payback damage is calculated after everything else
//However, it does NOT factor in Double Pain or Last Stand, hence why we use the unscaled Victim damage
int paybackDamage = paybackHolder.GetPaybackDamage(attackerElementDamage.Damage);
//If Constant Payback, the constant damage value will be returned as the Payback damage
//Therefore, update the final Payback damage value to factor in Weaknesses/Resistances using the constant Payback damage
//Ex. This causes an enemy with a +1 Weakness to Fire to be dealt 2 damage instead of 1 for a Constant 1 Fire Payback
if (paybackHolder.PaybackType == PaybackTypes.Constant)
{
paybackDamage = GetElementalDamage(StepResult.AttackerResult.Entity, paybackHolder.Element, paybackDamage).Damage;
}
//Fill out the rest of the Attacker information since we have it
//Payback damage is always direct, piercing, and guaranteed to hit
StepResult.AttackerResult.TotalDamage = paybackDamage;
StepResult.AttackerResult.DamageElement = paybackHolder.Element;
StepResult.AttackerResult.ElementResult = attackerElementDamage.InteractionResult;
StepResult.AttackerResult.ContactType = ContactTypes.TopDirect;
StepResult.AttackerResult.Piercing = true;
StepResult.AttackerResult.StatusesInflicted = paybackHolder.StatusesInflicted;
StepResult.AttackerResult.Hit = true;
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
StrengthHolder totalStrength = StepResult.AttackerResult.Entity.EntityProperties.GetTotalStrength(StepResult.VictimResult.Entity);
StepResult.VictimResult.TotalDamage += totalStrength.Value;
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
StepResult.AttackerResult.StatusesInflicted =
GetFilteredInflictedStatuses(StepResult.AttackerResult.Entity, StepResult.AttackerResult.StatusesInflicted);
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
ElementDamageResultHolder victimElementDamage = GetElementalDamage(StepResult.VictimResult.Entity,
StepResult.VictimResult.DamageElement, StepResult.VictimResult.TotalDamage);
StepResult.VictimResult.ElementResult = victimElementDamage.InteractionResult;
StepResult.VictimResult.TotalDamage = victimElementDamage.Damage;
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
if (StepContactResultInfo.ContactResult == ContactResult.Success)
{
//If the Attacker succeeded to attack, set the Attacker to null to mark it as not having a value
//This prevents the code afterwards from dealing damage to the Attacker
StepResult.AttackerResult.Entity = null;
}
}
protected override void OnCalculate(InteractionParamHolder damageInfo, InteractionResult curResult, ContactResultInfo curContactResult)
{
StepResult.VictimResult.TotalDamage -= StepResult.VictimResult.Entity.BattleStats.DamageReduction;
}