public static Dictionary <DamageElement, MinMaxFloat> GetBuffIncreaseDamages(this ICharacterData data)
{
if (data == null)
{
return(new Dictionary <DamageElement, MinMaxFloat>());
}
Dictionary <DamageElement, MinMaxFloat> result = new Dictionary <DamageElement, MinMaxFloat>();
IList <CharacterBuff> buffs = data.Buffs;
foreach (CharacterBuff buff in buffs)
{
result = GameDataHelpers.CombineDamages(result, buff.GetIncreaseDamages());
}
// Passive skills
IList <CharacterSkill> skills = data.Skills;
foreach (CharacterSkill skill in skills)
{
if (skill.GetSkill() == null || skill.GetSkill().skillType != SkillType.Passive || skill.level <= 0)
{
continue;
}
result = GameDataHelpers.CombineDamages(result, skill.GetPassiveBuffIncreaseDamages());
}
return(result);
}
public static CharacterStats GetBuffStats(this ICharacterData data)
{
if (data == null)
{
return(new CharacterStats());
}
var result = new CharacterStats();
var buffs = data.Buffs;
foreach (var buff in buffs)
{
result += buff.GetIncreaseStats();
result += GameDataHelpers.GetStatsFromAttributes(buff.GetIncreaseAttributes());
}
// Passive skills
var skills = data.Skills;
Buff tempBuff;
foreach (var skill in skills)
{
if (skill.GetSkill() == null || skill.GetSkill().skillType != SkillType.Passive || skill.level <= 0)
{
continue;
}
tempBuff = skill.GetSkill().buff;
result += tempBuff.GetIncreaseStats(skill.level);
result += GameDataHelpers.GetStatsFromAttributes(tempBuff.GetIncreaseAttributes(skill.level));
}
return(result);
}
public static Dictionary <DamageElement, float> GetBuffResistances(this ICharacterData data)
{
if (data == null)
{
return(new Dictionary <DamageElement, float>());
}
var result = new Dictionary <DamageElement, float>();
var buffs = data.Buffs;
foreach (var buff in buffs)
{
result = GameDataHelpers.CombineResistanceAmountsDictionary(result, buff.GetIncreaseResistances());
}
// Passive skills
var skills = data.Skills;
foreach (var skill in skills)
{
if (skill.GetSkill() == null || skill.GetSkill().skillType != SkillType.Passive || skill.level <= 0)
{
continue;
}
result = GameDataHelpers.CombineResistanceAmountsDictionary(result,
skill.GetSkill().buff.GetIncreaseResistances(skill.level));
}
return(result);
}
public static CharacterStats GetBuffStats(this ICharacterData data)
{
if (data == null)
{
return(new CharacterStats());
}
CharacterStats result = new CharacterStats();
IList <CharacterBuff> buffs = data.Buffs;
foreach (CharacterBuff buff in buffs)
{
result += buff.GetIncreaseStats();
result += GameDataHelpers.GetStatsFromAttributes(buff.GetIncreaseAttributes());
}
// Passive skills
IList <CharacterSkill> skills = data.Skills;
foreach (CharacterSkill skill in skills)
{
if (skill.GetSkill() == null || skill.GetSkill().skillType != SkillType.Passive || skill.level <= 0)
{
continue;
}
result += skill.GetPassiveBuffIncreaseStats();
result += GameDataHelpers.GetStatsFromAttributes(skill.GetPassiveBuffIncreaseAttributes());
}
return(result);
}
public static Dictionary <DamageElement, MinMaxFloat> GetDamageAmountWithInflictions(this Item weaponItem, short level, float rate, ICharacterData character, Dictionary <DamageElement, float> damageInflictionAmounts)
{
if (weaponItem == null ||
!weaponItem.IsWeapon())
{
return(new Dictionary <DamageElement, MinMaxFloat>());
}
return(GameDataHelpers.MakeDamageAmountWithInflictions(weaponItem.damageAmount, level, rate, weaponItem.GetEffectivenessDamage(character), damageInflictionAmounts));
}
public static KeyValuePair <DamageElement, MinMaxFloat> GetDamageAmount(this Item weaponItem, short level, float rate, ICharacterData character)
{
if (weaponItem == null ||
!weaponItem.IsWeapon())
{
return(new KeyValuePair <DamageElement, MinMaxFloat>());
}
return(GameDataHelpers.MakeDamageAmountPair(weaponItem.damageAmount, level, rate, weaponItem.GetEffectivenessDamage(character)));
}
public static Dictionary <Skill, short> GetSkills(this ICharacterData data, bool sumWithEquipments = true)
{
Dictionary <Skill, short> result = data.GetCharacterSkills();
if (sumWithEquipments)
{
result = GameDataHelpers.CombineSkills(result, data.GetEquipmentSkills());
}
return(result);
}
public static float GetEffectivenessDamage(this Item weaponItem, ICharacterData character)
{
if (weaponItem == null ||
!weaponItem.IsWeapon() ||
character == null)
{
return(0f);
}
return(GameDataHelpers.CalculateEffectivenessDamage(weaponItem.WeaponType.CacheEffectivenessAttributes, character));
}
public static Dictionary <DamageElement, MinMaxFloat> GetIncreaseDamages(this Item equipmentItem, short level, float rate)
{
var result = new Dictionary <DamageElement, MinMaxFloat>();
if (equipmentItem != null &&
equipmentItem.IsEquipment())
{
result = GameDataHelpers.MakeDamageAmountsDictionary(equipmentItem.increaseDamages, result, level, rate);
}
return(result);
}
public static Dictionary <DamageElement, float> GetResistances(this ICharacterData data, bool sumWithEquipments = true, bool sumWithBuffs = true)
{
Dictionary <DamageElement, float> result = data.GetCharacterResistances();
if (sumWithEquipments)
{
result = GameDataHelpers.CombineResistances(result, data.GetEquipmentResistances());
}
if (sumWithBuffs)
{
result = GameDataHelpers.CombineResistances(result, data.GetBuffResistances());
}
return(result);
}
public static Dictionary <DamageElement, MinMaxFloat> GetIncreaseDamages(this ICharacterData data, bool sumWithEquipments = true, bool sumWithBuffs = true)
{
Dictionary <DamageElement, MinMaxFloat> result = new Dictionary <DamageElement, MinMaxFloat>();
if (sumWithEquipments)
{
result = GameDataHelpers.CombineDamages(result, data.GetEquipmentIncreaseDamages());
}
if (sumWithBuffs)
{
result = GameDataHelpers.CombineDamages(result, data.GetBuffIncreaseDamages());
}
return(result);
}
public static Dictionary <Attribute, short> GetAttributes(this ICharacterData data, bool sumWithEquipments = true, bool sumWithBuffs = true)
{
Dictionary <Attribute, short> result = data.GetCharacterAttributes();
if (sumWithEquipments)
{
result = GameDataHelpers.CombineAttributes(result, data.GetEquipmentAttributes());
}
if (sumWithBuffs)
{
result = GameDataHelpers.CombineAttributes(result, data.GetBuffAttributes());
}
return(result);
}
public static Dictionary <DamageElement, float> GetCharacterResistances(this ICharacterData data)
{
if (data == null)
{
return(new Dictionary <DamageElement, float>());
}
Dictionary <DamageElement, float> result = new Dictionary <DamageElement, float>();
BaseCharacter character = data.GetDatabase();
if (character != null)
{
result = GameDataHelpers.CombineResistances(result, character.GetCharacterResistances(data.Level));
}
return(result);
}
public static void GetAllStats(this ICharacterData data,
out CharacterStats resultStats,
Dictionary <Attribute, short> resultAttributes,
Dictionary <DamageElement, float> resultResistances,
Dictionary <DamageElement, MinMaxFloat> resultIncreaseDamages,
Dictionary <Skill, short> resultSkills,
Dictionary <EquipmentSet, int> resultEquipmentSets,
out int resultMaxHp,
out int resultMaxMp,
out int resultMaxStamina,
out int resultMaxFood,
out int resultMaxWater,
out float resultTotalItemWeight,
out float resultAtkSpeed,
out float resultMoveSpeed)
{
resultStats = new CharacterStats();
resultAttributes.Clear();
resultResistances.Clear();
resultIncreaseDamages.Clear();
resultSkills.Clear();
resultEquipmentSets.Clear();
GetEquipmentSetBonus(data, out resultStats, resultAttributes, resultResistances, resultIncreaseDamages, resultSkills, resultEquipmentSets);
resultStats = resultStats + data.GetStats();
resultAttributes = GameDataHelpers.CombineAttributes(resultAttributes, data.GetAttributes());
resultResistances = GameDataHelpers.CombineResistances(resultResistances, data.GetResistances());
resultIncreaseDamages = GameDataHelpers.CombineDamages(resultIncreaseDamages, data.GetIncreaseDamages());
resultSkills = GameDataHelpers.CombineSkills(resultSkills, data.GetSkills());
// Sum with other stats
resultMaxHp = (int)resultStats.hp;
resultMaxMp = (int)resultStats.mp;
resultMaxStamina = (int)resultStats.stamina;
resultMaxFood = (int)resultStats.food;
resultMaxWater = (int)resultStats.water;
resultTotalItemWeight = GameInstance.Singleton.GameplayRule.GetTotalWeight(data);
resultAtkSpeed = resultStats.atkSpeed;
resultMoveSpeed = resultStats.moveSpeed;
// Validate max amount
foreach (Attribute attribute in new List <Attribute>(resultAttributes.Keys))
{
if (attribute.maxAmount > 0 && resultAttributes[attribute] > attribute.maxAmount)
{
resultAttributes[attribute] = attribute.maxAmount;
}
}
}
public static CharacterStats GetCharacterStats(this ICharacterData data)
{
if (data == null)
{
return(new CharacterStats());
}
var level = data.Level;
var character = data.GetDatabase();
var result = new CharacterStats();
if (character != null)
{
result += character.GetCharacterStats(level);
}
result += GameDataHelpers.CaculateStats(GetAttributes(data));
return(result);
}
public static CharacterStats GetCharacterStats(this ICharacterData data)
{
if (data == null)
{
return(new CharacterStats());
}
short level = data.Level;
BaseCharacter character = data.GetDatabase();
CharacterStats result = new CharacterStats();
if (character != null)
{
result += character.GetCharacterStats(level);
}
result += GameDataHelpers.GetStatsFromAttributes(GetAttributes(data));
return(result);
}
public static CharacterStats GetEquipmentStats(this ICharacterData data)
{
if (data == null)
{
return(new CharacterStats());
}
CharacterStats result = new CharacterStats();
// Armors
IList <CharacterItem> equipItems = data.EquipItems;
foreach (CharacterItem equipItem in equipItems)
{
if (equipItem.IsEmpty())
{
continue;
}
result += equipItem.GetIncreaseStats();
result += equipItem.GetSocketsIncreaseStats();
result += GameDataHelpers.GetStatsFromAttributes(equipItem.GetIncreaseAttributes());
result += GameDataHelpers.GetStatsFromAttributes(equipItem.GetSocketsIncreaseAttributes());
}
// Weapons
EquipWeapons equipWeapons = data.EquipWeapons;
if (equipWeapons != null)
{
// Right hand equipment
if (!equipWeapons.rightHand.IsEmpty())
{
result += equipWeapons.rightHand.GetIncreaseStats();
result += equipWeapons.rightHand.GetSocketsIncreaseStats();
result += GameDataHelpers.GetStatsFromAttributes(equipWeapons.rightHand.GetIncreaseAttributes());
result += GameDataHelpers.GetStatsFromAttributes(equipWeapons.rightHand.GetSocketsIncreaseAttributes());
}
// Left hand equipment
if (!equipWeapons.leftHand.IsEmpty())
{
result += equipWeapons.leftHand.GetIncreaseStats();
result += equipWeapons.leftHand.GetSocketsIncreaseStats();
result += GameDataHelpers.GetStatsFromAttributes(equipWeapons.leftHand.GetIncreaseAttributes());
result += GameDataHelpers.GetStatsFromAttributes(equipWeapons.leftHand.GetSocketsIncreaseAttributes());
}
}
return(result);
}
public static Dictionary <DamageElement, MinMaxFloat> GetEquipmentIncreaseDamages(this ICharacterData data)
{
if (data == null)
{
return(new Dictionary <DamageElement, MinMaxFloat>());
}
var result = new Dictionary <DamageElement, MinMaxFloat>();
// Armors
Item tempEquipment = null;
var equipItems = data.EquipItems;
foreach (var equipItem in equipItems)
{
tempEquipment = equipItem.GetEquipmentItem();
if (tempEquipment != null)
{
result = GameDataHelpers.CombineDamageAmountsDictionary(result,
tempEquipment.GetIncreaseDamages(equipItem.level, equipItem.GetEquipmentBonusRate()));
}
}
// Weapons
var equipWeapons = data.EquipWeapons;
if (equipWeapons != null)
{
// Right hand equipment
var rightHandItem = equipWeapons.rightHand;
tempEquipment = rightHandItem.GetEquipmentItem();
if (tempEquipment != null)
{
result = GameDataHelpers.CombineDamageAmountsDictionary(result,
tempEquipment.GetIncreaseDamages(rightHandItem.level, rightHandItem.GetEquipmentBonusRate()));
}
// Left hand equipment
var leftHandItem = equipWeapons.leftHand;
tempEquipment = leftHandItem.GetEquipmentItem();
if (tempEquipment != null)
{
result = GameDataHelpers.CombineDamageAmountsDictionary(result,
tempEquipment.GetIncreaseDamages(leftHandItem.level, leftHandItem.GetEquipmentBonusRate()));
}
}
return(result);
}
public static CharacterStats GetEquipmentStats(this ICharacterData data)
{
if (data == null)
{
return(new CharacterStats());
}
var result = new CharacterStats();
// Armors
Item tempEquipment = null;
var equipItems = data.EquipItems;
foreach (var equipItem in equipItems)
{
tempEquipment = equipItem.GetEquipmentItem();
if (tempEquipment != null)
{
result += tempEquipment.GetIncreaseStats(equipItem.level, equipItem.GetEquipmentBonusRate());
result += GameDataHelpers.GetStatsFromAttributes(tempEquipment.GetIncreaseAttributes(equipItem.level, equipItem.GetEquipmentBonusRate()));
}
}
// Weapons
var equipWeapons = data.EquipWeapons;
if (equipWeapons != null)
{
// Right hand equipment
var rightHandItem = equipWeapons.rightHand;
tempEquipment = rightHandItem.GetEquipmentItem();
if (tempEquipment != null)
{
result += tempEquipment.GetIncreaseStats(rightHandItem.level, rightHandItem.GetEquipmentBonusRate());
result += GameDataHelpers.GetStatsFromAttributes(tempEquipment.GetIncreaseAttributes(rightHandItem.level, rightHandItem.GetEquipmentBonusRate()));
}
// Left hand equipment
var leftHandItem = equipWeapons.leftHand;
tempEquipment = leftHandItem.GetEquipmentItem();
if (tempEquipment != null)
{
result += tempEquipment.GetIncreaseStats(leftHandItem.level, leftHandItem.GetEquipmentBonusRate());
result += GameDataHelpers.GetStatsFromAttributes(tempEquipment.GetIncreaseAttributes(leftHandItem.level, leftHandItem.GetEquipmentBonusRate()));
}
}
return(result);
}
public Dictionary <Skill, short> GetSocketsIncreaseSkills()
{
if (GetEquipmentItem() == null || Sockets.Count == 0)
{
return(null);
}
Dictionary <Skill, short> result = new Dictionary <Skill, short>();
Item tempEnhancer;
foreach (int socketId in Sockets)
{
if (GameInstance.Items.TryGetValue(socketId, out tempEnhancer))
{
// Level for increase stats always 1
result = GameDataHelpers.CombineSkills(tempEnhancer.socketEnhanceEffect.skills, result);
}
}
return(result);
}
public static Dictionary <DamageElement, MinMaxFloat> GetEquipmentIncreaseDamages(this ICharacterData data)
{
if (data == null)
{
return(new Dictionary <DamageElement, MinMaxFloat>());
}
Dictionary <DamageElement, MinMaxFloat> result = new Dictionary <DamageElement, MinMaxFloat>();
// Armors
IList <CharacterItem> equipItems = data.EquipItems;
foreach (CharacterItem equipItem in equipItems)
{
if (equipItem.IsEmpty())
{
continue;
}
result = GameDataHelpers.CombineDamages(result, equipItem.GetIncreaseDamages());
result = GameDataHelpers.CombineDamages(result, equipItem.GetSocketsIncreaseDamages());
}
// Weapons
EquipWeapons equipWeapons = data.EquipWeapons;
if (equipWeapons != null)
{
// Right hand equipment
if (equipWeapons.rightHand.IsEmpty())
{
result = GameDataHelpers.CombineDamages(result, equipWeapons.rightHand.GetIncreaseDamages());
result = GameDataHelpers.CombineDamages(result, equipWeapons.rightHand.GetSocketsIncreaseDamages());
}
// Left hand equipment
if (equipWeapons.leftHand.IsEmpty())
{
result = GameDataHelpers.CombineDamages(result, equipWeapons.leftHand.GetIncreaseDamages());
result = GameDataHelpers.CombineDamages(result, equipWeapons.leftHand.GetSocketsIncreaseDamages());
}
}
return(result);
}
public static Dictionary <Attribute, short> GetCharacterAttributes(this ICharacterData data)
{
if (data == null)
{
return(new Dictionary <Attribute, short>());
}
Dictionary <Attribute, short> result = new Dictionary <Attribute, short>();
// Attributes from character database
BaseCharacter character = data.GetDatabase();
if (character != null)
{
result = GameDataHelpers.CombineAttributes(result,
character.GetCharacterAttributes(data.Level));
}
// Added attributes
IList <CharacterAttribute> characterAttributes = data.Attributes;
foreach (CharacterAttribute characterAttribute in characterAttributes)
{
Attribute key = characterAttribute.GetAttribute();
short value = characterAttribute.amount;
if (key == null)
{
continue;
}
if (!result.ContainsKey(key))
{
result[key] = value;
}
else
{
result[key] += value;
}
}
return(result);
}
public static Dictionary <Attribute, short> GetBuffAttributes(this ICharacterData data)
{
var result = new Dictionary <Attribute, short>();
var buffs = data.Buffs;
foreach (var buff in buffs)
{
result = GameDataHelpers.CombineAttributeAmountsDictionary(result, buff.GetIncreaseAttributes());
}
// Passive skills
var skills = data.Skills;
foreach (var skill in skills)
{
if (skill.GetSkill() == null || skill.GetSkill().skillType != SkillType.Passive || skill.level <= 0)
{
continue;
}
result = GameDataHelpers.CombineAttributeAmountsDictionary(result,
skill.GetSkill().buff.GetIncreaseAttributes(skill.level));
}
return(result);
}
public Dictionary <DamageElement, float> GetCharacterResistances(short level)
{
return(GameDataHelpers.MakeResistanceAmountsDictionary(resistances, new Dictionary <DamageElement, float>(), level, 1f));
}
public Dictionary <Attribute, short> GetCharacterAttributes(short level)
{
return(GameDataHelpers.MakeAttributeAmountsDictionary(attributes, new Dictionary <Attribute, short>(), level, 1f));
}
// -------------------------------------------------------------------
// Protected
// -------------------------------------------------------------------
public static IList <GameDataRace> GetAvailable()
{
return(GameDataHelpers.FindGameDataList(TypeCache <GameDataRace> .Value).Cast <GameDataRace>().ToList());
}
public static void GetEquipmentSetBonus(this ICharacterData data,
out CharacterStats bonusStats,
Dictionary <Attribute, short> bonusAttributes,
Dictionary <DamageElement, float> bonusResistances,
Dictionary <DamageElement, MinMaxFloat> bonusIncreaseDamages,
Dictionary <Skill, short> bonusSkills,
Dictionary <EquipmentSet, int> equipmentSets)
{
bonusStats = new CharacterStats();
bonusAttributes.Clear();
bonusResistances.Clear();
bonusIncreaseDamages.Clear();
bonusSkills.Clear();
// Equipment Set
equipmentSets.Clear();
// Armor equipment set
foreach (CharacterItem equipItem in data.EquipItems)
{
if (equipItem.NotEmptySlot() && equipItem.GetItem().equipmentSet != null)
{
if (equipmentSets.ContainsKey(equipItem.GetItem().equipmentSet))
{
++equipmentSets[equipItem.GetItem().equipmentSet];
}
else
{
equipmentSets.Add(equipItem.GetItem().equipmentSet, 0);
}
}
}
// Weapon equipment set
if (data.EquipWeapons != null)
{
// Right hand equipment set
if (data.EquipWeapons.rightHand.NotEmptySlot() && data.EquipWeapons.rightHand.GetItem().equipmentSet != null)
{
if (equipmentSets.ContainsKey(data.EquipWeapons.rightHand.GetItem().equipmentSet))
{
++equipmentSets[data.EquipWeapons.rightHand.GetItem().equipmentSet];
}
else
{
equipmentSets.Add(data.EquipWeapons.rightHand.GetItem().equipmentSet, 0);
}
}
// Left hand equipment set
if (data.EquipWeapons.leftHand.NotEmptySlot() && data.EquipWeapons.leftHand.GetItem().equipmentSet != null)
{
if (equipmentSets.ContainsKey(data.EquipWeapons.leftHand.GetItem().equipmentSet))
{
++equipmentSets[data.EquipWeapons.leftHand.GetItem().equipmentSet];
}
else
{
equipmentSets.Add(data.EquipWeapons.leftHand.GetItem().equipmentSet, 0);
}
}
}
// Apply set items
Dictionary <Attribute, short> tempIncreaseAttributes;
Dictionary <DamageElement, float> tempIncreaseResistances;
Dictionary <DamageElement, MinMaxFloat> tempIncreaseDamages;
Dictionary <Skill, short> tempIncreaseSkills;
CharacterStats tempIncreaseStats;
foreach (KeyValuePair <EquipmentSet, int> cacheEquipmentSet in equipmentSets)
{
EquipmentBonus[] effects = cacheEquipmentSet.Key.effects;
int setAmount = cacheEquipmentSet.Value;
for (int i = 0; i < setAmount; ++i)
{
if (i < effects.Length)
{
// Make temp of data
tempIncreaseAttributes = GameDataHelpers.CombineAttributes(effects[i].attributes, null, 1f);
tempIncreaseResistances = GameDataHelpers.CombineResistances(effects[i].resistances, null, 1f);
tempIncreaseDamages = GameDataHelpers.CombineDamages(effects[i].damages, null, 1f);
tempIncreaseSkills = GameDataHelpers.CombineSkills(effects[i].skills, null);
tempIncreaseStats = effects[i].stats + GameDataHelpers.GetStatsFromAttributes(tempIncreaseAttributes);
// Combine to result dictionaries
bonusAttributes = GameDataHelpers.CombineAttributes(bonusAttributes, tempIncreaseAttributes);
bonusResistances = GameDataHelpers.CombineResistances(bonusResistances, tempIncreaseResistances);
bonusIncreaseDamages = GameDataHelpers.CombineDamages(bonusIncreaseDamages, tempIncreaseDamages);
bonusSkills = GameDataHelpers.CombineSkills(bonusSkills, tempIncreaseSkills);
bonusStats += tempIncreaseStats;
}
else
{
break;
}
}
}
}
