protected Character(CharacterSO other)
{
// name
displayName = other.displayName;
// stats
attributes = other.attributes;
elementAttack = other.elementAttack;
elementDefense = other.elementDefense;
combatStats = other.combatStats;
// level and class
level = other.level;
charClass = other.charClass;
// create armor and weapon configs from class rules
mWeaponConfig = charClass.CreateWeaponConfig();
mArmorConfig = charClass.CreateArmorConfig();
for (int i=0; i < other.weapons.Length; i++) {
mWeaponConfig.EquipWeapon(other.weapons[i], i);
}
// TODO, this should be tightly coupled with SO implementation
// for (int i=0; i < other.weapons.Length; i++) {
// mArmorConfig.EquipArmor(other.armors[i], i);
// }
curHP = maxHP;
}
public DamageEvent(BattleEntity srcEntity, BattleEntity destEntity, ElementVector damage, ElementVector critDamage, ElementVector defense)
{
this.mSrcEntity = srcEntity;
this.mDestEntity = destEntity;
this.mDamage = damage;
this.mCritDamage = critDamage;
this.mDefense = defense;
}
public ElementVector(ElementVector copy)
{
slash = copy.slash;
crush = copy.crush;
pierce = copy.pierce;
light = copy.light;
dark = copy.dark;
fire = copy.fire;
water = copy.water;
wind = copy.wind;
earth = copy.earth;
}
public static ElementVector operator *(ElementVector e1, ElementVector e2)
{
ElementVector result = new ElementVector();
result.crush = e1.crush * e2.crush;
result.slash = e1.slash * e2.slash;
result.pierce = e1.pierce * e2.pierce;
result.light = e1.light * e2.light;
result.dark = e1.dark * e2.dark;
result.fire = e1.fire * e2.fire;
result.water = e1.water * e2.water;
result.earth = e1.earth * e2.earth;
result.wind = e1.wind * e2.wind;
return result;
}
public void Execute(CombatResolver src, CombatResolver dest)
{
CheckExecute ();
// pull out min and max damage and calculated 'rolled damage'
ElementVector min = src.DamageMin;
ElementVector max = src.DamageMax;
float rand = UnityEngine.Random.Range(0f, 1f);
ElementVector diff = max - min;
ElementVector randomDmg = min + (diff * rand);
// scale damage by vector, this could have been done earlier, same results
AttributeVector attributes = src.Attributes;
AttributeVector damageAttributeScalar = src.DamageAttributeScalar;
AttributeVector resultDamageExtra = attributes * damageAttributeScalar;
float scaleDamage = resultDamageExtra.Sum;
// scale damage should be < 1 normally, so we want to ensure this is positive on scaling
m_Damage = randomDmg * (1 + scaleDamage);
// scale on dmg bonus
m_Damage += src.ElementAttackRaw;
m_Damage *= src.ElementAttackScalar;
// if is critical
m_CritDamage = new ElementVector();
m_CritResult = new CritChanceLogic ();
m_CritResult.Execute (src, dest);
if (m_CritResult.Hits) {
float critScale = CombatUtil.CalculateCritDamageScale(src, dest);
m_CritDamage = (m_Damage * critScale);
}
m_HpBefore = dest.entity.currentHP;
m_Defense = dest.ElementDefense;
// apply dmg
m_TotalDamage = CombatUtil.CalculateDamage (m_Damage, m_CritDamage, m_Defense);
dest.entity.currentHP -= m_TotalDamage;
m_HpAfter = dest.entity.currentHP;
Logger.d (this, this);
}
public static ElementVector operator *(ElementVector e, float f)
{
ElementVector result = new ElementVector(e);
result.crush *= f;
result.pierce *= f;
result.slash *= f;
result.light *= f;
result.dark *= f;
result.fire *= f;
result.water *= f;
result.earth *= f;
result.wind *= f;
return result;
}
public ElementVector Min(float value)
{
ElementVector result = new ElementVector(this);
result.crush = Math.Min(value, result.crush);
result.slash = Math.Min(value, result.slash);
result.pierce = Math.Min(value, result.pierce);
result.light = Math.Min(value, result.light);
result.dark = Math.Min(value, result.dark);
result.fire = Math.Min(value, result.fire);
result.water = Math.Min(value, result.water);
result.earth = Math.Min(value, result.earth);
result.wind = Math.Min(value, result.wind);
return result;
}
/// <summary>
/// Calculates the damage.
/// </summary>
/// <returns>The damage.</returns>
/// <param name="dmgVec">Dmg vec.</param>
/// <param name="critVec">Crit vec.</param>
/// <param name="defenseVec">Defense vec.</param>
public static float CalculateDamage(ElementVector dmgVec, ElementVector critVec, ElementVector defenseVec)
{
ElementVector totalDmg = dmgVec + critVec;
return (totalDmg * totalDmg / (totalDmg + defenseVec).Max(1)).Sum;
}
public void LoadElementDefenseScalar(ElementVector elements)
{
if (elements != null) {
mPropertyMultiply[(int)CombatPropertyType.CRUSH_DEFENSE] = elements.crush;
mPropertyMultiply[(int)CombatPropertyType.SLASH_DEFENSE] = elements.slash;
mPropertyMultiply[(int)CombatPropertyType.PIERCE_DEFENSE] = elements.pierce;
mPropertyMultiply[(int)CombatPropertyType.LIGHT_DEFENSE] = elements.light;
mPropertyMultiply[(int)CombatPropertyType.DARK_DEFENSE] = elements.dark;
mPropertyMultiply[(int)CombatPropertyType.EARTH_DEFENSE] = elements.earth;
mPropertyMultiply[(int)CombatPropertyType.WIND_DEFENSE] = elements.wind;
mPropertyMultiply[(int)CombatPropertyType.FIRE_DEFENSE] = elements.fire;
mPropertyMultiply[(int)CombatPropertyType.WATER_DEFENSE] = elements.water;
}
}
public void LoadElementAttack(ElementVector elements)
{
if (elements != null) {
mPropertyAdd[(int)CombatPropertyType.CRUSH_ATTACK] = elements.crush;
mPropertyAdd[(int)CombatPropertyType.SLASH_ATTACK] = elements.slash;
mPropertyAdd[(int)CombatPropertyType.PIERCE_ATTACK] = elements.pierce;
mPropertyAdd[(int)CombatPropertyType.LIGHT_ATTACK] = elements.light;
mPropertyAdd[(int)CombatPropertyType.DARK_ATTACK] = elements.dark;
mPropertyAdd[(int)CombatPropertyType.EARTH_ATTACK] = elements.earth;
mPropertyAdd[(int)CombatPropertyType.WIND_ATTACK] = elements.wind;
mPropertyAdd[(int)CombatPropertyType.FIRE_ATTACK] = elements.fire;
mPropertyAdd[(int)CombatPropertyType.WATER_ATTACK] = elements.water;
}
}
