private void GrantOnKillEffectsOnHighDamage(On.RoR2.GlobalEventManager.orig_OnHitEnemy orig, RoR2.GlobalEventManager self, RoR2.DamageInfo damageInfo, GameObject victim)
{
var attacker = damageInfo.attacker;
if (attacker)
{
var body = attacker.GetComponent <CharacterBody>();
var victimBody = victim.GetComponent <CharacterBody>();
if (body && victimBody)
{
var InventoryCount = GetCount(body);
if (InventoryCount > 0)
{
if (damageInfo.damage / body.damage >= witchesRingTriggerThreshold && !victimBody.HasBuff(WitchesRingImmunityBuff))
{
if (NetworkServer.active)
{
victimBody.AddTimedBuffAuthority(WitchesRingImmunityBuff, baseCooldownDuration / (1 + additionalCooldownReduction * (InventoryCount - 1)));
DamageReport damageReport = new DamageReport(damageInfo, victimBody.healthComponent, damageInfo.damage, victimBody.healthComponent.combinedHealth);
GlobalEventManager.instance.OnCharacterDeath(damageReport);
}
}
}
}
}
orig(self, damageInfo, victim);
}
private void Evt_GEMOnCharacterDeathGlobal(DamageReport rep)
{
if ((rep.victimBody?.HasBuff(markDebuff) ?? false) && GetCount(rep.attackerBody) > 0)
{
rep.attackerBody.inventory.GiveItem(hitListTally);
}
}
// Token: 0x060028ED RID: 10477 RVA: 0x000AD35D File Offset: 0x000AB55D
private void OnServerDamageDealt(DamageReport damageReport)
{
if (damageReport.victimMaster && damageReport.victimMaster.isBoss)
{
this.OnBossDamageFirstTaken();
}
}
// Token: 0x0600294D RID: 10573 RVA: 0x000ADB34 File Offset: 0x000ABD34
private void OnCharacterDeath(DamageReport damageReport)
{
if (damageReport.victimBody && damageReport.victimBody.bodyIndex == this.overloadingWormBodyIndex && base.IsCurrentBody(damageReport.damageInfo.attacker))
{
base.Grant();
}
}
private void CheckDeathChance(DamageReport damageReport)
{
var InventoryCount = GetCount(damageReport.victimBody);
if (InventoryCount > 0)
{
var DeathChance = deathChanceInitial + ((InventoryCount - 1) * deathChanceStack);
var victim = damageReport.victim;
var attacker = damageReport.attacker;
if (easyModo && (damageReport.isFallDamage || damageReport.damageInfo.dotIndex != DotController.DotIndex.None))
{
#if DEBUG
TurboEdition._logger.LogWarning(ItemName + " Easy Modo is on, and the damage type was fall damage or DoT, damage rejected");
#endif
return;
}
#if DEBUG
Chat.AddMessage("Turbo Edition: " + ItemName + " is being held by someone who got hurt, check log for details.");
TurboEdition._logger.LogWarning(ItemName + " is being held by " + victim.body + ", rolling death with a chance of " + DeathChance + " and a inverted luck chance of " + -victim.body.master.luck);
#endif
if (Util.CheckRoll(DeathChance, -victim.body.master.luck) && victim.body.healthComponent)
{
#if DEBUG
Chat.AddMessage("Turbo Edition: " + ItemName + " failed the death roll.\nChange the planet, this is my final message. Goodbye.");
#endif
victim.body.healthComponent.Suicide(attacker, attacker, DamageType.VoidDeath);
}
}
}
// Token: 0x06002893 RID: 10387 RVA: 0x000AC938 File Offset: 0x000AAB38
private void OnCharacterDeathGlobal(DamageReport damageReport)
{
if (damageReport.victimBodyIndex == this.clayBossBodyIndex && base.IsCurrentBody(damageReport.attackerBody) && damageReport.damageInfo.inflictor && damageReport.damageInfo.inflictor.GetComponent <MapZone>() && SceneCatalog.mostRecentSceneDef == this.requiredSceneDef)
{
base.Grant();
}
}
private void GlobalEventManager_onCharacterDeathGlobal(DamageReport damageReport)
{
if (!NetworkServer.active || !Stage.instance)
{
return;
}
BulletstormPickupsComponent pickupsComponent = Stage.instance.GetComponent <BulletstormPickupsComponent>();
if (!pickupsComponent)
{
return;
}
if (CheckIfDoll(damageReport.damageInfo) || damageReport.victimTeamIndex == TeamIndex.Player || damageReport.victimTeamIndex == TeamIndex.None)
{
return;
}
var requiredKills = pickupsComponent.requiredKills;
CharacterBody VictimBody = damageReport.victimBody;
if (VictimBody)
{
//int DiffMultAdd = Run.instance.selectedDifficulty; //TODO: Add difficulty scaling?
pickupsComponent.globalDeaths++;
if (ShowProgress)
{
_logger.LogMessage(string.Format("[Bulletstorm] Kills/StageRequired: {0}/{1}", pickupsComponent.globalDeaths, requiredKills));
}
if (pickupsComponent.globalDeaths % requiredKills == 0)
{
Vector3 pickupPosition = EvaluatePickupPosition(pickupsComponent, VictimBody);
pickupPosition += Vector3.up * 2f;
if (ShowProgress)
{
_logger.LogMessage(string.Format("Pickups Controller: Resulting Kill Info (setup for roll):" +
"\nwasMapDeath: {0}" +
"\nlastHitAttacker: {1}" +
"\nposition: {2}", pickupsComponent.wasMapDeath, pickupsComponent.lastHitAttacker, pickupPosition));
}
var teamLuck = RiskOfBulletstorm.Utils.HelperUtil.GetPlayersLuck();
if (Util.CheckRoll(RollChance, teamLuck)) //Roll to spawn pickups
{
//Chat.AddMessage("Pickups: Rolled success.");
SpawnPickup(pickupPosition);
}
else
{
if (ShowProgress)
{
_logger.LogMessage("[Bulletstorm] Pickups Controller: Roll failed!");
}
}
pickupsComponent.wasMapDeath = false;
pickupsComponent.lastHitAttacker = null;
pickupsComponent.globalDeaths = 0;
}
}
}
public void OnKilledServer(DamageReport damageReport)
{
Vector3 position = Vector3.zero;
if (damageReport.attackerBody)
{
position = damageReport.victimBody.corePosition;
}
else
{
foreach (var teammate in TeamComponent.GetTeamMembers(TeamIndex.Player))
{
if (teammate.body?.master?.playerCharacterMasterController)
{
position = teammate.body.corePosition;
}
}
}
DropItems(position);
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex(equipmentIndex), position, Vector3.up * 20f);
DropCoins(position);
}
private static void GlobalEventManager_onCharacterDeathGlobal(DamageReport obj)
{
if ((obj.victimBody.HasBuff(resetDebuff) || obj.damageInfo.damageType.HasFlag(sniperResetDamageType)) && obj.attackerBodyIndex == (BodyIndex)(sniperBodyIndex.Value) && obj.attackerBody != null && obj.attackerBody is SniperCharacterBody body)
{
ResetSkills(body);
}
}
private static void GlobalEventManager_onServerDamageDealt(DamageReport obj)
{
if (obj?.damageInfo?.damageType is DamageType dt && dt.HasFlag(sniperResetDamageType) && obj.victimBody)
{
obj.victimBody.AddTimedBuff(resetDebuff, resetDuration);
}
}
public DamageReport dealDamage(ObjectInSpace delerOfDamage, float dmgAmount, DamageType dmgType, Vector3 damagePoint)
{
DamageReport dmgReport = new DamageReport(this, delerOfDamage, dmgType);
dmgReport.damagePoint = damagePoint;
if (dmgAmount > 0f)
{
dmgAmount = dealDamageToShield(dmgReport, dmgAmount, dmgType);
dmgAmount = dealDamageToArmor(dmgReport, dmgAmount, dmgType);
dmgAmount = dealDamageToHull(dmgReport, dmgAmount, dmgType);
if (dmgReport.damageSum > 0f)
{
damageEffect();
GameObject.Find("InterfaceGame").GetComponent<InterfaceScript>().createDamageText(dmgReport.damagePoint, "" + Mathf.Ceil(dmgReport.damageSum));
GameObject.Find("InterfaceGame").GetComponent<InterfaceScript>().addMesage(dmgReport.damageMessage());
}
if (dmgReport.remainingHull <= 0f)
{
dmgReport.isDestroyed = true;
destroyByDamage();
}
}
return dmgReport;
}
public virtual void TakeDamage(WeaponInfo info)
{
double rng = EntityInfo.rng.NextDouble();
DamageReport report = new DamageReport();
report.Crit = rng <= info.CritChance;
report.SetIncoming(info);
Health -= report.TotalIncoming();
// report damage taken
if (DamageReport != null)
{
DamageReport.Invoke(this, report);
}
if (Health <= 0)
{
Destroy(gameObject);
if (DamagePrefab != null)
{
Destroy(Instantiate(DamagePrefab, transform.position, transform.rotation, null), 5f);
if (UnityEngine.Random.Range(0, 1) < 0.5f)
{
GameObject spawn = Instantiate(Loot, transform.position, transform.rotation, null);
spawn.GetComponent <PickupItem>().roll = BaseRoller.RollItem(120);
}
}
}
}
private float dealDamageToHull(DamageReport dmgReport, float dmgAmount, DamageType dmgType)
{
if (dmgAmount > 0f)
{
if (getCurrentHull() > 0f)
{
if (getCurrentHull() >= dmgAmount)
{
addHull(-dmgAmount);
dmgReport.damageHull = dmgAmount;
dmgReport.damageSum += dmgAmount;
dmgAmount = 0f;
}
else
{
float dmgAmountToZeroHull = getCurrentHull();
addHull(-dmgAmountToZeroHull);
dmgReport.damageHull = dmgAmountToZeroHull;
dmgReport.damageSum += dmgAmountToZeroHull;
dmgReport.damageOverkill = dmgAmount - dmgAmountToZeroHull;
dmgReport.isDestroyed = true;
dmgAmount = 0f;
}
dmgReport.remainingHull = dmgReport.currentHull - dmgReport.damageHull;
}
}
return dmgAmount;
}
private float dealDamageToShield(DamageReport dmgReport, float dmgAmount, DamageType dmgType)
{
if (dmgAmount > 0f)
{
if (getCurrentShield() > 0f)
{
if (getCurrentShield() >= dmgAmount)
{
addShield(-dmgAmount);
dmgReport.damageShield = dmgAmount;
dmgReport.damageSum += dmgAmount;
dmgAmount = 0f;
}
else
{
float dmgAmountToZeroShield = getCurrentShield();
addShield(-dmgAmountToZeroShield);
dmgReport.damageShield = dmgAmountToZeroShield;
dmgReport.damageSum += dmgAmountToZeroShield;
dmgAmount = dmgAmount - dmgAmountToZeroShield;
}
dmgReport.remainingShield = dmgReport.currentShield - dmgReport.damageShield;
}
}
return dmgAmount;
}
private float dealDamageToArmor(DamageReport dmgReport, float dmgAmount, DamageType dmgType)
{
if (dmgAmount>0f)
{
if (getCurrentArmor() > 0f)
{
if (getCurrentArmor() >= dmgAmount)
{
addArmor(-dmgAmount);
dmgReport.damageArmor = dmgAmount;
dmgReport.damageSum += dmgAmount;
dmgAmount = 0f;
}
else
{
float dmgAmountToZeroArmor = getCurrentArmor();
addArmor(-dmgAmountToZeroArmor);
dmgReport.damageArmor = dmgAmountToZeroArmor;
dmgReport.damageSum += dmgAmountToZeroArmor;
dmgAmount = dmgAmount - dmgAmountToZeroArmor;
}
dmgReport.remainingArmor = dmgReport.currentArmor - dmgReport.damageArmor;
}
}
return dmgAmount;
}
// Token: 0x060025F0 RID: 9712 RVA: 0x000AFEC4 File Offset: 0x000AE0C4
private void OnCharacterDeath(DamageReport damageReport)
{
if (!damageReport.victim)
{
return;
}
CharacterBody body = damageReport.victim.body;
if (!body || !body.isElite)
{
return;
}
GameObject attacker = damageReport.damageInfo.attacker;
if (!attacker)
{
return;
}
CharacterBody component = attacker.GetComponent <CharacterBody>();
if (!component)
{
return;
}
if (component.masterObject == this.serverAchievementTracker.networkUser.masterObject)
{
base.Grant();
}
}
internal override AEffectReport Apply(Unit a_target)
{
DamageReport report = new DamageReport();
IntModifier reduction = a_target.defense.GetResistance(type).Compute(arpen);
report.attackInfos = attackInfos;
report.effectInfos = effectInfos;
int baseDmg = ComputeStackModifications();
report.target = a_target;
report.type = type;
report.unreduced = baseDmg;
report.final = reduction.Compute(report.unreduced,
FFEngine.Game.Constants.DAMAGE_REDUCTION_FROM_ARMOR_IS_FLAT_FIRST);
//Scratching
if (attackInfos.critType == ECriticalType.Normal && a_target.defense.ShouldScratch(this))
{
report.didScratch = true;
report.final = Mathf.FloorToInt(report.final * FFEngine.Game.Constants.SCRATCH_DAMAGE_MULTIPLIER);
}
else
{
report.didScratch = false;
}
report.reducedByArmor = report.final - report.unreduced;
return(report);
}
// Token: 0x060025DA RID: 9690 RVA: 0x000AFCF4 File Offset: 0x000ADEF4
private static void OnCharacterDeath(DamageReport damageReport)
{
if (!damageReport.victim)
{
return;
}
CharacterBody component = damageReport.victim.GetComponent <CharacterBody>();
if (!component || !component.isChampion || !component.isElite)
{
return;
}
foreach (HardEliteBossKillAchievement.EliteBossKillServerAchievement eliteBossKillServerAchievement in HardEliteBossKillAchievement.EliteBossKillServerAchievement.instancesList)
{
GameObject masterObject = eliteBossKillServerAchievement.serverAchievementTracker.networkUser.masterObject;
if (masterObject)
{
CharacterMaster component2 = masterObject.GetComponent <CharacterMaster>();
if (component2)
{
CharacterBody body = component2.GetBody();
if (body && body.healthComponent && body.healthComponent.alive)
{
eliteBossKillServerAchievement.Grant();
}
}
}
}
}
public void OnKilledOtherServer(DamageReport damageReport)
{
if (damageReport.attackerBody = this.characterBody)
{
this.healthComponent.HealFraction(0.07f, default);
}
}
private void GlobalEventManager_onServerDamageDealt(DamageReport obj)
{
if ((obj.damageInfo.damageType & this.resetOnKill) > DamageType.Generic)
{
obj.victimBody.AddTimedBuff(this.resetDebuff, this.resetDebuffTime);
}
}
private void GlobalEventManager_onServerDamageDealt(DamageReport damageReport)
{
if (!damageReport.attackerBody || !damageReport.victimBody || !damageReport.attacker || !damageReport.victim || !damageReport.attackerMaster || !damageReport.victimMaster || damageReport == null)
{
return;
}
if (damageReport.attackerBody && damageReport != null)
{
CharacterBody attackerBody = damageReport.attackerBody;
CharacterBody victimBody = damageReport.victimBody;
CharacterMaster attackerMaster = damageReport.attackerMaster;
CharacterMaster victimMaster = damageReport.victimMaster;
Inventory attackerInventory = attackerMaster ? attackerMaster.inventory : null;
Inventory victimInventory = victimMaster ? victimMaster.inventory : null;
int scpRandom = UnityEngine.Random.Range(0, scpBuffList.Count);
int rootCount = attackerInventory.GetItemCount(Root.itemIndex);
int scpCount = attackerInventory.GetItemCount(SCP.itemIndex);
if (rootCount > 0 && Util.CheckRoll((17 + (rootCount * 3)), attackerMaster) && attackerMaster && damageReport.victimMaster)
{
Util.PlaySound("Play_nullifier_attack1_root", victimBody.gameObject);
victimBody.AddTimedBuff(BuffIndex.Cripple, 3);
}
if (scpCount > 0 && damageReport.victimBody && victimMaster)
{
victimBody.AddTimedBuff(scpBuffList[scpRandom], (scpCount * 2));
}
}
}
////// Private Methods //////
void InflictFreezeOrStun(int count, SetStateOnHurt ssoh, DamageReport report, bool isStun)
{
if (!report.victim.isInFrozenState)
{
if (isStun)
{
if (ssoh.canBeStunned)
{
ssoh.SetStun(1f);
}
}
else
{
if (ssoh.canBeFrozen)
{
ssoh.SetFrozen(2f * report.damageInfo.procCoefficient);
}
}
}
report.victim.TakeDamage(new DamageInfo {
attacker = report.attacker,
crit = report.damageInfo.crit,
damage = ((float)(count - 1) * procStackDamage + procBaseDamage) * report.attackerBody.damage,
damageColorIndex = DamageColorIndex.Item,
damageType = DamageType.Generic,
force = Vector3.zero,
inflictor = report.damageInfo.inflictor,
position = report.damageInfo.position,
procChainMask = report.damageInfo.procChainMask,
procCoefficient = 0f
});
}
// Token: 0x060027A4 RID: 10148 RVA: 0x000AAF7C File Offset: 0x000A917C
private void OnCharacterDeathGlobal(DamageReport damageReport)
{
if (damageReport.victimBodyIndex == this.superRoboBallBossBodyIndex && damageReport.victimTeamIndex != TeamIndex.Player)
{
base.Grant();
}
}
private new void OnCharacterDeathGlobal(DamageReport report)
{
if (this.isEnabled)
{
base.OnCharacterDeathGlobal(report);
}
}
private bool DamageReport(Player p, DamageReport dR)
{
switch (dR)
{
case Models.DamageReport.Damage:
_consoleMicroservice.AlliedShipDamaged(p.Name);
_consoleMicroservice.Admiralty(p.Name, "Allied warship under attack.\n");
return(false);
case Models.DamageReport.CriticalDamage:
_consoleMicroservice.AlliedShipDamagedCritical(p.Name);
_consoleMicroservice.Admiralty(p.Name, "Allied warship critically damaged.\n");
return(false);
case Models.DamageReport.Sunk:
_consoleMicroservice.AlliedShipDestroyed(p.Name);
_consoleMicroservice.Admiralty(p.Name, "Allied warship lost.\n");
if (!p.Board.HasFleet())
{
return(true);
}
break;
default:
return(false);
}
return(false);
}
private static void ShareKillMoney(On.RoR2.DeathRewards.orig_OnKilledServer orig, DeathRewards self,
DamageReport damageReport)
{
orig(self, damageReport);
if (!GeneralHooks.IsMultiplayer())
{
return;
}
#region Sharedmoney
// Collect reward from kill and put it into shared pool
SharedMoneyValue += (int)self.goldReward;
if (!ShareSuite.MoneyScalarEnabled.Value ||
!NetworkServer.active)
{
return;
}
AddToSharedMoneyValue(self.goldReward);
#endregion
}
// Token: 0x060028FC RID: 10492 RVA: 0x000AD469 File Offset: 0x000AB669
private void OnServerCharacterExecuted(DamageReport damageReport, float executionHealthLost)
{
if (damageReport.attackerMaster == base.networkUser.master && base.networkUser.master != null && this.tracker.Push(Run.FixedTimeStamp.now.t))
{
base.Grant();
}
}
private bool getEnemyDropRate(DamageReport damageReport)
{
if (!ArtifactOfDoomConfig.useArtifactOfSacrificeCalculation.Value)
{
return(false);
}
if (!damageReport.victimMaster)
{
return(false);
}
if (damageReport.attackerTeamIndex == damageReport.victimTeamIndex && damageReport.victimMaster.minionOwnership.ownerMaster)
{
return(false);
}
float expAdjustedDropChancePercent = Util.GetExpAdjustedDropChancePercent(5f * (float)ArtifactOfDoomConfig.multiplayerForArtifactOfSacrificeDropRate.Value, damageReport.victim.gameObject);
//Debug.LogFormat("Drop chance from {0}: {1}", new object[]
//{
// damageReport.victimBody,
// expAdjustedDropChancePercent
//});
if (Util.CheckRoll(expAdjustedDropChancePercent, 0f, null))
{
return(true);
}
return(false);
}
private NetworkUser getNetworkUserOfDamageReport(DamageReport report, bool withMaster)
{
NetworkUser tempNetworkUser = null;
foreach (var element in NetworkUser.readOnlyInstancesList)
{
if (report.attackerOwnerMaster != null && withMaster)
{
if (element.GetCurrentBody() != null)
{
if (element.GetCurrentBody().netId == report.attackerOwnerMaster.GetBody().netId)
{
tempNetworkUser = element;
}
}
}
else
{
if (element.GetCurrentBody() != null)
{
if (element.GetCurrentBody().netId == report.attackerBody.netId)
{
tempNetworkUser = element;
}
}
}
}
return(tempNetworkUser);
}
private void GlobalEventManager_OnCharacterDeath(DamageReport damageReport)
{
if (NetworkServer.active)
{
if (damageReport != null && damageReport.victimBody && damageReport.victimBody.healthComponent)
{
if (damageReport.victimBody.healthComponent.isInFrozenState)
{
if (this.frozenBy.ContainsKey(damageReport.victim.gameObject))
{
GameObject body = this.frozenBy[damageReport.victim.gameObject];
if (AltArtiPassive.instanceLookup.ContainsKey(body))
{
AltArtiPassive passive = AltArtiPassive.instanceLookup[body];
passive.DoExecute(damageReport);
}
}
}
else if (damageReport.damageInfo.damageType.HasFlag(DamageType.Freeze2s))
{
if (AltArtiPassive.instanceLookup.ContainsKey(damageReport.attacker))
{
AltArtiPassive.instanceLookup[damageReport.attacker].DoExecute(damageReport);
}
}
}
}
}
public static DamageReport operator + (DamageReport x, DamageReport y)
{
DamageReport report = new DamageReport();
report.applied = x.applied + y.applied;
report.reducedByArmor = x.reducedByArmor + y.reducedByArmor;
report.final = x.final + y.final;
report.isCriticalStrike = x.isCriticalStrike || y.isCriticalStrike;
report.isKillingBlow = x.isKillingBlow || y.isKillingBlow;
return report;
}
internal DamageReport ComputeDamage(DamageWrapper a_dmg)
{
DamageReport report = new DamageReport();
//Armor reduction
report.applied = a_dmg.amount;
report.final = GetResistance(a_dmg.type,a_dmg.arpen).Compute(report.applied);
report.reducedByArmor = report.final - report.applied;
return report;
}
internal DamageReport ApplyDamage(AttackWrapper a_attack)
{
DamageReport report = new DamageReport();
foreach(DamageWrapper each in a_attack.damages)
{
report += ComputeDamage(each);
}
Debug.Log("Damages : " + report.ToString());
return report;
}
/// <summary>
/// Alters the current score based on a damage report.
/// </summary>
/// <param name="dr">The damage report.</param>
private void TallyScore(DamageReport dr)
{
//Determine whether the player is attacking or being attacked.
if (!dr.Attacker.AIControlled && dr.Defender.AIControlled) {
//PC attacked NPC, tally score based on multiplier.
if (dr.Multiplier == 1) this.Score += 2;
if (dr.Multiplier > 1) this.Score += 5;
} else if (dr.Attacker.AIControlled && !dr.Defender.AIControlled) {
//NPC attacked PC, decrement score.
this.Score--;
}
}
public void OnDamageTaken (DamageReport a_report)
{
foreach(AUnitComponent each in _damageCallbacks)
{
if(each.enabled)
{
((IDamagesCallbacks)each).OnDamageTaken(a_report);
}
}
}
public void OnDamageDealt (Unit a_unit, DamageReport a_report)
{
foreach(AUnitComponent each in _damageCallbacks)
{
if(each.enabled)
{
((IDamagesCallbacks)each).OnDamageDealt(a_unit, a_report);
}
}
}
