private static bool IsDamageType(Obj_AI_Hero hero, String spellName, Damage.DamageType damageType)
{
DamageSpell damageSpell = null;
foreach (SpellDataInst spellDataInst in hero.Spellbook.Spells)
{
if (string.Equals(spellDataInst.Name, spellName,
StringComparison.InvariantCultureIgnoreCase))
{
damageSpell = Damage.Spells[hero.ChampionName].FirstOrDefault(s =>
{
if (s.Slot == spellDataInst.Slot)
{
return(0 == s.Stage);
}
return(false);
}) ?? Damage.Spells[hero.ChampionName].FirstOrDefault(s => s.Slot == spellDataInst.Slot);
if (damageSpell != null)
{
break;
}
}
}
if (damageSpell == null || damageSpell.DamageType != damageType)
{
return(false);
}
return(true);
}
public void SetStats()
{
if (mobElement == Damage.DamageType.Random)
{
mobElement = (Damage.DamageType)Random.Range(0, 12);
}
if (mobClass == Monster_Class.Random)
{
mobClass = (Monster_Class)Random.Range(0, 5);
}
if (mobClass != Monster_Class.Normal)
{
if (mobClass == Monster_Class.Tank)
{
SetStatsForTank();
}
else if (mobClass == Monster_Class.Fast)
{
SetStatsForFast();
}
else if (mobClass == Monster_Class.Strong)
{
SetStatsForStrong();
}
else if (mobClass == Monster_Class.Elite)
{
SetStatsForElite();
}
}
else
{
SetStatsForNormal();
}
}
public static int CalculateElementDamageOTToMonster(Damage_OT dot, Monster y)
{
int d = 0;
Damage_OT.Damage_OTType otype = dot.GetDamage_OTType();
Damage_OT.Damage_OTType poi = Damage_OT.Damage_OTType.Poison;
//Damage_OT.Damage_OTType ble = Damage_OT.Damage_OTType.Bleeding;
Damage_OT.Damage_OTType fir = Damage_OT.Damage_OTType.Fire;
Damage.DamageType m = y.mobElement;
if (otype == poi && m == Damage.DamageType.Poison)
{
d = (int)((dot.GetDamage_OTAmount() / 2f)) * -1;
}
else if (otype == fir && m == Damage.DamageType.Fire)
{
d = (int)((dot.GetDamage_OTAmount() / 2f)) * -1;
}
else
{
d = dot.GetDamage_OTAmount();
}
return(d);
}
public override void TakeDamage(Damage.DamageType type, int amount)
{
if (type != Damage.DamageType.Healing && amount > 0)
{
gameObject.SetActive(false);
}
}
public void SetMobColor(Damage.DamageType element)
{
if (element == Damage.DamageType.Fire)
{
GetComponent <SpriteRenderer>().color = mob_Fire;
}
else if (element == Damage.DamageType.Water)
{
GetComponent <SpriteRenderer>().color = mob_Water;
}
else if (element == Damage.DamageType.Thunder)
{
GetComponent <SpriteRenderer>().color = mob_Thunder;
}
else if (element == Damage.DamageType.Ice)
{
GetComponent <SpriteRenderer>().color = mob_Ice;
}
else if (element == Damage.DamageType.Wind)
{
GetComponent <SpriteRenderer>().color = mob_Wind;
}
else if (element == Damage.DamageType.Earth)
{
GetComponent <SpriteRenderer>().color = mob_Earth;
}
else if (element == Damage.DamageType.Light)
{
GetComponent <SpriteRenderer>().color = mob_Light;
}
else if (element == Damage.DamageType.Poison)
{
GetComponent <SpriteRenderer>().color = mob_Poison;
}
else if (element == Damage.DamageType.Dark)
{
GetComponent <SpriteRenderer>().color = mob_Dark;
}
else if (element == Damage.DamageType.Aether)
{
GetComponent <SpriteRenderer>().color = mob_Aether;
}
else if (element == Damage.DamageType.Soul)
{
GetComponent <SpriteRenderer>().color = mob_Soul;
}
else
{
GetComponent <SpriteRenderer>().color = Color.white;
}
notChangedelement = mobElement;
}
public Color32 SetDamageColor(Damage.DamageType dt)
{
if (dt == Damage.DamageType.Aether)
{
return(Aether);
}
else if (dt == Damage.DamageType.Dark)
{
return(Dark);
}
else if (dt == Damage.DamageType.Poison)
{
return(Poison);
}
else if (dt == Damage.DamageType.Earth)
{
return(Earth);
}
else if (dt == Damage.DamageType.Fire)
{
return(Fire);
}
else if (dt == Damage.DamageType.Ice)
{
return(Ice);
}
else if (dt == Damage.DamageType.Light)
{
return(Light);
}
else if (dt == Damage.DamageType.Soul)
{
return(Soul);
}
else if (dt == Damage.DamageType.Thunder)
{
return(Thunder);
}
else if (dt == Damage.DamageType.Water)
{
return(Water);
}
else if (dt == Damage.DamageType.Wind)
{
return(Wind);
}
else
{
return(Normal);
}
}
public Resistance GetResistanceForType(Damage.DamageType _type)
{
int x = 0;
if (_type == Damage.DamageType.Aether)
{
x = aetherResistance;
}
else if (_type == Damage.DamageType.Dark)
{
x = darkResistance;
}
else if (_type == Damage.DamageType.Earth)
{
x = earthResistance;
}
else if (_type == Damage.DamageType.Fire)
{
x = fireResistance;
}
else if (_type == Damage.DamageType.Ice)
{
x = iceResistance;
}
else if (_type == Damage.DamageType.Light)
{
x = lightResistance;
}
else if (_type == Damage.DamageType.Normal)
{
x = armor;
}
else if (_type == Damage.DamageType.Soul)
{
x = soulResistance;
}
else if (_type == Damage.DamageType.Thunder)
{
x = thunderResistance;
}
else if (_type == Damage.DamageType.Water)
{
x = waterResistance;
}
else if (_type == Damage.DamageType.Wind)
{
x = windResistance;
}
return(new Resistance(x, _type));
}
public void FinalizeStats()
{
energyPoints = 15 + (int)(playerLevel * (1.35f + (playerLevel / 5f)));
minDamage_P = 1 + (int)(minDamage_P * (1 + (damageP / 100f)) + bonusDamage + (strength / 2f));
maxDamage_P = 3 + (int)(maxDamage_P * (1 + (damageP / 100f)) + bonusDamage + (strength / 2f));
healthPoints = 25 + (int)((healthPoints) * (1 + (healthPointsP / 100f)));
spellPoints = 15 + (int)((spellPoints) * (1 + (spellPointsP / 100f)));
energyPoints = 5 + (int)((energyPoints) * (1 + (energyPointsP / 100f)));
magicFindP = (int)((mluck * 0.7f) + ((playerLevel / 2f) * (mluck / 5f)));
moneyFindP = (int)((mluck * 1.1f) + ((playerLevel / 2f) * (mluck / 5f)));
critChance = 5 + (int)(perception / (playerLevel * 1.3f) + 5);
critDamage = (int)(ferocity / (playerLevel * 1.3f) + 50);
if (magicFindP >= 9950)
{
magicFindP = 9950;
}
Lucky = magicFindP;
if (Lucky >= 9950)
{
Lucky = 9950;
}
Debug.Log("LootRoll is : (" + (Lucky * 10).ToString() + ",100000) ");
if (speed < 1)
{
speed = 1;
}
GetComponent <Player_Movement>().speed = (speed * 1.0f);
// set weapon element
var p_Main = GetComponent <Player_Main>();
if (p_Main.pE.equipSlots[5].item != null)
{
primaryDamage = p_Main.pE.equipSlots[5].item.d_Type;
primaryOTDamage = p_Main.pE.equipSlots[5].item.do_Type;
}
else
{
primaryDamage = Damage.DamageType.Normal;
primaryOTDamage = Damage_OT.Damage_OTType.Normal;
}
UpdateUI();
}
public float GetBlockEfficiency(Damage.DamageType type)
{
switch (type)
{
case Damage.DamageType.physical:
return(physicalBlockFactor);
case Damage.DamageType.heat:
return(heatBlockFactor);
case Damage.DamageType.explosion:
return(explosionBlockFactor);
default:
return(physicalBlockFactor);
}
}
// Checks to see which enchant is the most powerful
public void SetPrimaryWeaponEnchantAttributes()
{
Enchant primary = null;
if (enchants != null)
{
foreach (Enchant e in enchants)
{
if (e.type == Enchant.EnchantTypes.Damage_T1 || e.type == Enchant.EnchantTypes.Damage_T2 || e.type == Enchant.EnchantTypes.Damage_T3)
{
if (primary != null)
{
if (e.power > primary.power)
{
primary = e;
if (primary != null)
{
d_Type = primary.e_dType;
if (do_Type == Damage_OT.Damage_OTType.Normal && e.e_doType != Damage_OT.Damage_OTType.Normal)
{
do_Type = primary.e_doType;
}
}
}
}
else
{
primary = e;
if (primary != null)
{
d_Type = primary.e_dType;
if (do_Type == Damage_OT.Damage_OTType.Normal && e.e_doType != Damage_OT.Damage_OTType.Normal)
{
do_Type = primary.e_doType;
}
}
}
}
}
}
}
public override void TakeDamage(Damage.DamageType type, int amount)
{
if (type != Damage.DamageType.Healing && !states.isInvincible)
{
currentHealth -= amount;
healthText.text = "Health: " + currentHealth;
states.isSliding = false;
states.isGrabbed = false;
teleport.teleportSpriteRenderer.enabled = false;
states.isInvincible = true;
movement.velocity = Vector2.zero;
Time.timeScale = 0f;
StartCoroutine(ResetAfterDamage());
}
if (type == Damage.DamageType.Healing)
{
currentHealth = Mathf.Min(currentHealth + amount, maxHealth);
healthText.text = "Health: " + currentHealth;
}
}
public static void OnReceiveDamage(Obj_AI_Hero hero, Damage.DamageType type, double amount, string spellName)
{
//Setup the variables that the shields conditional checks will use.
var args = new ActiveEventArgs
{
Target = hero,
SpellName = spellName,
DamageAmount = amount,
DamageType = type,
};
if (!Config.Menu.Item("shield" + hero.ChampionName).GetValue <bool>())
{
return;
}
//Pro-debugging.
Console.WriteLine(hero.ChampionName + " is receiving " + amount + " damage (" + (amount / hero.Health * 100) + ")");
for (var i = 1; i <= 5; i++)
{
//Avoid using more than 1 shield, maybe in the future check the shield amount to stack them.
foreach (var shield in Shields)
{
if (GetShieldConfig <bool>(shield, "Enabled") &&
i == GetShieldConfig <Slider>(shield, "Priority").Value&&
(shield.CanTargetAllies || hero.IsMe) &&
((amount / hero.Health * 100 >= GetShieldConfig <Slider>(shield, "HealthPercent").Value) || (shield.ForceCastCondition != null && shield.ForceCastCondition(Effects.Shield, args))) &&
(shield.CheckCondition == null || shield.CheckCondition(Effects.Shield, args)) &&
shield.Cast(hero))
{
return;
}
}
}
}
internal static float GetDamageCalc(Obj_AI_Base Sender, Obj_AI_Base Target, Damage.DamageType Type, double Equation = 0d)
{
return((float)Damage.CalcDamage(Sender, Target, Type, Equation));
}
public void SetDamageType(Damage.DamageType type)
{
damageType = type;
}
public Resistance(int _amount, Damage.DamageType _type)
{
SetResistanceType(_type);
SetResistanceAmount(_amount);
}
public void SetResistanceType(Damage.DamageType t)
{
type = t;
}
public DamageTypeValueStruct(Damage.DamageType type, float value = 1f)
{
DamageType = type;
Value = value;
}
public static int CalculateElementDamageToMonster(Damage x, Monster y)
{
Damage.DamageType dt = x.GetDamageType();
Damage.DamageType mt = y.mobElement;
int d = 0;
if ((int)dt == (int)mt) // If attack element is same element as monster
{
if (x.isBasic)
{
d = (int)((x.GetDamageAmount() / 2f)) * -1; // heal 50% damage
}
else if (x.isSpecial)
{
d = (int)(x.GetDamageAmount() * -1f); // heal 100% damage
}
else if (x.isPowerful)
{
d = (int)((x.GetDamageAmount() * -1.5f)); // heal 150% damage
}
else
{
d = (x.GetDamageAmount());
}
}
else if ((int)dt != (int)mt) // If attack element isn't the same as monster element
{
if (x.isBasic)
{
if ((dt == Damage.DamageType.Fire && mt == Damage.DamageType.Ice) || // Effective Basic
(dt == Damage.DamageType.Water && mt == Damage.DamageType.Fire) ||
(dt == Damage.DamageType.Ice && mt == Damage.DamageType.Earth) ||
(dt == Damage.DamageType.Thunder && mt == Damage.DamageType.Water) ||
(dt == Damage.DamageType.Earth && mt == Damage.DamageType.Thunder))
{
d = (int)(x.GetDamageAmount() * 1.5f);
}
else if ((dt == Damage.DamageType.Fire && mt == Damage.DamageType.Water) || // Not-Effective Basic
(dt == Damage.DamageType.Water && mt == Damage.DamageType.Thunder) ||
(dt == Damage.DamageType.Ice && mt == Damage.DamageType.Fire) ||
(dt == Damage.DamageType.Thunder && mt == Damage.DamageType.Earth) ||
(dt == Damage.DamageType.Earth && mt == Damage.DamageType.Ice) ||
(dt == Damage.DamageType.Wind && mt == Damage.DamageType.Wind))
{
d = (int)(x.GetDamageAmount() * 0.5f);
}
else
{
d = (x.GetDamageAmount());
}
}
else if (x.isSpecial)
{
if ((dt == Damage.DamageType.Light && mt == Damage.DamageType.Dark) ||
(dt == Damage.DamageType.Dark && mt == Damage.DamageType.Light))
{
d = (int)(x.GetDamageAmount() * 2.0f);
}
else
{
d = (int)(x.GetDamageAmount() * 1.0f);
}
}
else if (x.isPowerful)
{
if ((dt == Damage.DamageType.Soul && mt != Damage.DamageType.Soul))
{
d = (int)((x.GetDamageAmount() * 1.5f));
}
}
else // Normal Attack
{
d = (x.GetDamageAmount());
}
}
return(d);
}
public abstract void TakeDamage(Damage.DamageType type, int amount);
public static ReductionDamageResult ComputeReductions(AIHeroClient source, Obj_AI_Base attacker, Damage.DamageType damageType)
{
double flatDamageReduction = 0;
double percentDamageReduction = 1;
foreach (var reduction in Reductions)
{
if (source == null ||
!source.HasBuff(reduction.BuffName) ||
reduction.DamageType != null && damageType != reduction.DamageType)
{
continue;
}
switch (reduction.Type)
{
case DamageReduction.ReductionDamageType.Flat:
flatDamageReduction += reduction.GetDamageReduction(source, attacker);
break;
case DamageReduction.ReductionDamageType.Percent:
percentDamageReduction *= 1 - reduction.GetDamageReduction(source, attacker) / 100;
break;
}
}
return(new ReductionDamageResult(flatDamageReduction, percentDamageReduction));
}
