/// <summary>
/// Combine damage infliction amounts dictionary
/// </summary>
/// <param name="sourceDictionary"></param>
/// <param name="newEntry"></param>
/// <returns></returns>
public static Dictionary <DamageElement, float> CombineDamageInflictions(Dictionary <DamageElement, float> sourceDictionary, KeyValuePair <DamageElement, float> newEntry)
{
if (sourceDictionary == null)
{
sourceDictionary = new Dictionary <DamageElement, float>();
}
GameInstance gameInstance = GameInstance.Singleton;
DamageElement damageElement = newEntry.Key;
if (damageElement == null)
{
damageElement = gameInstance.DefaultDamageElement;
}
float value = newEntry.Value;
if (!sourceDictionary.ContainsKey(damageElement))
{
sourceDictionary[damageElement] = value;
}
else
{
sourceDictionary[damageElement] += value;
}
return(sourceDictionary);
}
public override void ReceiveDamage(IAttackerEntity attacker, CharacterItem weapon, Dictionary <DamageElement, MinMaxFloat> allDamageAmounts, CharacterBuff debuff, uint hitEffectsId)
{
if (!IsServer || IsDead())
{
return;
}
base.ReceiveDamage(attacker, weapon, allDamageAmounts, debuff, hitEffectsId);
float calculatingTotalDamage = 0f;
if (allDamageAmounts.Count > 0)
{
foreach (KeyValuePair <DamageElement, MinMaxFloat> allDamageAmount in allDamageAmounts)
{
DamageElement damageElement = allDamageAmount.Key;
MinMaxFloat damageAmount = allDamageAmount.Value;
calculatingTotalDamage += damageAmount.Random();
}
}
// Apply damages
int totalDamage = (int)calculatingTotalDamage;
CurrentHp -= totalDamage;
ReceivedDamage(attacker, CombatAmountType.NormalDamage, totalDamage);
// If current hp <= 0, character dead
if (IsDead())
{
NetworkDestroy();
}
}
/// <summary>
/// Make damage - amount key-value pair which calculates with damage inflictions
/// </summary>
/// <param name="source"></param>
/// <param name="level"></param>
/// <param name="rate"></param>
/// <param name="effectiveness"></param>
/// <param name="damageInflictions"></param>
/// <returns></returns>
public static Dictionary <DamageElement, MinMaxFloat> MakeDamageWithInflictions(DamageIncremental source, short level, float rate, float effectiveness, Dictionary <DamageElement, float> damageInflictions)
{
Dictionary <DamageElement, MinMaxFloat> result = new Dictionary <DamageElement, MinMaxFloat>();
GameInstance gameInstance = GameInstance.Singleton;
MinMaxFloat baseDamage = (source.amount.GetAmount(level) * rate) + effectiveness;
if (damageInflictions != null && damageInflictions.Count > 0)
{
foreach (KeyValuePair <DamageElement, float> damageInflictionAmount in damageInflictions)
{
DamageElement damageElement = damageInflictionAmount.Key;
result = CombineDamages(result, new KeyValuePair <DamageElement, MinMaxFloat>(damageElement, baseDamage * damageInflictionAmount.Value));
}
}
else
{
DamageElement damageElement = source.damageElement;
if (damageElement == null)
{
damageElement = gameInstance.DefaultDamageElement;
}
result = CombineDamages(result, new KeyValuePair <DamageElement, MinMaxFloat>(damageElement, baseDamage));
}
return(result);
}
/// <summary>
/// Make damage infliction - amount key-value pair
/// </summary>
/// <param name="source"></param>
/// <param name="level"></param>
/// <returns></returns>
public static KeyValuePair <DamageElement, float> MakeDamageInfliction(DamageInflictionIncremental source, short level)
{
GameInstance gameInstance = GameInstance.Singleton;
DamageElement damageElement = source.damageElement;
if (damageElement == null)
{
damageElement = gameInstance.DefaultDamageElement;
}
return(new KeyValuePair <DamageElement, float>(damageElement, source.rate.GetAmount(level)));
}
/// <summary>
/// Make damage infliction - amount key-value pair
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static KeyValuePair <DamageElement, float> MakeDamageInfliction(DamageInflictionAmount source)
{
GameInstance gameInstance = GameInstance.Singleton;
DamageElement damageElement = source.damageElement;
if (damageElement == null)
{
damageElement = gameInstance.DefaultDamageElement;
}
return(new KeyValuePair <DamageElement, float>(damageElement, source.rate));
}
/// <summary>
/// Make damage amount
/// </summary>
/// <param name="source"></param>
/// <param name="level"></param>
/// <param name="rate"></param>
/// <param name="effectiveness"></param>
/// <returns></returns>
public static KeyValuePair <DamageElement, MinMaxFloat> MakeDamage(DamageIncremental source, short level, float rate, float effectiveness)
{
GameInstance gameInstance = GameInstance.Singleton;
DamageElement damageElement = source.damageElement;
if (damageElement == null)
{
damageElement = gameInstance.DefaultDamageElement;
}
return(new KeyValuePair <DamageElement, MinMaxFloat>(damageElement, (source.amount.GetAmount(level) * rate) + effectiveness));
}
protected override void UpdateData()
{
if (uiTextAmount != null)
{
DamageElement element = Data.damageElement;
MinMaxFloat amount = Data.amount;
uiTextAmount.text = string.Format(
LanguageManager.GetText(formatKeyAmount),
element.Title,
amount.min.ToString("N0"),
amount.max.ToString("N0"));
}
}
protected override void UpdateData()
{
if (uiTextInfliction != null)
{
DamageElement element = Data.damageElement;
uiTextInfliction.text = string.Format(
element == GameInstance.Singleton.DefaultDamageElement ?
LanguageManager.GetText(formatKeyInfliction) :
LanguageManager.GetText(formatKeyInflictionAsElemental),
element.Title,
(Data.infliction * 100f).ToString("N0"));
}
}
/// <summary>
/// Combine resistance amounts dictionary
/// </summary>
/// <param name="sourceDictionary"></param>
/// <param name="newEntry"></param>
/// <returns></returns>
public static Dictionary <DamageElement, float> CombineResistances(Dictionary <DamageElement, float> sourceDictionary, KeyValuePair <DamageElement, float> newEntry)
{
if (sourceDictionary == null)
{
sourceDictionary = new Dictionary <DamageElement, float>();
}
DamageElement damageElement = newEntry.Key;
if (damageElement != null)
{
float value = newEntry.Value;
if (!sourceDictionary.ContainsKey(damageElement))
{
sourceDictionary[damageElement] = value;
}
else
{
sourceDictionary[damageElement] += value;
}
}
return(sourceDictionary);
}
public override void GetAttackingData(
ref bool isLeftHand,
out AnimActionType animActionType,
out int dataId,
out int animationIndex,
out CharacterItem weapon,
out float triggerDuration,
out float totalDuration,
out DamageInfo damageInfo,
out Dictionary <DamageElement, MinMaxFloat> allDamageAmounts)
{
// Initialize data
isLeftHand = false;
animActionType = AnimActionType.AttackRightHand;
// Monster will not have weapon type so set dataId to `0`, then random attack animation from default attack animtions
dataId = 0;
// Monster will not have weapon data
weapon = null;
// Random attack animation
CharacterModel.GetRandomRightHandAttackAnimation(dataId, out animationIndex, out triggerDuration, out totalDuration);
// Assign damage data
damageInfo = monsterCharacter.damageInfo;
// Assign damage amounts
allDamageAmounts = new Dictionary <DamageElement, MinMaxFloat>();
DamageElement damageElement = monsterCharacter.damageAmount.damageElement;
MinMaxFloat damageAmount = monsterCharacter.damageAmount.amount.GetAmount(Level);
if (damageElement == null)
{
damageElement = gameInstance.DefaultDamageElement;
}
allDamageAmounts.Add(damageElement, damageAmount);
}
public DamageElementInflictionTuple(DamageElement damageElement, float infliction)
{
this.damageElement = damageElement;
this.infliction = infliction;
}
public DamageElementAmountTuple(DamageElement damageElement, MinMaxFloat amount)
{
this.damageElement = damageElement;
this.amount = amount;
}
public override float GetDamageReducedByResistance(BaseCharacterEntity damageReceiver, float damageAmount, DamageElement damageElement)
{
if (damageElement == null)
{
return(damageAmount -= damageReceiver.CacheStats.armor); // If armor is minus damage will be increased
}
var resistances = damageReceiver.CacheResistances;
float resistanceAmount = 0f;
resistances.TryGetValue(damageElement, out resistanceAmount);
if (resistanceAmount > damageElement.maxResistanceAmount)
{
resistanceAmount = damageElement.maxResistanceAmount;
}
return(damageAmount -= damageAmount * resistanceAmount); // If resistance is minus damage will be increased
}
public abstract float GetDamageReducedByResistance(BaseCharacterEntity damageReceiver, float damageAmount, DamageElement damageElement);
public override float GetDamageReducedByResistance(BaseCharacterEntity damageReceiver, float damageAmount, DamageElement damageElement)
{
if (damageElement == null || damageElement == GameInstance.Singleton.DefaultDamageElement)
{
return(damageAmount -= damageReceiver.CacheStats.armor); // If armor is minus value, damage will be increased
}
Dictionary <DamageElement, float> resistances = damageReceiver.CacheResistances;
float resistanceAmount = 0f;
resistances.TryGetValue(damageElement, out resistanceAmount);
if (resistanceAmount > damageElement.maxResistanceAmount)
{
resistanceAmount = damageElement.maxResistanceAmount;
}
return(damageAmount -= damageAmount * resistanceAmount); // If resistance is minus damage will be increased
}