public static void CharacterBody_RecalculateStats(On.RoR2.CharacterBody.orig_RecalculateStats orig, CharacterBody self)
{
orig(self);
if (self)
{
if (self.HasBuff(Survivor.Buffs.enrageBuff))
{
self.armor += Core.Config.specialBonusArmor.Value;
}
if (self.HasBuff(Survivor.Buffs.earthshockBuff))
{
float bonusSpeed = self.moveSpeed * Core.Config.utilityBonusMoveSpeed.Value;
float bonusJumpHeight = self.jumpPower * Core.Config.utilityBonusJumpPower.Value;
self.moveSpeed += bonusSpeed;
self.jumpPower += bonusJumpHeight;
}
if (self.HasBuff(Survivor.Buffs.earthshockDebuff))
{
self.moveSpeed *= States.Earthshock.debuffSlow;
if (!self.gameObject.GetComponent <Miscellaneous.AntiFlyingComponent>())
{
self.gameObject.AddComponent <Miscellaneous.AntiFlyingComponent>();
}
}
}
}
private void FixedUpdate()
{
//Tick up the stopwatch
this.trackerUpdateStopwatch += Time.fixedDeltaTime;
//If the stopwatch has gone on for .1 seconds...
if (this.trackerUpdateStopwatch >= 1f / this.trackerUpdateFrequency)
{
//Reset the timer
this.trackerUpdateStopwatch -= 1f / this.trackerUpdateFrequency;
//Poisoncounter to 0 cause we haven't found any poisoned creatures yet
this.poisonCounter = 0;
//Spheresearch it
foreach (HurtBox hurtBox in new SphereSearch
{
origin = characterBody.footPosition,
radius = this.maxTrackingDistance,
mask = LayerIndex.entityPrecise.mask
}.RefreshCandidates().FilterCandidatesByHurtBoxTeam(TeamMask.GetEnemyTeams(this.teamComponent.teamIndex)).OrderCandidatesByDistance().FilterCandidatesByDistinctHurtBoxEntities().GetHurtBoxes())
{
//Get the targets body component
CharacterBody body = hurtBox.healthComponent.body;
//Make sure they stats ain't brokeded
body.RecalculateStats();
//If they have either buff, tick up the counter
if (body.HasBuff(RoR2Content.Buffs.Poisoned) || body.HasBuff(RoR2Content.Buffs.Blight))
{
this.poisonCounter += 1;
}
}
//Set the totalpoisoned count to what we found
this.totalPoisoned = this.poisonCounter;
}
}
private void GenericSkill_OnExecute(On.RoR2.GenericSkill.orig_OnExecute orig, GenericSkill self)
{
var invCount = GetCount(self.characterBody);
CharacterBody vBody = self.characterBody;
if (vBody.skillLocator.FindSkill(self.skillName))
{
if (invCount > 0)
{
if (vBody.skillLocator.utility.Equals(self)) //is this redundant?
{
if (vBody.HasBuff(MachoBrace_Boost)) //should prevent weird stacking
{
vBody.RemoveBuff(MachoBrace_Boost);
}
vBody.AddBuff(MachoBrace_Boost);
}
else
{
if (vBody.HasBuff(MachoBrace_Boost))
{
vBody.RemoveBuff(MachoBrace_Boost);
}
}
}
}
orig(self);
}
private void CharacterBody_RecalculateStats(On.RoR2.CharacterBody.orig_RecalculateStats orig, CharacterBody self)
{
orig(self);
if (self)
{
if (self.HasBuff(Modules.Buffs.warcryBuff))
{
float damageBuff = StaticValues.warcryDamageMultiplier * self.damage;
self.damage += damageBuff;
self.attackSpeed += StaticValues.warcryAttackSpeedBuff;
}
if (self.HasBuff(Modules.Buffs.scepterWarcryBuff))
{
float damageBuff = StaticValues.scepterWarcryDamageMultiplier * self.damage;
self.damage += damageBuff;
self.attackSpeed += StaticValues.scepterWarcryAttackSpeedBuff;
}
if (self.HasBuff(Modules.Buffs.torporDebuff))
{
self.moveSpeed *= (1 - StaticValues.torporSlowAmount);
self.attackSpeed *= (1 - StaticValues.torporSlowAmount);
}
if (self.HasBuff(Modules.Buffs.scepterTorporDebuff))
{
self.moveSpeed *= (1 - StaticValues.scepterTorporSlowAmount);
self.attackSpeed *= (1 - StaticValues.scepterTorporSlowAmount);
}
}
}
private static float GetArmorDelta(CharacterBody self)
{
float addedArmor = 0f;
float lostArmor = 0f;
float count;
if (self.HasBuff(RoR2Content.Buffs.AffixHaunted) && Configuration.AspectHauntedBaseArmorGain.Value > 0f)
{
count = Catalog.GetStackMagnitude(self, RoR2Content.Buffs.AffixHaunted);
addedArmor += Configuration.AspectHauntedBaseArmorGain.Value + Configuration.AspectHauntedStackArmorGain.Value * (count - 1f);
}
else if (self.HasBuff(RoR2Content.Buffs.AffixHauntedRecipient) && Configuration.AspectHauntedAllyArmorGain.Value > 0f)
{
addedArmor += Configuration.AspectHauntedAllyArmorGain.Value;
}
if (self.HasBuff(Catalog.Buff.AffixPlated) && Configuration.AspectPlatedBaseArmorGain.Value > 0f)
{
count = Catalog.GetStackMagnitude(self, Catalog.Buff.AffixPlated);
addedArmor += Configuration.AspectPlatedBaseArmorGain.Value + Configuration.AspectPlatedStackArmorGain.Value * (count - 1f);
}
if (self.HasBuff(Catalog.Buff.ZetHeadHunter))
{
addedArmor += Configuration.HeadHunterBuffArmor.Value * self.GetBuffCount(Catalog.Buff.ZetHeadHunter);
}
if (self.HasBuff(Catalog.Buff.ZetShredded))
{
lostArmor += Mathf.Abs(Configuration.AspectHauntedShredArmor.Value);
}
//if (self.teamComponent.teamIndex == TeamIndex.Player) lostArmor *= Configuration.AspectEffectPlayerDebuffMult.Value;
return(addedArmor - lostArmor);
}
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 bool IsTickDamageEvent(DamageReportHandler damageReportHandler)
{
CharacterBody victim = damageReportHandler.Victim;
EnsureIsCachedAndAlive(victim);
if (!TickDebuffCache.ContainsKey(GetVictimNetworkUserId(victim)))
{
return(false);
}
switch (damageReportHandler.TickingDebuffIndex)
{
case (DotController.DotIndex.Burn):
if (!victim.HasBuff(BuffIndex.OnFire) && IsCached(victim, DotController.DotIndex.Burn))
{
RemoveDebuff(victim, DotController.DotIndex.Burn);
return(false);
}
return(CheckNew(victim, DotController.DotIndex.Burn));
case (DotController.DotIndex.PercentBurn):
if (!victim.HasBuff(BuffIndex.OnFire) && IsCached(victim, DotController.DotIndex.PercentBurn))
{
RemoveDebuff(victim, DotController.DotIndex.PercentBurn);
return(false);
}
return(CheckNew(victim, DotController.DotIndex.PercentBurn));
case (DotController.DotIndex.Bleed):
if (!victim.HasBuff(BuffIndex.Bleeding) && IsCached(victim, DotController.DotIndex.Bleed))
{
RemoveDebuff(victim, DotController.DotIndex.Bleed);
return(false);
}
return(CheckNew(victim, DotController.DotIndex.Bleed));
case (DotController.DotIndex.Blight):
if (!victim.HasBuff(BuffIndex.Blight) && IsCached(victim, DotController.DotIndex.Blight))
{
RemoveDebuff(victim, DotController.DotIndex.Blight);
return(false);
}
return(CheckNew(victim, DotController.DotIndex.Blight));
case (DotController.DotIndex.Poison):
if (!victim.HasBuff(BuffIndex.Poisoned) && IsCached(victim, DotController.DotIndex.Poison))
{
RemoveDebuff(victim, DotController.DotIndex.Poison);
return(false);
}
return(CheckNew(victim, DotController.DotIndex.Poison));
default:
return(false);
}
}
public void Update()
{
if (!body || !body.transform)
{
return;
}
if (NetworkServer.active)
{
if (target)
{
HealthComponent healthComponent = target.healthComponent;
if (!target.HasBuff(buffDef) || !healthComponent || !healthComponent.alive)
{
ClearTarget();
}
}
}
stopwatch += Time.deltaTime;
waveY = Mathf.Sin(stopwatch * Mathf.PI * waveFrequency + waveOffset * Mathf.PI * 2) * waveAmplitude;
if (target)
{
leash.leashOrigin = target.corePosition + offset * target.radius + Vector3.up * waveY;
rotateToDirection.targetRotation = Util.QuaternionSafeLookRotation(target.corePosition - transform.position);
}
else
{
leash.leashOrigin = body.corePosition + offset * body.radius + Vector3.up * waveY;
rotateToDirection.targetRotation = Quaternion.LookRotation(body.inputBank.aimDirection);
}
ItemDisplay itemDisplay = follower.GetComponent <ItemDisplay>();
ModelLocator modelLocator = body.modelLocator;
if (modelLocator)
{
Transform modelTransform = modelLocator.modelTransform;
if (modelTransform)
{
CharacterModel characterModel = modelTransform.GetComponent <CharacterModel>();
if (characterModel)
{
itemDisplay.SetVisibilityLevel(characterModel.visibility);
foreach (CharacterModel.RendererInfo rendererInfo in itemDisplay.rendererInfos)
{
Renderer renderer = rendererInfo.renderer;
renderer.GetPropertyBlock(materialPropertyBlock);
materialPropertyBlock.SetFloat("_Fade", target ? 1f : 1f / body.inventory.GetItemCount(MysticsItemsContent.Items.MysticsItems_Spotter));
renderer.SetPropertyBlock(materialPropertyBlock);
}
}
}
}
}
void FixedUpdate()
{
if (!characterBody.HasBuff(charmDef))
{
if (Overlay)
{
Destroy(Overlay);
}
enabled = false;
}
}
private static void StatHooks_GetStatCoefficients(CharacterBody sender, StatHookEventArgs args)
{
if (sender.HasBuff(Anger))
{
args.damageMultAdd += Config_Enrage_Damage;
}
if (sender.HasBuff(Jammed))
{
args.damageMultAdd += curse.JammedDamageBoost;
args.critAdd += curse.JammedCritBoost;
args.attackSpeedMultAdd += curse.JammedAttackSpeedBoost;
args.moveSpeedMultAdd += curse.JammedMoveSpeedBoost;
args.baseHealthAdd += curse.JammedHealthBoost;
}
}
private void RecalculateStats_On(HooksCore.RoR2.CharacterBody.RecalculateStats.Orig orig, CharacterBody self)
{
orig(self);
if (self && self.inventory)
{
if (self.HasBuff(RW_armorBuff))
{
self.armor += 75f;
}
if (self.HasBuff(RW_flameChargeBuff))
{
self.barrierDecayRate *= barrierDecayMult;
}
}
}
private void Evt_TILER2GetStatCoefficients(CharacterBody sender, StatHookEventArgs args)
{
if (sender.HasBuff(healBuff))
{
args.regenMultAdd += regenMod;
}
if (sender.HasBuff(attackBuff))
{
args.attackSpeedMultAdd += attackMod;
}
if (sender.HasBuff(speedBuff))
{
args.moveSpeedMultAdd += speedMod;
}
}
private void ClearBuffs(CharacterBody body)
{
if (body.HasBuff(SniperContent.spotterBuff))
{
body.RemoveBuff(SniperContent.spotterBuff);
}
if (body.HasBuff(SniperContent.spotterStatDebuff))
{
body.RemoveBuff(SniperContent.spotterStatDebuff);
}
if (body.HasBuff(SniperContent.spotterScepterBuff))
{
body.RemoveBuff(SniperContent.spotterScepterBuff);
}
}
private void RecalculateStatsAPI_GetStatCoefficients(CharacterBody sender, R2API.RecalculateStatsAPI.StatHookEventArgs args)
{
if (sender.HasBuff(buffDef))
{
args.moveSpeedMultAdd += moveSpeedBuff / 100f;
}
}
public override void OnEnter()
{
base.OnEnter();
if (NetworkServer.active)
{
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(base.teamComponent.teamIndex);
Vector3 position = base.transform.position;
for (int i = 0; i < teamMembers.Count; i++)
{
CharacterBody component = teamMembers[i].GetComponent <CharacterBody>();
if (component)
{
if (base.characterBody.skillLocator.utility.stock > 0 && !component.HasBuff(BuffIndex.EngiShield) && !component.HasBuff(BuffIndex.ElephantArmorBoost))
{
component.AddTimedBuff(BuffIndex.EngiShield, 3f);
component.AddTimedBuff(BuffIndex.Immune, 3f);
component.AddTimedBuff(BuffIndex.ElephantArmorBoost, 6f);
HealthComponent component2 = component.GetComponent <HealthComponent>();
if (component2)
{
component2.RechargeShieldFull();
}
base.skillLocator.utility.DeductStock(1);
}
}
}
}
base.OnExit();
base.outer.SetNextStateToMain();
}
private void CharacterBody_RecalculateStats(On.RoR2.CharacterBody.orig_RecalculateStats orig, CharacterBody self)
{
orig(self);
if (self)
{
if (self.HasBuff(Modules.Buffs.scaredDebuff))
{
}
if (self.HasBuff(Modules.Buffs.scaredBuildingDebuff))
{
self.attackSpeed = 0f;
self.moveSpeed = 0f;
}
}
}
private void CharacterBody_FixedUpdate(Action <RoR2.CharacterBody> orig, CharacterBody self)
{
orig(self);
if (self.HasBuff(this.buffIndex))
{
}
}
public static void PlayCloakDamageSound(CharacterBody cb)
{
if (cb && cb.HasBuff(ModContentPack.cloakDamageBuff))
{
Util.PlaySound("Play_BanditReloaded_cloakdamage", cb.gameObject);
}
}
/// <summary>
/// Safely removes a buff from the target character body
/// </summary>
/// <param name="buffToRemove">The buff you want to safely remove</param>
/// <param name="body">The body you safely want to remove a buff from.</param>
public static void SafeRemoveBuff(BuffDef buffToRemove, CharacterBody body)
{
if (body && body.HasBuff(buffToRemove))
{
body.RemoveBuff(buffToRemove);
}
}
private void Mustache_StatCoefficients(CharacterBody sender, RecalculateStatsAPI.StatHookEventArgs args)
{
if (sender && sender.HasBuff(Buffs.MustacheBuff))
{
args.baseRegenAdd += RegenAmount.Value + RegenAmountPerStack.Value * (GetCount(sender) - 1);
}
}
private void Thallium_GetStatCoefficients(CharacterBody sender, StatHookEventArgs args)
{
if (sender.HasBuff(poisonBuff))
{
args.moveSpeedMultAdd -= slowMultiplier;
}
}
public DamageInfo CalculateNewDamage(DamageInfo damageInfo)
{
//TODO: Replace the curseCount with a buff that can be displayed to user
damageInfo.damage *= 1 + (curseMultiplier * curseCount);
CharacterBody testBody = null;
if (damageInfo.attacker)
{
testBody = damageInfo.attacker.GetComponent <CharacterBody>();
}
else if (damageInfo.inflictor)
{
testBody = damageInfo.inflictor.GetComponent <CharacterBody>();
}
//Try and capture the affix type of the attacker/inflictor
foreach (AffixTracker tracker in affixTrackers)
{
//Set the curse flag if its a match
if (testBody && testBody.isElite && testBody.HasBuff(tracker.buffIndex))
{
mostRecentAttackIndex = tracker.buffIndex;
//Chat.AddMessage("Most Recent Damage Type Was : " + tracker.affixNameTag);
break;
}
}
return(damageInfo);
}
public override void OnEnter()
{
base.OnEnter();
if (base.teamComponent && NetworkServer.active)
{
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(base.teamComponent.teamIndex);
Vector3 position = base.transform.position;
for (int i = 0; i < teamMembers.Count; i++)
{
CharacterBody component = teamMembers[i].GetComponent <CharacterBody>();
if (component)
{
if (base.characterBody.skillLocator.utility.stock > 0 && !component.HasBuff(BuffIndex.EngiTeamShield))
{
component.AddTimedBuff(BuffIndex.EngiTeamShield, 8f);
component.AddTimedBuff(BuffIndex.TeslaField, 2f);
HealthComponent component2 = component.GetComponent <HealthComponent>();
if (component2)
{
component2.RechargeShieldFull();
}
base.skillLocator.utility.DeductStock(1);
}
}
}
}
}
private void AddSpeedReward(CharacterBody sender, StatHookEventArgs args)
{
if (sender.HasBuff(SpeedBuff))
{
args.moveSpeedMultAdd += moveSpeedPercentageBonusPerBuffStack * sender.GetBuffCount(SpeedBuff);
}
}
private static void ModifyCrit(CharacterBody self)
{
float addedCrit = 0f;
if (self.HasBuff(Catalog.Buff.ZetHeadHunter))
{
addedCrit += Configuration.HeadHunterBuffCritChance.Value * self.GetBuffCount(Catalog.Buff.ZetHeadHunter);
}
if (addedCrit > 0f)
{
Inventory inventory = self.inventory;
if (inventory)
{
if (inventory.GetItemCount(DLC1Content.Items.ConvertCritChanceToCritDamage) == 0)
{
self.crit += addedCrit;
}
else
{
self.critMultiplier += addedCrit * 0.01f;
}
}
}
}
public void FixedUpdate()
{
if (characterBody && characterBody.HasBuff(BuffIndex.ClayGoo))
{
characterBody.rigidbody.velocity += Vector3.up * 20f;
}
}
private void Extinguish(CharacterBody characterBody)
{
if (characterBody.HasBuff(BuffIndex.OnFire))
{
Chat.AddMessage("cured " + characterBody.GetUserName());
characterBody.ClearTimedBuffs(BuffIndex.OnFire);
if (DotController.dotControllerLocator.TryGetValue(characterBody.gameObject.GetInstanceID(), out DotController dotController))
{
//var burnEffectController = dotController.burnEffectController;
var dotStacks = dotController.dotStackList;
int i = 0;
int count = dotStacks.Count;
while (i < count)
{
if (dotStacks[i].dotIndex == DotController.DotIndex.Burn ||
dotStacks[i].dotIndex == DotController.DotIndex.Helfire ||
dotStacks[i].dotIndex == DotController.DotIndex.PercentBurn)
{
dotStacks[i].damage = 0f;
dotStacks[i].timer = 0f;
}
i++;
}
}
}
}
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);
}
private void On_GEMOnHitEnemy(On.RoR2.GlobalEventManager.orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
{
orig(self, damageInfo, victim);
if (!NetworkServer.active || !damageInfo.attacker)
{
return;
}
CharacterBody body = damageInfo.attacker.GetComponent <CharacterBody>();
if (!body || !body.HasBuff(pillageBuff))
{
return;
}
CharacterMaster chrm = body.master;
if (!chrm)
{
return;
}
int mamt = Run.instance.GetDifficultyScaledCost(body.GetBuffCount(pillageBuff));
if (Compat_ShareSuite.enabled && Compat_ShareSuite.MoneySharing())
{
Compat_ShareSuite.GiveMoney((uint)mamt);
}
else
{
chrm.GiveMoney((uint)mamt);
}
}
void OnEnable()
{
//ContactDamageCooldown = ContactDamageCooldownFull;
characterBody = gameObject.GetComponent <CharacterBody>();
if (!characterBody)
{
_logger.LogError("No characterbody found for jammed enemy!");
return;
}
if (!characterBody.HasBuff(Shared.Buffs.BuffsController.Jammed))
{
characterBody.AddBuff(Shared.Buffs.BuffsController.Jammed);
}
if (characterBody.inventory && characterBody.inventory.GetItemCount(CurseController.isJammedItem) == 0)
{
characterBody.inventory.GiveItem(CurseController.isJammedItem);
}
ModelLocator modelLocator = gameObject.GetComponent <ModelLocator>();
if (modelLocator)
{
if (!fireEffect)
{
fireEffect = Object.Instantiate <GameObject>(instance.jammedFire, modelLocator.modelTransform.Find("ROOT").transform);
//fireEffect.transform.parent = modelLocator.modelTransform;
}
}
var deathBehaviour = gameObject.GetComponent <CharacterDeathBehavior>();
if (deathBehaviour)
{
characterDeathBehavior = deathBehaviour;
}
}