public override float RecalculateDamage(float baseValue, CharacterBody character)
{
float BaseDamage = character.baseDamage + character.levelDamage * (character.level - 1);
BaseDamage += ModItemManager.GetBonusForStat(character, StatIndex.Damage);
float DamageBoost = 0;
int DamageBoostCount = character.inventory ? character.inventory.GetItemCount(ItemIndex.BoostDamage) : 0;
if (DamageBoostCount > 0)
{
DamageBoost += DamageBoostCount * DamageBoost;
}
DamageBoost -= 0.05f * character.GetBuffCount(BuffIndex.BeetleJuice);
if (character.HasBuff(BuffIndex.GoldEmpowered))
{
DamageBoost += 1;
}
float DamageMult = DamageBoost + (character.CalcLunarDaggerPower());
DamageMult += ModItemManager.GetMultiplierForStat(character, StatIndex.Damage);
return(BaseDamage * DamageMult);
}
public override float RecalculateArmor(float baseValue, CharacterBody character)
{
float BaseArmor = character.baseArmor + character.levelArmor * (character.level - 1);
float BonusArmor = 0;
if (character.HasBuff(BuffIndex.ArmorBoost))
{
BonusArmor += 200;
}
if (character.HasBuff(BuffIndex.Cripple))
{
BonusArmor -= 20;
}
float TotalArmor = BaseArmor + BonusArmor;
TotalArmor += ModItemManager.GetBonusForStat(character, StatIndex.Armor);
if (character.isSprinting)
{
TotalArmor += ModItemManager.GetBonusForStat(character, StatIndex.RunningArmor);
}
TotalArmor *= 1 + ModItemManager.GetMultiplierForStat(character, StatIndex.Armor);
if (character.isSprinting)
{
TotalArmor *= 1 + ModItemManager.GetMultiplierForStat(character, StatIndex.RunningArmor);
}
return(TotalArmor);
}
public override float RecalculateJumpCount(float baseValue, CharacterBody character)
{
float JumpCount = character.baseJumpCount + ModItemManager.GetBonusForStat(character, StatIndex.JumpCount);
JumpCount *= 1 + ModItemManager.GetMultiplierForStat(character, StatIndex.JumpCount);
return(JumpCount);
}
public override float RecalculateJumpPower(float baseValue, CharacterBody character)
{
float JumpPower = character.baseJumpPower + character.levelJumpPower * (character.level - 1) + ModItemManager.GetBonusForStat(character, StatIndex.JumpPower);
JumpPower *= 1 + ModItemManager.GetMultiplierForStat(character, StatIndex.JumpPower);
return(JumpPower);
}
public override float RecalculateRegen(float baseValue, CharacterBody character)
{
float BaseRegen = (character.baseRegen + character.levelRegen * (character.level - 1)) * 2.5f;
float RegenBonus = 0;
float regenmult = 1;
//Item Related
if ((bool)character.inventory)
{
RegenBonus += ModItemManager.GetBonusForStat(character, StatIndex.Regen);
if (character.outOfDanger)
{
RegenBonus += ModItemManager.GetBonusForStat(character, StatIndex.SafeRegen);
}
if (character.inventory.GetItemCount(ItemIndex.HealthDecay) > 0)
{
RegenBonus -= character.maxHealth / character.inventory.GetItemCount(ItemIndex.HealthDecay);
}
regenmult += ModItemManager.GetMultiplierForStat(character, StatIndex.Regen);
if (character.outOfDanger)
{
regenmult += ModItemManager.GetMultiplierForStat(character, StatIndex.SafeRegen);
}
}
float totalRegen = (BaseRegen * regenmult + RegenBonus);
return(totalRegen);
}
public override float RecalculateSpecialCount(float baseValue, CharacterBody character)
{
float count = 0;
count += ModItemManager.GetBonusForStat(character, StatIndex.CountUtility);
count *= 1 + ModItemManager.GetMultiplierForStat(character, StatIndex.CountUtility);
return(count);
}
public override float RecalculateUtilityCooldown(float baseValue, CharacterBody character)
{
float CoolDownMultiplier = 1f;
CoolDownMultiplier += ModItemManager.GetBonusForStat(character, StatIndex.CoolDownSpecial);
CoolDownMultiplier *= ModItemManager.GetMultiplierForStatCD(character, StatIndex.CoolDownSpecial);
return(CoolDownMultiplier);
}
static public void Init()
{
m_RecalulateList = new List <ModRecalculateCustom>
{
new DefaultRecalculate()
};
ModItemManager.Init();
ModEffects.Init();
On.RoR2.CharacterBody.RecalculateStats += ModdedRecalculate;
}
static public void ModdedHitAll(On.RoR2.GlobalEventManager.orig_OnHitAll orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
{
if ((double)damageInfo.procCoefficient == 0.0)
{
return;
}
int Host = NetworkServer.active ? 1 : 0;
if (!(bool)((UnityEngine.Object)damageInfo.attacker))
{
return;
}
CharacterBody component = damageInfo.attacker.GetComponent <CharacterBody>();
if (!(bool)((UnityEngine.Object)component))
{
return;
}
CharacterMaster master = component.master;
if (!(bool)((UnityEngine.Object)master))
{
return;
}
Inventory inventory = master.inventory;
if (!(bool)((UnityEngine.Object)master.inventory))
{
return;
}
damageInfo.procChainMask.LinkToManager();
ModItemManager.OnHitAllEffects(self, damageInfo, victim);
//Buff
if ((component.HasBuff(BuffIndex.AffixBlue) ? 1 : 0) <= 0)
{
return;
}
float damage = damageInfo.damage * 0.5f;
float force = 0.0f;
Vector3 position = damageInfo.position;
#pragma warning disable CS0618 //Obsolete warning
ProjectileManager.instance.FireProjectile(Resources.Load <GameObject>("Prefabs/Projectiles/LightningStake"), position, Quaternion.identity, damageInfo.attacker, damage, force, damageInfo.crit, DamageColorIndex.Item, (GameObject)null, -1f);
#pragma warning restore CS0618
damageInfo.procChainMask.UnlinkToManager();
}
static public void ModdedHitEnemy(On.RoR2.GlobalEventManager.orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
{
if (damageInfo.procCoefficient == 0 || !NetworkServer.active || (!(bool)damageInfo.attacker || damageInfo.procCoefficient <= 0))
{
return;
}
CharacterBody Attacker = damageInfo.attacker.GetComponent <CharacterBody>();
CharacterBody characterBody = victim ? victim.GetComponent <CharacterBody>() : null;
if (!Attacker)
{
return;
}
CharacterMaster master = Attacker.master;
if (!master)
{
return;
}
damageInfo.procChainMask.LinkToManager();
Inventory inventory = master.inventory;
TeamComponent Team = Attacker.GetComponent <TeamComponent>();
TeamIndex attackerTeamIndex = Team ? Team.teamIndex : TeamIndex.Neutral;
Vector3 aimOrigin = Attacker.aimOrigin;
ModItemManager.OnHitEnemyEffects(self, damageInfo, victim);
//SetOnFire . Can't realy do much for this one
int DamageType = (uint)(damageInfo.damageType & RoR2.DamageType.IgniteOnHit) > 0U ? 1 : 0;
bool CanSetFire = (damageInfo.damageType & RoR2.DamageType.PercentIgniteOnHit) != RoR2.DamageType.Generic || Attacker.HasBuff(BuffIndex.AffixRed);
int num2 = CanSetFire ? 1 : 0;
if ((DamageType | num2) != 0)
{
DotController.InflictDot(victim, damageInfo.attacker, CanSetFire ? DotController.DotIndex.PercentBurn : DotController.DotIndex.Burn, 4f * damageInfo.procCoefficient, 1f);
}
//Apply Ice Elite (Will have to wait for Buff Change for that)
if ((Attacker.HasBuff(BuffIndex.AffixWhite) ? 1 : 0) > 0 && (bool)((UnityEngine.Object)characterBody))
{
characterBody.AddTimedBuff(BuffIndex.Slow80, 1.5f * damageInfo.procCoefficient);
}
damageInfo.procChainMask.UnlinkToManager();
}
public override float RecalculateCrit(float baseValue, CharacterBody character)
{
float CriticalChance = character.baseCrit + character.levelCrit * (character.level - 1);
CriticalChance += ModItemManager.GetBonusForStat(character, StatIndex.Crit);
CriticalChance *= 1 + ModItemManager.GetMultiplierForStat(character, StatIndex.AttackSpeed);
if (character.HasBuff(BuffIndex.FullCrit))
{
CriticalChance += 100;
}
return(CriticalChance);
}
public override float RecalculateGeneralCooldown(float baseValue, CharacterBody character)
{
float CoolDownMultiplier = 1f;
CoolDownMultiplier += ModItemManager.GetBonusForStat(character, StatIndex.GlobalCoolDown);
CoolDownMultiplier *= ModItemManager.GetMultiplierForStatCD(character, StatIndex.GlobalCoolDown);
if (character.HasBuff(BuffIndex.GoldEmpowered))
{
CoolDownMultiplier *= 0.25f;
}
if (character.HasBuff(BuffIndex.NoCooldowns))
{
CoolDownMultiplier = 0.0f;
}
return(CoolDownMultiplier);
}
public override float RecalculateAttackSpeed(float baseValue, CharacterBody character)
{
float BaseAttackSpeed = character.baseAttackSpeed + character.levelAttackSpeed * (character.level - 1);
//Item efect
float AttackSpeedBonus = 1f;
if (character.inventory)
{
if (character.inventory.currentEquipmentIndex == EquipmentIndex.AffixYellow)
{
AttackSpeedBonus += 0.5f;
}
}
//Buffs
float AttackSpeedMult = AttackSpeedBonus + character.GetFieldValue <int[]>("buffs")[2] * 0.12f;
if (character.HasBuff(BuffIndex.Warbanner))
{
AttackSpeedMult += 0.3f;
}
if (character.HasBuff(BuffIndex.EnrageAncientWisp))
{
AttackSpeedMult += 2f;
}
if (character.HasBuff(BuffIndex.WarCryBuff))
{
AttackSpeedMult += 1f;
}
BaseAttackSpeed += ModItemManager.GetBonusForStat(character, StatIndex.AttackSpeed);
AttackSpeedMult += ModItemManager.GetMultiplierForStat(character, StatIndex.AttackSpeed);
float AttackSpeed = BaseAttackSpeed * AttackSpeedMult;
//Debuff
AttackSpeed *= 1 - (0.05f * character.GetBuffCount(BuffIndex.BeetleJuice));
return(AttackSpeed);
}
public override float RecalculateHealth(float baseValue, CharacterBody character)
{
float MaxHealth = character.baseMaxHealth + (character.level - 1) * character.levelMaxHealth;
float HealthBonusItem = 0;
float hpbooster = 1;
float healthDivider = 1;
if ((bool)character.inventory)
{
HealthBonusItem += ModItemManager.GetBonusForStat(character, StatIndex.MaxHealth);
if (character.inventory.GetItemCount(ItemIndex.Infusion) > 0)
{
HealthBonusItem += character.inventory.infusionBonus;
}
hpbooster += ModItemManager.GetMultiplierForStat(character, StatIndex.MaxHealth);
healthDivider = character.CalcLunarDaggerPower();
}
MaxHealth += HealthBonusItem;
MaxHealth *= hpbooster / healthDivider;
return(MaxHealth);
}
public override float RecalculateShield(float baseValue, CharacterBody character)
{
float MaxShield = character.baseMaxShield + character.levelMaxShield * (character.level - 1);
if (character.inventory)
{
if (character.inventory.GetItemCount(ItemIndex.ShieldOnly) > 0)
{
MaxShield += character.maxHealth * (1.25f + (character.inventory.GetItemCount(ItemIndex.ShieldOnly) - 1) * 0.5f);
character.SetPropertyValue("maxHealth", 1);
}
}
//Buff
if (character.HasBuff(BuffIndex.EngiShield))
{
MaxShield += character.maxHealth * 1f;
}
if (character.HasBuff(BuffIndex.EngiTeamShield))
{
MaxShield += character.maxHealth * 0.5f;
}
//NPC Overload Buff
if (character.GetFieldValue <BuffMask>("buffMask").HasBuff(BuffIndex.AffixBlue))
{
character.SetPropertyValue("maxHealth", character.maxHealth * 0.5f);
MaxShield += character.maxHealth;
}
if (character.inventory)
{
MaxShield += ModItemManager.GetBonusForStat(character, StatIndex.MaxShield);
MaxShield *= (1 + ModItemManager.GetMultiplierForStat(character, StatIndex.MaxShield));
}
return(MaxShield);
}
public override float RecalculateMoveSpeed(float baseValue, CharacterBody character)
{
float BaseMoveSpeed = character.baseMoveSpeed + character.levelMoveSpeed * (character.level - 1);
float SpeedBonus = 1;
//More weird stuff
if ((bool)character.inventory)
{
if (character.inventory.currentEquipmentIndex == EquipmentIndex.AffixYellow)
{
BaseMoveSpeed += 2;
}
}
if (character.isSprinting)
{
BaseMoveSpeed *= character.GetFieldValue <float>("sprintingSpeedMultiplier");
}
//SpeedBonus
if (character.HasBuff(BuffIndex.BugWings))
{
SpeedBonus += 0.2f;
}
if (character.HasBuff(BuffIndex.Warbanner))
{
SpeedBonus += 0.3f;
}
if (character.HasBuff(BuffIndex.EnrageAncientWisp))
{
SpeedBonus += 0.4f;
}
if (character.HasBuff(BuffIndex.CloakSpeed))
{
SpeedBonus += 0.4f;
}
if (character.HasBuff(BuffIndex.TempestSpeed))
{
SpeedBonus += 1;
}
if (character.HasBuff(BuffIndex.WarCryBuff))
{
SpeedBonus += .5f;
}
if (character.HasBuff(BuffIndex.EngiTeamShield))
{
SpeedBonus += 0.3f;
}
SpeedBonus += ModItemManager.GetMultiplierForStat(character, StatIndex.MoveSpeed);
if (character.isSprinting)
{
SpeedBonus += ModItemManager.GetMultiplierForStat(character, StatIndex.RunningMoveSpeed);
}
if (character.outOfCombat && character.outOfDanger)
{
SpeedBonus += ModItemManager.GetMultiplierForStat(character, StatIndex.SafeMoveSpeed);
if (character.isSprinting)
{
SpeedBonus += ModItemManager.GetMultiplierForStat(character, StatIndex.SafeRunningMoveSpeed);
}
}
//Debuff Speed
float SpeedMalus = 1f;
if (character.HasBuff(BuffIndex.Slow50))
{
SpeedMalus += 0.5f;
}
if (character.HasBuff(BuffIndex.Slow60))
{
SpeedMalus += 0.6f;
}
if (character.HasBuff(BuffIndex.Slow80))
{
SpeedMalus += 0.8f;
}
if (character.HasBuff(BuffIndex.ClayGoo))
{
SpeedMalus += 0.5f;
}
if (character.HasBuff(BuffIndex.Slow30))
{
SpeedMalus += 0.3f;
}
if (character.HasBuff(BuffIndex.Cripple))
{
++SpeedMalus;
}
BaseMoveSpeed += ModItemManager.GetBonusForStat(character, StatIndex.MoveSpeed);
if (character.isSprinting)
{
BaseMoveSpeed += ModItemManager.GetBonusForStat(character, StatIndex.RunningMoveSpeed);
}
if (character.outOfCombat && character.outOfDanger)
{
BaseMoveSpeed += ModItemManager.GetBonusForStat(character, StatIndex.SafeMoveSpeed);
if (character.isSprinting)
{
BaseMoveSpeed += ModItemManager.GetBonusForStat(character, StatIndex.SafeRunningMoveSpeed);
}
}
float MoveSpeed = BaseMoveSpeed * (SpeedBonus / SpeedMalus);
if ((bool)character.inventory)
{
MoveSpeed *= 1.0f - 0.05f * character.GetBuffCount(BuffIndex.BeetleJuice);
}
return(MoveSpeed);
}
