// Token: 0x060017D8 RID: 6104 RVA: 0x00067B08 File Offset: 0x00065D08 private static void PerformDamage(GameObject attacker, GameObject inflictor, float damage, bool isCrit, ProcChainMask procChainMask, float procCoefficient, DamageColorIndex damageColorIndex, DamageType damageType, Vector3 forceVector, float pushAwayForce, List <OverlapAttack.OverlapInfo> hitList) { for (int i = 0; i < hitList.Count; i++) { OverlapAttack.OverlapInfo overlapInfo = hitList[i]; if (overlapInfo.hurtBox) { HealthComponent healthComponent = overlapInfo.hurtBox.healthComponent; if (healthComponent) { DamageInfo damageInfo = new DamageInfo(); damageInfo.attacker = attacker; damageInfo.inflictor = inflictor; damageInfo.force = forceVector + pushAwayForce * overlapInfo.pushDirection; damageInfo.damage = damage; damageInfo.crit = isCrit; damageInfo.position = overlapInfo.hitPosition; damageInfo.procChainMask = procChainMask; damageInfo.procCoefficient = procCoefficient; damageInfo.damageColorIndex = damageColorIndex; damageInfo.damageType = damageType; damageInfo.ModifyDamageInfo(overlapInfo.hurtBox.damageModifier); healthComponent.TakeDamage(damageInfo); GlobalEventManager.instance.OnHitEnemy(damageInfo, healthComponent.gameObject); GlobalEventManager.instance.OnHitAll(damageInfo, healthComponent.gameObject); } } } }
private float Voidheart30PercentTimebomb(On.RoR2.HealthComponent.orig_Heal orig, RoR2.HealthComponent self, float amount, RoR2.ProcChainMask procChainMask, bool nonRegen) { var InventoryCount = GetCount(self.body); if (self.body && InventoryCount > 0) { if (self.combinedHealth <= self.fullCombinedHealth * Mathf.Clamp((voidHeartBaseTickingTimeBombHealthThreshold + (voidHeartAdditionalTickingTimeBombHealthThreshold * InventoryCount - 1)), voidHeartBaseTickingTimeBombHealthThreshold, voidHeartMaxTickingTimeBombHealthThreshold) && //This check is for the timer to determine time since spawn, at <= 10f it'll only activate after the tenth second self.GetComponent <VoidHeartPrevention>().internalTimer >= 7f) { RoR2.DamageInfo damageInfo = new RoR2.DamageInfo(); damageInfo.crit = false; damageInfo.damage = amount; damageInfo.force = Vector3.zero; damageInfo.position = self.transform.position; damageInfo.procChainMask = procChainMask; damageInfo.procCoefficient = 0f; damageInfo.damageColorIndex = DamageColorIndex.Default; damageInfo.damageType = DamageType.Generic; self.TakeDamage(damageInfo); return(orig(self, 0, procChainMask, nonRegen)); } } return(orig(self, amount, procChainMask, nonRegen)); }
// Token: 0x06000E57 RID: 3671 RVA: 0x00046B08 File Offset: 0x00044D08 private void DoDamage() { if (this.pointsList.Count == 0) { return; } float damage = this.damagePerSecond * this.updateInterval; Vector3 vector = this.pointsList[this.pointsList.Count - 1].position; HashSet <GameObject> hashSet = new HashSet <GameObject>(); TeamIndex teamIndex = TeamIndex.Neutral; if (this.owner) { hashSet.Add(this.owner); teamIndex = TeamComponent.GetObjectTeam(this.owner); } for (int i = this.pointsList.Count - 2; i >= 0; i--) { Vector3 position = this.pointsList[i].position; Vector3 direction = position - vector; RaycastHit[] array = Physics.SphereCastAll(new Ray(vector, direction), this.radius, direction.magnitude, LayerIndex.entityPrecise.mask, QueryTriggerInteraction.UseGlobal); for (int j = 0; j < array.Length; j++) { Collider collider = array[j].collider; if (collider.gameObject) { HurtBox component = collider.GetComponent <HurtBox>(); if (component) { HealthComponent healthComponent = component.healthComponent; if (healthComponent) { GameObject gameObject = healthComponent.gameObject; if (!hashSet.Contains(gameObject)) { hashSet.Add(gameObject); if (TeamComponent.GetObjectTeam(gameObject) != teamIndex) { healthComponent.TakeDamage(new DamageInfo { position = array[j].point, attacker = this.owner, inflictor = base.gameObject, crit = false, damage = damage, damageColorIndex = DamageColorIndex.Item, damageType = DamageType.Generic, force = Vector3.zero, procCoefficient = 0f }); } } } } } } vector = position; } }
private void IceEliteChanges(On.RoR2.HealthComponent.orig_TakeDamage orig, RoR2.HealthComponent self, RoR2.DamageInfo damageInfo) { RoR2.CharacterBody characterBody = null; if (damageInfo.attacker) { characterBody = damageInfo.attacker.GetComponent <RoR2.CharacterBody>(); } if (damageInfo.damage > 0) { if (characterBody) { RoR2.CharacterMaster master = characterBody.master; if (master && master.inventory) { if (damageInfo.procCoefficient > 0f) { if (characterBody.GetBuffCount(Resources.Load <BuffDef>("buffdefs/AffixWhite")) > 0) { self.body.AddTimedBuff(FreezingBlood.buffIndex, 2f * damageInfo.procCoefficient); if (self.body.GetBuffCount(FreezingBlood.buffIndex) >= 10) { self.body.ClearTimedBuffs(FreezingBlood.buffIndex); RoR2.CharacterBody component = damageInfo.attacker.GetComponent <RoR2.CharacterBody>(); RoR2.ProcChainMask procChainMask = damageInfo.procChainMask; int AffixWhiteStack = master.inventory.GetItemCount(AspectsToItems.AspectsToItems.NewDefsList.Find(x => x.name == "AffixWhite").itemIndex); Vector3 position = damageInfo.position; float damageCoefficient = 10f + 10f * AffixWhiteStack; if (AffixWhiteStack == 0) { damageCoefficient = 20f; } float damage2 = RoR2.Util.OnHitProcDamage(component.damage, component.damage, damageCoefficient); RoR2.DamageInfo damageInfo2 = new RoR2.DamageInfo { damage = damage2, damageColorIndex = DamageColorIndex.Item, damageType = DamageType.Generic, attacker = damageInfo.attacker, crit = damageInfo.crit, force = Vector3.zero, inflictor = null, position = position, procChainMask = procChainMask, procCoefficient = 1f }; RoR2.EffectManager.SimpleImpactEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/IceCullExplosion"), position, Vector3.up, true); self.TakeDamage(damageInfo2); } } } } } } orig(self, damageInfo); }
// Token: 0x06000A04 RID: 2564 RVA: 0x0002BE48 File Offset: 0x0002A048 public void OnTriggerEnter(Collider other) { if (NetworkServer.active) { HealthComponent component = other.GetComponent <HealthComponent>(); if (component) { component.TakeDamage(new DamageInfo { position = other.transform.position, attacker = null, inflictor = base.gameObject, damage = 999999f }); } } }
private static void HandleBulletDamage(NetworkMessage netMsg) { NetworkReader reader = netMsg.reader; GameObject gameObject = reader.ReadGameObject(); DamageInfo damageInfo = reader.ReadDamageInfo(); if (reader.ReadBoolean() && gameObject) { HealthComponent component = gameObject.GetComponent <HealthComponent>(); if (component) { component.TakeDamage(damageInfo); } GlobalEventManager.instance.OnHitEnemy(damageInfo, gameObject); } GlobalEventManager.instance.OnHitAll(damageInfo, gameObject); }
// Token: 0x06000426 RID: 1062 RVA: 0x00010B54 File Offset: 0x0000ED54 public bool DefaultHitCallback(ref BulletAttack.BulletHit hitInfo) { bool result = false; if (hitInfo.collider) { result = ((1 << hitInfo.collider.gameObject.layer & this.stopperMask) == 0); } if (this.hitEffectPrefab) { EffectManager.SimpleImpactEffect(this.hitEffectPrefab, hitInfo.point, this.HitEffectNormal ? hitInfo.surfaceNormal : (-hitInfo.direction), true); } if (hitInfo.collider) { SurfaceDef objectSurfaceDef = SurfaceDefProvider.GetObjectSurfaceDef(hitInfo.collider, hitInfo.point); if (objectSurfaceDef && objectSurfaceDef.impactEffectPrefab) { EffectData effectData = new EffectData { origin = hitInfo.point, rotation = Quaternion.LookRotation(hitInfo.surfaceNormal), color = objectSurfaceDef.approximateColor, surfaceDefIndex = objectSurfaceDef.surfaceDefIndex }; EffectManager.SpawnEffect(objectSurfaceDef.impactEffectPrefab, effectData, true); } } if (this.isCrit) { EffectManager.SimpleImpactEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/Critspark"), hitInfo.point, this.HitEffectNormal ? hitInfo.surfaceNormal : (-hitInfo.direction), true); } GameObject entityObject = hitInfo.entityObject; if (entityObject) { float num = 1f; switch (this.falloffModel) { case BulletAttack.FalloffModel.None: num = 1f; break; case BulletAttack.FalloffModel.DefaultBullet: num = 0.5f + Mathf.Clamp01(Mathf.InverseLerp(60f, 25f, hitInfo.distance)) * 0.5f; break; case BulletAttack.FalloffModel.Buckshot: num = 0.25f + Mathf.Clamp01(Mathf.InverseLerp(25f, 7f, hitInfo.distance)) * 0.75f; break; } DamageInfo damageInfo = new DamageInfo(); damageInfo.damage = this.damage * num; damageInfo.crit = this.isCrit; damageInfo.attacker = this.owner; damageInfo.inflictor = this.weapon; damageInfo.position = hitInfo.point; damageInfo.force = hitInfo.direction * (this.force * num); damageInfo.procChainMask = this.procChainMask; damageInfo.procCoefficient = this.procCoefficient; damageInfo.damageType = this.damageType; damageInfo.damageColorIndex = this.damageColorIndex; damageInfo.ModifyDamageInfo(hitInfo.damageModifier); TeamIndex teamIndex = TeamIndex.Neutral; if (this.owner) { TeamComponent component = this.owner.GetComponent <TeamComponent>(); if (component) { teamIndex = component.teamIndex; } } TeamIndex teamIndex2 = TeamIndex.Neutral; TeamComponent component2 = hitInfo.entityObject.GetComponent <TeamComponent>(); if (component2) { teamIndex2 = component2.teamIndex; } bool flag = teamIndex == teamIndex2; HealthComponent healthComponent = null; if (!flag) { healthComponent = entityObject.GetComponent <HealthComponent>(); } if (NetworkServer.active) { if (healthComponent) { healthComponent.TakeDamage(damageInfo); GlobalEventManager.instance.OnHitEnemy(damageInfo, hitInfo.entityObject); } GlobalEventManager.instance.OnHitAll(damageInfo, hitInfo.entityObject); } else if (ClientScene.ready) { BulletAttack.messageWriter.StartMessage(53); BulletAttack.messageWriter.Write(entityObject); BulletAttack.messageWriter.Write(damageInfo); BulletAttack.messageWriter.Write(healthComponent != null); BulletAttack.messageWriter.FinishMessage(); ClientScene.readyConnection.SendWriter(BulletAttack.messageWriter, QosChannelIndex.defaultReliable.intVal); } } return(result); }
// Token: 0x06000C13 RID: 3091 RVA: 0x0003BF50 File Offset: 0x0003A150 public void OnProjectileImpact(ProjectileImpactInfo impactInfo) { if (!this.alive) { return; } Collider collider = impactInfo.collider; if (collider) { DamageInfo damageInfo = new DamageInfo(); if (this.projectileDamage) { damageInfo.damage = this.projectileDamage.damage; damageInfo.crit = this.projectileDamage.crit; damageInfo.attacker = (this.projectileController.owner ? this.projectileController.owner.gameObject : null); damageInfo.inflictor = base.gameObject; damageInfo.position = impactInfo.estimatedPointOfImpact; damageInfo.force = this.projectileDamage.force * this.transform.forward; damageInfo.procChainMask = this.projectileController.procChainMask; damageInfo.procCoefficient = this.projectileController.procCoefficient; damageInfo.damageColorIndex = this.projectileDamage.damageColorIndex; } HurtBox component = collider.GetComponent <HurtBox>(); if (component) { HealthComponent healthComponent = component.healthComponent; if (healthComponent) { Transform transform = healthComponent.gameObject.transform; if (healthComponent.gameObject == this.projectileController.owner) { return; } if ((!this.pastTargetList.Contains(transform) || (this.canBounceToSameTarget && transform != this.lastTarget)) && (transform == this.currentTarget || this.canHitNonTarget || !this.currentTarget)) { this.pastTargetList.Add(transform); if (this.currentTarget) { this.lastTarget = this.currentTarget; } else { this.lastTarget = transform; } this.currentTarget = this.FindTarget(); this.bounceCount++; healthComponent.TakeDamage(damageInfo); GlobalEventManager.instance.OnHitAll(damageInfo, collider.gameObject); GlobalEventManager.instance.OnHitEnemy(damageInfo, component.healthComponent.gameObject); if (this.projectileDamage) { this.projectileDamage.damage *= this.damageMultiplier; } if (this.impactEffect) { EffectManager.instance.SimpleImpactEffect(this.impactEffect, this.transform.position, -this.transform.forward, !this.projectileController.isPrediction); } if (this.bounceCount >= this.maxBounceCount) { this.alive = false; } } } } else if (this.destroyOnWorldIfNoTarget && this.currentTarget == null) { damageInfo.position = this.transform.position; GlobalEventManager.instance.OnHitAll(damageInfo, collider.gameObject); if (this.impactEffect) { EffectManager.instance.SimpleImpactEffect(this.impactEffect, this.transform.position, -this.transform.forward, !this.projectileController.isPrediction); } this.alive = false; } } if (!this.alive) { UnityEngine.Object.Destroy(base.gameObject); } }
// Token: 0x0600138F RID: 5007 RVA: 0x0005F7EC File Offset: 0x0005D9EC public void OnInteractionBegin(Interactor activator) { if (!this.CanBeAffordedByInteractor(activator)) { return; } CharacterBody component = activator.GetComponent <CharacterBody>(); switch (this.costType) { case CostType.Money: if (component) { CharacterMaster master = component.master; if (master) { master.money -= (uint)this.cost; } } break; case CostType.PercentHealth: { HealthComponent component2 = activator.GetComponent <HealthComponent>(); if (component2) { float health = component2.health; float num = component2.fullHealth * (float)this.cost / 100f; if (health > num) { component2.TakeDamage(new DamageInfo { damage = num, attacker = base.gameObject, position = base.transform.position, damageType = DamageType.BypassArmor }); } } break; } case CostType.Lunar: { NetworkUser networkUser = Util.LookUpBodyNetworkUser(activator.gameObject); if (networkUser) { networkUser.DeductLunarCoins((uint)this.cost); } break; } case CostType.WhiteItem: case CostType.GreenItem: case CostType.RedItem: { ItemTier itemTier = PurchaseInteraction.CostTypeToItemTier(this.costType); if (component) { Inventory inventory = component.inventory; if (inventory) { ItemIndex itemIndex = ItemIndex.None; ShopTerminalBehavior component3 = base.GetComponent <ShopTerminalBehavior>(); if (component3) { itemIndex = component3.CurrentPickupIndex().itemIndex; } WeightedSelection <ItemIndex> weightedSelection = new WeightedSelection <ItemIndex>(8); foreach (ItemIndex itemIndex2 in ItemCatalog.allItems) { if (itemIndex2 != itemIndex) { int itemCount = inventory.GetItemCount(itemIndex2); if (itemCount > 0 && ItemCatalog.GetItemDef(itemIndex2).tier == itemTier) { weightedSelection.AddChoice(itemIndex2, (float)itemCount); } } } List <ItemIndex> list = new List <ItemIndex>(); int num2 = 0; while (weightedSelection.Count > 0 && num2 < this.cost) { int num3 = weightedSelection.EvaluteToChoiceIndex(this.rng.nextNormalizedFloat); WeightedSelection <ItemIndex> .ChoiceInfo choice = weightedSelection.GetChoice(num3); ItemIndex value = choice.value; int num4 = (int)choice.weight; num4--; if (num4 <= 0) { weightedSelection.RemoveChoice(num3); } else { weightedSelection.ModifyChoiceWeight(num3, (float)num4); } list.Add(value); num2++; } for (int i = num2; i < this.cost; i++) { list.Add(itemIndex); } for (int j = 0; j < list.Count; j++) { ItemIndex itemIndex3 = list[j]; PurchaseInteraction.CreateItemTakenOrb(component.corePosition, base.gameObject, itemIndex3); inventory.RemoveItem(itemIndex3, 1); if (itemIndex3 != itemIndex) { Action <PurchaseInteraction, Interactor> action = PurchaseInteraction.onItemSpentOnPurchase; if (action != null) { action(this, activator); } } } } } break; } } IEnumerable <StatDef> statDefsToIncrement = this.purchaseStatNames.Select(new Func <string, StatDef>(StatDef.Find)); StatManager.OnPurchase <IEnumerable <StatDef> >(component, this.costType, statDefsToIncrement); this.onPurchase.Invoke(activator); this.lastActivator = activator; }
private static void Init() { CostTypeCatalog.costTypeDefs = new CostTypeDef[11]; CostTypeIndex costType = CostTypeIndex.None; CostTypeDef costTypeDef7 = new CostTypeDef(); costTypeDef7.buildCostString = delegate(CostTypeDef costTypeDef, CostTypeDef.BuildCostStringContext context) { context.stringBuilder.Append(""); }; costTypeDef7.isAffordable = ((CostTypeDef costTypeDef, CostTypeDef.IsAffordableContext context) => true); costTypeDef7.payCost = delegate(CostTypeDef costTypeDef, CostTypeDef.PayCostContext context) { }; CostTypeCatalog.Register(costType, costTypeDef7); CostTypeIndex costType2 = CostTypeIndex.Money; CostTypeDef costTypeDef2 = new CostTypeDef(); costTypeDef2.costStringFormatToken = "COST_MONEY_FORMAT"; costTypeDef2.isAffordable = delegate(CostTypeDef costTypeDef, CostTypeDef.IsAffordableContext context) { CharacterBody component = context.activator.GetComponent <CharacterBody>(); if (component) { CharacterMaster master = component.master; if (master) { return((ulong)master.money >= (ulong)((long)context.cost)); } } return(false); }; costTypeDef2.payCost = delegate(CostTypeDef costTypeDef, CostTypeDef.PayCostContext context) { if (context.activatorMaster) { context.activatorMaster.money -= (uint)context.cost; } }; costTypeDef2.colorIndex = ColorCatalog.ColorIndex.Money; CostTypeCatalog.Register(costType2, costTypeDef2); CostTypeIndex costType3 = CostTypeIndex.PercentHealth; CostTypeDef costTypeDef3 = new CostTypeDef(); costTypeDef3.costStringFormatToken = "COST_PERCENTHEALTH_FORMAT"; costTypeDef3.saturateWorldStyledCostString = false; costTypeDef3.darkenWorldStyledCostString = true; costTypeDef3.isAffordable = delegate(CostTypeDef costTypeDef, CostTypeDef.IsAffordableContext context) { HealthComponent component = context.activator.GetComponent <HealthComponent>(); return(component && component.combinedHealth / component.fullCombinedHealth * 100f >= (float)context.cost); }; costTypeDef3.payCost = delegate(CostTypeDef costTypeDef, CostTypeDef.PayCostContext context) { HealthComponent component = context.activator.GetComponent <HealthComponent>(); if (component) { float combinedHealth = component.combinedHealth; float num = component.fullCombinedHealth * (float)context.cost / 100f; if (combinedHealth > num) { component.TakeDamage(new DamageInfo { damage = num, attacker = context.purchasedObject, position = context.purchasedObject.transform.position, damageType = (DamageType.NonLethal | DamageType.BypassArmor) }); } } }; costTypeDef3.colorIndex = ColorCatalog.ColorIndex.Blood; CostTypeCatalog.Register(costType3, costTypeDef3); CostTypeIndex costType4 = CostTypeIndex.LunarCoin; CostTypeDef costTypeDef4 = new CostTypeDef(); costTypeDef4.costStringFormatToken = "COST_LUNARCOIN_FORMAT"; costTypeDef4.saturateWorldStyledCostString = false; costTypeDef4.darkenWorldStyledCostString = true; costTypeDef4.isAffordable = delegate(CostTypeDef costTypeDef, CostTypeDef.IsAffordableContext context) { NetworkUser networkUser = Util.LookUpBodyNetworkUser(context.activator.gameObject); return(networkUser && (ulong)networkUser.lunarCoins >= (ulong)((long)context.cost)); }; costTypeDef4.payCost = delegate(CostTypeDef costTypeDef, CostTypeDef.PayCostContext context) { NetworkUser networkUser = Util.LookUpBodyNetworkUser(context.activator.gameObject); if (networkUser) { networkUser.DeductLunarCoins((uint)context.cost); } }; costTypeDef4.colorIndex = ColorCatalog.ColorIndex.LunarCoin; CostTypeCatalog.Register(costType4, costTypeDef4); CostTypeCatalog.Register(CostTypeIndex.WhiteItem, new CostTypeDef { costStringFormatToken = "COST_ITEM_FORMAT", isAffordable = new CostTypeDef.IsAffordableDelegate(CostTypeCatalog.< > c.< > 9. < Init > g__IsAffordableItem | 5_0), payCost = new CostTypeDef.PayCostDelegate(CostTypeCatalog.< > c.< > 9. < Init > g__PayCostItems | 5_1), colorIndex = ColorCatalog.ColorIndex.Tier1Item, itemTier = ItemTier.Tier1 });