protected override bool PerformEquipmentAction(RoR2.EquipmentSlot slot)
{
if (!slot.characterBody)
{
return(false);
}
var body = slot.characterBody;
if (NetworkServer.active)
{
var supernova = new RoR2.BlastAttack()
{
radius = 40,
procCoefficient = 0.25f,
position = body.corePosition,
attacker = body.gameObject,
crit = RoR2.Util.CheckRoll(body.crit, body.master),
baseDamage = body.damage * 4,
falloffModel = RoR2.BlastAttack.FalloffModel.None,
baseForce = body.damage * 100,
teamIndex = !body.teamComponent.teamIndex.Equals(TeamIndex.None) ? body.teamComponent.teamIndex : TeamIndex.None,
damageType = DamageType.IgniteOnHit,
attackerFiltering = AttackerFiltering.NeverHit
};
supernova.Fire();
RoR2.EffectData effectData = new RoR2.EffectData();
effectData.origin = body.corePosition;
effectData.scale = 40f;
RoR2.EffectManager.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/ExplosionVFX"), effectData, true);
return(true);
}
return(false);
}
// Token: 0x060005D7 RID: 1495 RVA: 0x0001834C File Offset: 0x0001654C
public void CreateEffect(AnimationEvent animationEvent)
{
Transform transform = base.transform;
int num = -1;
if (!string.IsNullOrEmpty(animationEvent.stringParameter))
{
num = this.childLocator.FindChildIndex(animationEvent.stringParameter);
if (num != -1)
{
transform = this.childLocator.FindChild(num);
}
}
bool transmit = animationEvent.intParameter != 0;
EffectData effectData = new EffectData();
effectData.origin = transform.position;
effectData.SetChildLocatorTransformReference(this.bodyObject, num);
EffectManager.SpawnEffect((GameObject)animationEvent.objectReferenceParameter, effectData, transmit);
}
// Token: 0x06000AF6 RID: 2806 RVA: 0x000307FC File Offset: 0x0002E9FC
private void DetonateServer()
{
if (this.hasDetonatedServer)
{
return;
}
this.hasDetonatedServer = true;
CharacterBody currentPassengerBody = this.vehicleSeat.currentPassengerBody;
if (currentPassengerBody)
{
EffectData effectData = new EffectData
{
origin = base.transform.position,
scale = this.blastRadius
};
EffectManager.SpawnEffect(this.explosionEffectPrefab, effectData, true);
new BlastAttack
{
attacker = currentPassengerBody.gameObject,
baseDamage = this.blastDamageCoefficient * currentPassengerBody.damage,
baseForce = this.blastForce,
bonusForce = this.blastBonusForce,
canHurtAttacker = false,
crit = currentPassengerBody.RollCrit(),
damageColorIndex = DamageColorIndex.Item,
damageType = this.blastDamageType,
falloffModel = this.blastFalloffModel,
inflictor = base.gameObject,
position = base.transform.position,
procChainMask = default(ProcChainMask),
procCoefficient = this.blastProcCoefficient,
radius = this.blastRadius,
teamIndex = currentPassengerBody.teamComponent.teamIndex
}.Fire();
}
Util.PlaySound(this.explosionSoundString, base.gameObject);
UnityEngine.Object.Destroy(base.gameObject);
}
public void OnReceived()
{
if (NetworkServer.active)
{
return;
}
GameObject target = null;
var playerGameObject = RoR2.Util.FindNetworkObject(BodyID);
if (playerGameObject)
{
var playerBody = playerGameObject.GetComponent <RoR2.CharacterBody>();
if (playerBody)
{
var eqp = playerBody.equipmentSlot.FindActiveEquipmentDisplay();
target = eqp ? eqp.gameObject : playerGameObject;
if (target)
{
if (ChargeState)
{
RoR2.EffectData sphere = new RoR2.EffectData
{
origin = target.transform.position,
rotation = target.transform.rotation,
rootObject = target
};
RoR2.EffectManager.SpawnEffect(JarChargeSphere, sphere, false);
}
}
}
}
else
{
Debug.LogError("We don't have a jar or a playerbody. Can't do a sphere!");
return;
}
}
// Token: 0x06000EB9 RID: 3769 RVA: 0x0004881C File Offset: 0x00046A1C
private void TransmitEffect(uint effectPrefabIndex, EffectData effectData, NetworkConnection netOrigin = null)
{
EffectManager.outgoingEffectMessage.effectPrefabIndex = effectPrefabIndex;
EffectData.Copy(effectData, EffectManager.outgoingEffectMessage.effectData);
if (NetworkServer.active)
{
using (IEnumerator <NetworkConnection> enumerator = NetworkServer.connections.GetEnumerator())
{
while (enumerator.MoveNext())
{
NetworkConnection networkConnection = enumerator.Current;
if (networkConnection != null && networkConnection != netOrigin)
{
networkConnection.SendByChannel(52, EffectManager.outgoingEffectMessage, QosChannelIndex.effects.intVal);
}
}
return;
}
}
if (ClientScene.readyConnection != null)
{
ClientScene.readyConnection.SendByChannel(52, EffectManager.outgoingEffectMessage, QosChannelIndex.effects.intVal);
}
}
// Token: 0x06000EB7 RID: 3767 RVA: 0x00048794 File Offset: 0x00046994
public void SpawnEffect(GameObject effectPrefab, EffectData effectData, bool transmit)
{
if (transmit)
{
this.TransmitEffect(effectPrefab, effectData, null);
if (NetworkServer.active)
{
return;
}
}
if (NetworkClient.active)
{
if (!VFXBudget.CanAffordSpawn(effectPrefab))
{
return;
}
EffectData effectData2 = effectData.Clone();
EffectComponent component = UnityEngine.Object.Instantiate <GameObject>(effectPrefab, effectData2.origin, effectData2.rotation).GetComponent <EffectComponent>();
if (component)
{
component.effectData = effectData2.Clone();
}
}
}
// Token: 0x060009A0 RID: 2464 RVA: 0x00030A12 File Offset: 0x0002EC12
public static void ReadEffectData(this NetworkReader reader, EffectData effectData)
{
effectData.Deserialize(reader);
}
// Token: 0x0600099E RID: 2462 RVA: 0x000309FB File Offset: 0x0002EBFB
public static void Write(this NetworkWriter writer, EffectData effectData)
{
effectData.Serialize(writer);
}
// 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: 0x0600042F RID: 1071 RVA: 0x000113A0 File Offset: 0x0000F5A0
private void FireSingle(Vector3 normal, int muzzleIndex)
{
float num = this.maxDistance;
Vector3 vector = this.origin + normal * this.maxDistance;
List <BulletAttack.BulletHit> list = new List <BulletAttack.BulletHit>();
bool flag = this.radius == 0f || this.smartCollision;
bool flag2 = this.radius != 0f;
HashSet <GameObject> hashSet = null;
if (this.smartCollision)
{
hashSet = new HashSet <GameObject>();
}
if (flag)
{
RaycastHit[] array = Physics.RaycastAll(this.origin, normal, num, this.hitMask, this.queryTriggerInteraction);
for (int i = 0; i < array.Length; i++)
{
BulletAttack.BulletHit bulletHit = default(BulletAttack.BulletHit);
this.InitBulletHitFromRaycastHit(ref bulletHit, this.origin, normal, ref array[i]);
list.Add(bulletHit);
if (this.smartCollision)
{
hashSet.Add(bulletHit.entityObject);
}
if (bulletHit.distance < num)
{
num = bulletHit.distance;
}
}
}
if (flag2)
{
LayerMask mask = this.hitMask;
if (this.smartCollision)
{
mask &= ~LayerIndex.world.mask;
}
RaycastHit[] array2 = Physics.SphereCastAll(this.origin, this.radius, normal, num, mask, this.queryTriggerInteraction);
for (int j = 0; j < array2.Length; j++)
{
BulletAttack.BulletHit bulletHit2 = default(BulletAttack.BulletHit);
this.InitBulletHitFromRaycastHit(ref bulletHit2, this.origin, normal, ref array2[j]);
if (!this.smartCollision || !hashSet.Contains(bulletHit2.entityObject))
{
list.Add(bulletHit2);
}
}
}
this.ProcessHitList(list, ref vector, new List <GameObject>());
if (this.tracerEffectPrefab)
{
EffectData effectData = new EffectData
{
origin = vector,
start = this.origin
};
effectData.SetChildLocatorTransformReference(this.weapon, muzzleIndex);
EffectManager.SpawnEffect(this.tracerEffectPrefab, effectData, true);
}
}
private bool PerformEquipmentAction(EquipmentIndex equipmentIndex)
{
switch (equipmentIndex)
{
case EquipmentIndex.CommandMissile:
remainingMissiles += 12;
return(true);
case EquipmentIndex.Saw:
{
Vector3 position = transform.position;
Ray ray = new Ray
{
direction = inputBank.aimDirection,
origin = inputBank.aimOrigin
};
bool crit = Util.CheckRoll(characterBody.crit, characterBody.master);
ProjectileManager.instance.FireProjectile(Resources.Load <GameObject>("Prefabs/Projectiles/Sawmerang"), ray.origin, Util.QuaternionSafeLookRotation(ray.direction), gameObject, characterBody.damage, 0f, crit, DamageColorIndex.Default, null, -1f);
return(true);
}
case EquipmentIndex.Fruit:
if (healthComponent)
{
Util.PlaySound("Play_item_use_fruit", gameObject);
EffectData effectData = new EffectData();
effectData.origin = transform.position;
effectData.SetNetworkedObjectReference(gameObject);
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/FruitHealEffect"), effectData, true);
healthComponent.HealFraction(0.5f, default(ProcChainMask));
return(true);
}
return(true);
case EquipmentIndex.Meteor:
{
MeteorStormController component = Instantiate(Resources.Load <GameObject>("Prefabs/NetworkedObjects/MeteorStorm"), characterBody.corePosition, Quaternion.identity).GetComponent <MeteorStormController>();
component.owner = gameObject;
component.ownerDamage = characterBody.damage;
component.isCrit = Util.CheckRoll(characterBody.crit, characterBody.master);
NetworkServer.Spawn(component.gameObject);
return(true);
}
case EquipmentIndex.SoulJar:
return(true);
case EquipmentIndex.Blackhole:
{
Vector3 position2 = transform.position;
Ray ray2 = new Ray
{
direction = inputBank.aimDirection,
origin = inputBank.aimOrigin
};
ProjectileManager.instance.FireProjectile(Resources.Load <GameObject>("Prefabs/Projectiles/GravSphere"), position2, Util.QuaternionSafeLookRotation(ray2.direction), gameObject, 0f, 0f, false, DamageColorIndex.Default, null, -1f);
return(true);
}
case EquipmentIndex.GhostGun:
{
GameObject gameObject = Instantiate(Resources.Load <GameObject>("Prefabs/NetworkedObjects/GhostGun"), transform.position, Quaternion.identity);
gameObject.GetComponent <GhostGunController>().owner = this.gameObject;
NetworkServer.Spawn(gameObject);
return(true);
}
case EquipmentIndex.CritOnUse:
characterBody.AddTimedBuff(BuffIndex.FullCrit, 8f);
return(true);
case EquipmentIndex.DroneBackup:
{
Util.PlaySound("Play_item_use_radio", gameObject);
int num = 4;
float num2 = 25f;
if (NetworkServer.active)
{
for (int i = 0; i < num; i++)
{
Vector2 vector = Random.insideUnitCircle.normalized * 3f;
Vector3 position3 = transform.position + new Vector3(vector.x, 0f, vector.y);
SummonMaster(Resources.Load <GameObject>("Prefabs/CharacterMasters/DroneBackupMaster"), position3).gameObject.AddComponent <MasterSuicideOnTimer>().lifeTimer = num2 + Random.Range(0f, 3f);
}
return(true);
}
return(true);
}
case EquipmentIndex.OrbitalLaser:
{
Vector3 position4 = transform.position;
RaycastHit raycastHit;
if (Physics.Raycast(new Ray
{
direction = inputBank.aimDirection,
origin = inputBank.aimOrigin
}, out raycastHit, 900f, LayerIndex.world.mask | LayerIndex.defaultLayer.mask))
{
position4 = raycastHit.point;
}
GameObject gameObject2 = (GameObject)Instantiate(Resources.Load("Prefabs/NetworkedObjects/OrbitalLaser"), position4, Quaternion.identity);
gameObject2.GetComponent <OrbitalLaserController>().ownerBody = characterBody;
NetworkServer.Spawn(gameObject2);
return(true);
}
case EquipmentIndex.BFG:
bfgChargeTimer = 2f;
subcooldownTimer = 2.2f;
return(true);
case EquipmentIndex.Enigma:
{
EquipmentIndex equipmentIndex2 = EquipmentCatalog.enigmaEquipmentList[Random.Range(0, EquipmentCatalog.enigmaEquipmentList.Count - 1)];
PerformEquipmentAction(equipmentIndex2);
return(true);
}
case EquipmentIndex.Jetpack:
{
JetpackController jetpackController = JetpackController.FindJetpackController(gameObject);
if (!jetpackController)
{
GameObject gameObject3 = Instantiate(Resources.Load <GameObject>("Prefabs/NetworkedObjects/JetpackController"));
jetpackController = gameObject3.GetComponent <JetpackController>();
jetpackController.NetworktargetObject = gameObject;
NetworkServer.Spawn(gameObject3);
return(true);
}
jetpackController.ResetTimer();
return(true);
}
case EquipmentIndex.Lightning:
{
HurtBox hurtBox = currentTargetHurtBox;
if (hurtBox)
{
subcooldownTimer = 0.2f;
OrbManager.instance.AddOrb(new LightningStrikeOrb
{
attacker = gameObject,
damageColorIndex = DamageColorIndex.Item,
damageValue = characterBody.damage * 30f,
isCrit = Util.CheckRoll(characterBody.crit, characterBody.master),
procChainMask = default(ProcChainMask),
procCoefficient = 1f,
target = hurtBox
});
return(true);
}
return(false);
}
case EquipmentIndex.PassiveHealing:
if (passiveHealingFollower)
{
passiveHealingFollower.AssignNewTarget(currentTargetBodyObject);
return(true);
}
return(true);
case EquipmentIndex.BurnNearby:
if (characterBody)
{
characterBody.AddHelfireDuration(8f);
return(true);
}
return(true);
case EquipmentIndex.SoulCorruptor:
{
HurtBox hurtBox2 = currentTargetHurtBox;
if (!hurtBox2)
{
return(false);
}
if (!hurtBox2.healthComponent || hurtBox2.healthComponent.combinedHealthFraction > 0.25f)
{
return(false);
}
Util.TryToCreateGhost(hurtBox2.healthComponent.body, characterBody, 30);
hurtBox2.healthComponent.Suicide(gameObject);
return(true);
}
case EquipmentIndex.Scanner:
NetworkServer.Spawn(Instantiate(Resources.Load <GameObject>("Prefabs/NetworkedObjects/ChestScanner"), characterBody.corePosition, Quaternion.identity));
return(true);
case EquipmentIndex.CrippleWard:
NetworkServer.Spawn(Instantiate(Resources.Load <GameObject>("Prefabs/NetworkedObjects/CrippleWard"), characterBody.corePosition, Quaternion.identity));
// Don't drop it for now - can't pick back up (bug)
// inventory.SetEquipmentIndex(EquipmentIndex.None);
return(true);
}
return(false);
}
private System.Collections.IEnumerator GlobalEventManager_CreateLevelUpEffect(On.RoR2.GlobalEventManager.orig_CreateLevelUpEffect orig, RoR2.GlobalEventManager self, float delay, GameObject levelUpEffect, RoR2.EffectData effectData)
{
yield return(new WaitForSeconds(delay));
orig.Invoke(self, delay, levelUpEffect, effectData);
foreach (RoR2.PlayerCharacterMasterController playerCharacterMasterController in RoR2.PlayerCharacterMasterController.instances)
{
bool isClient = playerCharacterMasterController.master.isClient;
if (isClient)
{
string displayName = playerCharacterMasterController.GetDisplayName();
System.Random rnd = new System.Random();
RoR2.CharacterMaster localUser = playerCharacterMasterController.master;
RoR2.CharacterBody playerBody = localUser.GetBody();
int playerLevel = (int)playerBody.level;
if (currentLevel < playerLevel)
{
ItemTier itemTier1 = ItemTier.Tier1;
int amountOfItemsInTier = this.getAmountOfItemsInTier(itemTier1, playerCharacterMasterController.master);
this.removeAllItemsInTier(itemTier1, playerCharacterMasterController.master);
this.addItems(itemTier1, amountOfItemsInTier, playerCharacterMasterController.master, rnd, tier1Min.Value, tier1Max.Value);
ItemTier itemTier2 = ItemTier.Tier2;
amountOfItemsInTier = this.getAmountOfItemsInTier(itemTier2, playerCharacterMasterController.master);
this.removeAllItemsInTier(itemTier2, playerCharacterMasterController.master);
this.addItems(itemTier2, amountOfItemsInTier, playerCharacterMasterController.master, rnd, tier2Min.Value, tier2Max.Value);
ItemTier itemTier3 = ItemTier.Tier3;
amountOfItemsInTier = this.getAmountOfItemsInTier(itemTier3, playerCharacterMasterController.master);
this.removeAllItemsInTier(itemTier3, playerCharacterMasterController.master);
this.addItems(itemTier3, amountOfItemsInTier, playerCharacterMasterController.master, rnd, tier3Min.Value, tier3Max.Value);
ItemTier itemTierLunar = ItemTier.Lunar;
amountOfItemsInTier = this.getAmountOfItemsInTier(itemTierLunar, playerCharacterMasterController.master);
this.removeAllItemsInTier(itemTierLunar, playerCharacterMasterController.master);
this.addItems(itemTierLunar, amountOfItemsInTier, playerCharacterMasterController.master, rnd, tierLunarMin.Value, tierLunarMax.Value);
currentLevel = playerLevel;
}
}
}
yield break;
}
public void TakeDamage(DamageInfo damageInfo)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.HealthComponent::TakeDamage(RoR2.DamageInfo)' called on client");
return;
}
if (!this.alive || this.godMode)
{
return;
}
CharacterBody characterBody = null;
if (damageInfo.attacker)
{
characterBody = damageInfo.attacker.GetComponent <CharacterBody>();
}
base.BroadcastMessage("OnIncomingDamage", damageInfo, SendMessageOptions.DontRequireReceiver);
CharacterMaster master = this.body.master;
base.GetComponent <TeamComponent>();
if (master && master.inventory)
{
int itemCount = master.inventory.GetItemCount(ItemIndex.Bear);
if (itemCount > 0 && Util.CheckRoll((1f - 1f / (0.15f * (float)itemCount + 1f)) * 100f, 0f, null))
{
EffectData effectData = new EffectData
{
origin = damageInfo.position,
rotation = Util.QuaternionSafeLookRotation((damageInfo.force != Vector3.zero) ? damageInfo.force : UnityEngine.Random.onUnitSphere)
};
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/BearProc"), effectData, true);
damageInfo.rejected = true;
}
}
if (this.body.HasBuff(BuffIndex.Immune) && (!characterBody || !characterBody.HasBuff(BuffIndex.GoldEmpowered)))
{
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/DamageRejected"), new EffectData
{
origin = damageInfo.position
}, true);
damageInfo.rejected = true;
}
if (damageInfo.rejected)
{
return;
}
float num = damageInfo.damage;
if (characterBody)
{
CharacterMaster master2 = characterBody.master;
if (master2 && master2.inventory)
{
if (this.combinedHealth >= this.fullCombinedHealth * 0.9f)
{
int itemCount2 = master2.inventory.GetItemCount(ItemIndex.Crowbar);
if (itemCount2 > 0)
{
Util.PlaySound("Play_item_proc_crowbar", base.gameObject);
num *= 1.5f + 0.3f * (float)(itemCount2 - 1);
EffectManager.instance.SimpleImpactEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/ImpactCrowbar"), damageInfo.position, -damageInfo.force, true);
}
}
if (this.body.isBoss)
{
int itemCount3 = master2.inventory.GetItemCount(ItemIndex.BossDamageBonus);
if (itemCount3 > 0)
{
num *= 1.2f + 0.1f * (float)(itemCount3 - 1);
damageInfo.damageColorIndex = DamageColorIndex.WeakPoint;
EffectManager.instance.SimpleImpactEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/ImpactBossDamageBonus"), damageInfo.position, -damageInfo.force, true);
}
}
}
}
if (damageInfo.crit)
{
num *= 2f;
}
if ((damageInfo.damageType & DamageType.WeakPointHit) != DamageType.Generic)
{
num *= 1.5f;
damageInfo.damageColorIndex = DamageColorIndex.WeakPoint;
}
if ((damageInfo.damageType & DamageType.BypassArmor) == DamageType.Generic)
{
float armor = this.body.armor;
float num2 = (armor >= 0f) ? (1f - armor / (armor + 100f)) : (2f - 100f / (100f - armor));
num = Mathf.Max(1f, num * num2);
}
if ((damageInfo.damageType & DamageType.BarrierBlocked) != DamageType.Generic)
{
damageInfo.force *= 0.5f;
IBarrier component = base.GetComponent <IBarrier>();
if (component != null)
{
component.BlockedDamage(damageInfo, num);
}
damageInfo.procCoefficient = 0f;
num = 0f;
}
if (this.hasOneshotProtection)
{
num = Mathf.Min(num, this.fullCombinedHealth * 0.9f);
}
if ((damageInfo.damageType & DamageType.SlowOnHit) != DamageType.Generic)
{
this.body.AddTimedBuff(BuffIndex.Slow50, 2f);
}
if ((damageInfo.damageType & DamageType.ClayGoo) != DamageType.Generic && (this.body.bodyFlags & CharacterBody.BodyFlags.ImmuneToGoo) == CharacterBody.BodyFlags.None)
{
this.body.AddTimedBuff(BuffIndex.ClayGoo, 2f);
}
if (master && master.inventory)
{
int itemCount4 = master.inventory.GetItemCount(ItemIndex.GoldOnHit);
if (itemCount4 > 0)
{
float num3 = num / this.fullCombinedHealth;
uint num4 = (uint)Mathf.Max(master.money * num3 * (float)itemCount4, damageInfo.damage * (float)itemCount4);
master.money = (uint)Mathf.Max(0f, master.money - num4);
EffectManager.instance.SimpleImpactEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/CoinImpact"), damageInfo.position, Vector3.up, true);
}
}
if ((damageInfo.damageType & DamageType.NonLethal) != DamageType.Generic)
{
num = Mathf.Max(Mathf.Min(num, this.health - 1f), 0f);
}
if (this.shield > 0f)
{
float num5 = Mathf.Min(num, this.shield);
float num6 = num - num5;
this.Networkshield = Mathf.Max(this.shield - num5, 0f);
if (this.shield == 0f)
{
float scale = 1f;
if (this.body)
{
scale = this.body.radius;
}
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/ShieldBreakEffect"), new EffectData
{
origin = base.transform.position,
scale = scale
}, true);
}
if (num6 > 0f)
{
this.Networkhealth = this.health - num6;
}
}
else
{
this.Networkhealth = this.health - num;
}
this.TakeDamageForce(damageInfo, false);
base.SendMessage("OnTakeDamage", damageInfo, SendMessageOptions.DontRequireReceiver);
DamageReport damageReport = new DamageReport
{
victim = this,
damageInfo = damageInfo
};
damageReport.damageInfo.damage = num;
if (num > 0f)
{
HealthComponent.SendDamageDealt(damageReport);
}
this.UpdateLastHitTime(damageInfo.damage, damageInfo.position, (damageInfo.damageType & DamageType.Silent) > DamageType.Generic);
if (damageInfo.attacker)
{
damageInfo.attacker.SendMessage("OnDamageDealt", damageReport, SendMessageOptions.DontRequireReceiver);
}
GlobalEventManager.ServerDamageDealt(damageReport);
if (this.isFrozen && this.combinedHealthFraction < 0.3f)
{
this.Networkhealth = 0f;
EffectManager.instance.SpawnEffect(FrozenState.cullEffectPrefab, new EffectData
{
origin = this.body.corePosition,
scale = (this.body ? this.body.radius : 1f)
}, true);
}
if (!this.alive)
{
base.BroadcastMessage("OnKilled", damageInfo, SendMessageOptions.DontRequireReceiver);
if (damageInfo.attacker)
{
damageInfo.attacker.SendMessage("OnKilledOther", damageReport, SendMessageOptions.DontRequireReceiver);
}
GlobalEventManager.instance.OnCharacterDeath(damageReport);
return;
}
if (master && master.inventory)
{
int itemCount5 = master.inventory.GetItemCount(ItemIndex.Phasing);
if (itemCount5 > 0 && Util.CheckRoll(damageInfo.damage / this.fullCombinedHealth * 100f, master))
{
this.body.AddTimedBuff(BuffIndex.Cloak, 1.5f + (float)itemCount5 * 1.5f);
this.body.AddTimedBuff(BuffIndex.CloakSpeed, 1.5f + (float)itemCount5 * 1.5f);
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/ProcStealthkit"), new EffectData
{
origin = base.transform.position,
rotation = Quaternion.identity
}, true);
}
}
}
public void FixedUpdate()
{
var input = body.inputBank;
if (SuckTime > 0)
{
if (!IsSuckingProjectiles)
{
RoR2.EffectData sphere = new RoR2.EffectData
{
origin = TargetTransform ? TargetTransform.position : body.transform.position,
rotation = TargetTransform ? TargetTransform.rotation : body.transform.rotation,
rootObject = TargetTransform ? TargetTransform.gameObject : body.gameObject
};
RoR2.EffectManager.SpawnEffect(JarChargeSphere, sphere, false);
var bodyIdentity = body.gameObject.GetComponent <NetworkIdentity>();
if (bodyIdentity && NetworkServer.active)
{
new SyncJarSucking(SyncJarSucking.MessageType.Charging, true, projectileAbsorptionTime, bodyIdentity.netId).Send(NetworkDestination.Clients);
}
IsSuckingProjectiles = true;
}
SuckTime -= Time.fixedDeltaTime;
List <ProjectileController> bullets = new List <ProjectileController>();
new RoR2.SphereSearch
{
radius = baseRadiusGranted,
mask = RoR2.LayerIndex.projectile.mask,
origin = body.corePosition
}.RefreshCandidates().FilterCandidatesByProjectileControllers().GetProjectileControllers(bullets);
if (bullets.Count > 0)
{
foreach (ProjectileController controller in bullets)
{
var controllerOwner = controller.owner;
if (controllerOwner)
{
var ownerBody = controllerOwner.GetComponent <RoR2.CharacterBody>();
if (ownerBody)
{
if (ownerBody.teamComponent.teamIndex == body.teamComponent.teamIndex)
{
if (FriendlyFireManager.friendlyFireMode != FriendlyFireManager.FriendlyFireMode.Off && iWantToLoseFriendsInChaosMode)
{
if (ownerBody == body)
{
continue;
}
}
else
{
continue;
}
}
var projectileDamage = controller.gameObject.GetComponent <ProjectileDamage>();
if (projectileDamage)
{
jarBullets.Add(new JarBullet(projectileDamage.damage, projectileDamage.damageColorIndex, projectileDamage.damageType));
var orb = new JarOfReshapingOrb();
orb.Target = TargetTransform ? TargetTransform.gameObject : body.gameObject; //Where it is going to
orb.origin = controller.transform.position; //Where it is coming from
orb.Index = -1;
OrbManager.instance.AddOrb(orb); // Fire
var bodyIdentity = body.gameObject.GetComponent <NetworkIdentity>();
if (bodyIdentity && NetworkServer.active)
{
new SyncJarOrb(SyncJarOrb.MessageType.Fired, bodyIdentity.netId, controller.transform.position).Send(NetworkDestination.Clients);
}
RoR2.Util.PlayScaledSound(EntityStates.Engi.EngiWeapon.ChargeGrenades.chargeStockSoundString, body.gameObject, jarBullets.Count);
EntityState.Destroy(controller.gameObject);
}
}
}
}
}
}
else
{
IsSuckingProjectiles = false;
}
if (ChargeTime > 0)
{
if (!IsCharging && NetworkServer.active)
{
var bodyIdentity = body.gameObject.GetComponent <NetworkIdentity>();
if (bodyIdentity)
{
new SyncJarCharging(jarBullets.Count, ChargeTime, RefireTime, bodyIdentity.netId).Send(NetworkDestination.Clients);
}
IsCharging = true;
}
ChargeTime -= Time.fixedDeltaTime;
if (ChargeTime <= 0)
{
if (NetworkServer.active)
{
var bullet = jarBullets.Last();
FireProjectileInfo projectileInfo = new FireProjectileInfo();
projectileInfo.projectilePrefab = JarProjectile;
projectileInfo.damage = 20 + bullet.Damage * 2;
projectileInfo.damageColorIndex = bullet.DamageColorIndex;
projectileInfo.damageTypeOverride = bullet.DamageType;
projectileInfo.owner = body.gameObject;
projectileInfo.procChainMask = default(RoR2.ProcChainMask);
projectileInfo.position = TargetTransform ? TargetTransform.position : body.corePosition;
projectileInfo.rotation = RoR2.Util.QuaternionSafeLookRotation(input ? input.aimDirection : body.transform.forward);
projectileInfo.speedOverride = 120;
ProjectileManager.instance.FireProjectile(projectileInfo);
jarBullets.RemoveAt(jarBullets.Count - 1);
}
RoR2.Util.PlaySound(EntityStates.ClayBoss.FireTarball.attackSoundString, body.gameObject);
ClientBullets--;
if (jarBullets.Count > 0 || ClientBullets > 0)
{
ChargeTime += RefireTime;
}
}
}
else
{
IsCharging = false;
}
}
// Token: 0x0600055D RID: 1373 RVA: 0x00015BE3 File Offset: 0x00013DE3
public static void SpawnEffect(GameObject effectPrefab, EffectData effectData, bool transmit)
{
EffectManager.SpawnEffect(EffectCatalog.FindEffectIndexFromPrefab(effectPrefab), effectData, transmit);
}
private bool PerformEquipmentAction(EquipmentIndex equipmentIndex)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Boolean RoR2.EquipmentSlot::PerformEquipmentAction(RoR2.EquipmentIndex)' called on client");
return(false);
}
switch (equipmentIndex)
{
case EquipmentIndex.CommandMissile:
this.remainingMissiles += 12;
return(true);
case EquipmentIndex.Saw:
{
Vector3 position = base.transform.position;
Ray aimRay = this.GetAimRay();
bool crit = Util.CheckRoll(this.characterBody.crit, this.characterBody.master);
ProjectileManager.instance.FireProjectile(Resources.Load <GameObject>("Prefabs/Projectiles/Sawmerang"), aimRay.origin, Util.QuaternionSafeLookRotation(aimRay.direction), base.gameObject, this.characterBody.damage, 0f, crit, DamageColorIndex.Default, null, -1f);
return(true);
}
case EquipmentIndex.Fruit:
if (this.healthComponent)
{
Util.PlaySound("Play_item_use_fruit", base.gameObject);
EffectData effectData = new EffectData();
effectData.origin = base.transform.position;
effectData.SetNetworkedObjectReference(base.gameObject);
EffectManager.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/FruitHealEffect"), effectData, true);
this.healthComponent.HealFraction(0.5f, default(ProcChainMask));
return(true);
}
return(true);
case EquipmentIndex.Meteor:
{
MeteorStormController component = UnityEngine.Object.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/NetworkedObjects/MeteorStorm"), this.characterBody.corePosition, Quaternion.identity).GetComponent <MeteorStormController>();
component.owner = base.gameObject;
component.ownerDamage = this.characterBody.damage;
component.isCrit = Util.CheckRoll(this.characterBody.crit, this.characterBody.master);
NetworkServer.Spawn(component.gameObject);
return(true);
}
case EquipmentIndex.SoulJar:
return(true);
case EquipmentIndex.Blackhole:
{
Vector3 position2 = base.transform.position;
Ray aimRay2 = this.GetAimRay();
ProjectileManager.instance.FireProjectile(Resources.Load <GameObject>("Prefabs/Projectiles/GravSphere"), position2, Util.QuaternionSafeLookRotation(aimRay2.direction), base.gameObject, 0f, 0f, false, DamageColorIndex.Default, null, -1f);
return(true);
}
case EquipmentIndex.GhostGun:
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/NetworkedObjects/GhostGun"), base.transform.position, Quaternion.identity);
gameObject.GetComponent <GhostGunController>().owner = base.gameObject;
NetworkServer.Spawn(gameObject);
return(true);
}
case EquipmentIndex.CritOnUse:
this.characterBody.AddTimedBuff(BuffIndex.FullCrit, 8f);
return(true);
case EquipmentIndex.DroneBackup:
{
Util.PlaySound("Play_item_use_radio", base.gameObject);
int sliceCount = 4;
float num = 25f;
if (NetworkServer.active)
{
float y = Quaternion.LookRotation(this.GetAimRay().direction).eulerAngles.y;
float d = 3f;
foreach (float num2 in new DegreeSlices(sliceCount, 0.5f))
{
Quaternion rotation = Quaternion.Euler(0f, y + num2, 0f);
Quaternion rotation2 = Quaternion.Euler(0f, y + num2 + 180f, 0f);
Vector3 position3 = base.transform.position + rotation * (Vector3.forward * d);
CharacterMaster characterMaster = this.SummonMaster(Resources.Load <GameObject>("Prefabs/CharacterMasters/DroneBackupMaster"), position3, rotation2);
if (characterMaster)
{
characterMaster.gameObject.AddComponent <MasterSuicideOnTimer>().lifeTimer = num + UnityEngine.Random.Range(0f, 3f);
}
}
}
this.subcooldownTimer = 0.5f;
return(true);
}
case EquipmentIndex.OrbitalLaser:
{
Vector3 position4 = base.transform.position;
RaycastHit raycastHit;
if (Physics.Raycast(this.GetAimRay(), out raycastHit, 900f, LayerIndex.world.mask | LayerIndex.defaultLayer.mask))
{
position4 = raycastHit.point;
}
GameObject gameObject2 = (GameObject)UnityEngine.Object.Instantiate(Resources.Load("Prefabs/NetworkedObjects/OrbitalLaser"), position4, Quaternion.identity);
gameObject2.GetComponent <OrbitalLaserController>().ownerBody = this.characterBody;
NetworkServer.Spawn(gameObject2);
return(true);
}
case EquipmentIndex.BFG:
this.bfgChargeTimer = 2f;
this.subcooldownTimer = 2.2f;
return(true);
case EquipmentIndex.Enigma:
{
EquipmentIndex equipmentIndex2 = EquipmentCatalog.enigmaEquipmentList[UnityEngine.Random.Range(0, EquipmentCatalog.enigmaEquipmentList.Count - 1)];
this.PerformEquipmentAction(equipmentIndex2);
return(true);
}
case EquipmentIndex.Jetpack:
{
JetpackController jetpackController = JetpackController.FindJetpackController(base.gameObject);
if (!jetpackController)
{
GameObject gameObject3 = UnityEngine.Object.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/NetworkedObjects/JetpackController"));
jetpackController = gameObject3.GetComponent <JetpackController>();
jetpackController.NetworktargetObject = base.gameObject;
NetworkServer.Spawn(gameObject3);
return(true);
}
jetpackController.ResetTimer();
return(true);
}
case EquipmentIndex.Lightning:
{
this.UpdateTargets();
HurtBox hurtBox = this.currentTargetHurtBox;
if (hurtBox)
{
this.subcooldownTimer = 0.2f;
OrbManager.instance.AddOrb(new LightningStrikeOrb
{
attacker = base.gameObject,
damageColorIndex = DamageColorIndex.Item,
damageValue = this.characterBody.damage * 30f,
isCrit = Util.CheckRoll(this.characterBody.crit, this.characterBody.master),
procChainMask = default(ProcChainMask),
procCoefficient = 1f,
target = hurtBox
});
this.InvalidateCurrentTarget();
return(true);
}
return(false);
}
case EquipmentIndex.PassiveHealing:
if (this.passiveHealingFollower)
{
this.UpdateTargets();
this.passiveHealingFollower.AssignNewTarget(this.currentTargetBodyObject);
this.InvalidateCurrentTarget();
return(true);
}
return(true);
case EquipmentIndex.BurnNearby:
if (this.characterBody)
{
this.characterBody.AddHelfireDuration(8f);
return(true);
}
return(true);
case EquipmentIndex.SoulCorruptor:
{
this.UpdateTargets();
HurtBox hurtBox2 = this.currentTargetHurtBox;
if (!hurtBox2)
{
return(false);
}
if (!hurtBox2.healthComponent || hurtBox2.healthComponent.combinedHealthFraction > 0.25f)
{
return(false);
}
Util.TryToCreateGhost(hurtBox2.healthComponent.body, this.characterBody, 30);
hurtBox2.healthComponent.Suicide(base.gameObject, null, DamageType.Generic);
this.InvalidateCurrentTarget();
return(true);
}
case EquipmentIndex.Scanner:
NetworkServer.Spawn(UnityEngine.Object.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/NetworkedObjects/ChestScanner"), this.characterBody.corePosition, Quaternion.identity));
return(true);
case EquipmentIndex.CrippleWard:
NetworkServer.Spawn(UnityEngine.Object.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/NetworkedObjects/CrippleWard"), this.characterBody.corePosition, Quaternion.identity));
this.inventory.SetEquipmentIndex(EquipmentIndex.None);
return(true);
case EquipmentIndex.Gateway:
return(this.FireGateway());
case EquipmentIndex.Tonic:
this.characterBody.AddTimedBuff(BuffIndex.TonicBuff, EquipmentSlot.tonicBuffDuration);
if (!Util.CheckRoll(80f, this.characterBody.master))
{
this.characterBody.pendingTonicAfflictionCount++;
return(true);
}
return(true);
case EquipmentIndex.QuestVolatileBattery:
return(false);
case EquipmentIndex.Cleanse:
{
Vector3 corePosition = this.characterBody.corePosition;
EffectData effectData2 = new EffectData
{
origin = corePosition
};
effectData2.SetHurtBoxReference(this.characterBody.mainHurtBox);
EffectManager.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/CleanseEffect"), effectData2, true);
BuffIndex buffIndex = BuffIndex.Slow50;
BuffIndex buffCount = (BuffIndex)BuffCatalog.buffCount;
while (buffIndex < buffCount)
{
if (BuffCatalog.GetBuffDef(buffIndex).isDebuff)
{
this.characterBody.ClearTimedBuffs(buffIndex);
}
buffIndex++;
}
DotController.RemoveAllDots(base.gameObject);
SetStateOnHurt component2 = base.GetComponent <SetStateOnHurt>();
if (component2)
{
component2.Cleanse();
}
float num3 = 6f;
float num4 = num3 * num3;
TeamIndex teamIndex = this.teamComponent.teamIndex;
List <ProjectileController> instancesList = InstanceTracker.GetInstancesList <ProjectileController>();
List <ProjectileController> list = new List <ProjectileController>();
int i = 0;
int count = instancesList.Count;
while (i < count)
{
ProjectileController projectileController = instancesList[i];
if (projectileController.teamFilter.teamIndex != teamIndex && (projectileController.transform.position - corePosition).sqrMagnitude < num4)
{
list.Add(projectileController);
}
i++;
}
int j = 0;
int count2 = list.Count;
while (j < count2)
{
ProjectileController projectileController2 = list[j];
if (projectileController2)
{
UnityEngine.Object.Destroy(projectileController2.gameObject);
}
j++;
}
return(true);
}
case EquipmentIndex.FireBallDash:
{
Ray aimRay3 = this.GetAimRay();
GameObject gameObject4 = UnityEngine.Object.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/NetworkedObjects/FireballVehicle"), aimRay3.origin, Quaternion.LookRotation(aimRay3.direction));
gameObject4.GetComponent <VehicleSeat>().AssignPassenger(base.gameObject);
CharacterBody characterBody = this.characterBody;
NetworkUser networkUser;
if (characterBody == null)
{
networkUser = null;
}
else
{
CharacterMaster master = characterBody.master;
if (master == null)
{
networkUser = null;
}
else
{
PlayerCharacterMasterController playerCharacterMasterController = master.playerCharacterMasterController;
networkUser = ((playerCharacterMasterController != null) ? playerCharacterMasterController.networkUser : null);
}
}
NetworkUser networkUser2 = networkUser;
if (networkUser2)
{
NetworkServer.SpawnWithClientAuthority(gameObject4, networkUser2.gameObject);
}
else
{
NetworkServer.Spawn(gameObject4);
}
this.subcooldownTimer = 2f;
return(true);
}
case EquipmentIndex.GainArmor:
this.characterBody.AddTimedBuff(BuffIndex.ElephantArmorBoost, 5f);
return(true);
}
return(false);
}
public void TakeDamage(DamageInfo damageInfo)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.HealthComponent::TakeDamage(RoR2.DamageInfo)' called on client");
return;
}
if (!alive || godMode)
{
return;
}
CharacterBody characterBody = null;
if (damageInfo.attacker)
{
characterBody = damageInfo.attacker.GetComponent <CharacterBody>();
}
BroadcastMessage("OnIncomingDamage", damageInfo, SendMessageOptions.DontRequireReceiver);
var master = body.master;
GetComponent <TeamComponent>();
if (master && master.inventory)
{
var itemCount = master.inventory.GetItemCount((ItemIndex)1);
if (itemCount > 0 && Util.CheckRoll((1f - 1f / (0.15f * itemCount + 1f)) * 100f, 0f, null))
{
var effectData = new EffectData
{
origin = damageInfo.position,
rotation = Util.QuaternionSafeLookRotation((damageInfo.force != Vector3.zero) ? damageInfo.force : Random.onUnitSphere)
};
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/BearProc"), effectData, true);
damageInfo.rejected = true;
}
}
if (body.HasBuff((BuffIndex)3))
{
damageInfo.rejected = true;
}
if (body.HasBuff((BuffIndex)23) && (!characterBody || !characterBody.HasBuff((BuffIndex)22)))
{
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/DamageRejected"), new EffectData
{
origin = damageInfo.position
}, true);
damageInfo.rejected = true;
}
if (damageInfo.rejected)
{
return;
}
var num = damageInfo.damage;
if (characterBody)
{
var master2 = characterBody.master;
if (master2 && master2.inventory)
{
if (combinedHealth >= fullCombinedHealth * 0.9f)
{
var itemCount2 = master2.inventory.GetItemCount((ItemIndex)17);
if (itemCount2 > 0)
{
Util.PlaySound("Play_item_proc_crowbar", gameObject);
num *= 1.5f + 0.3f * (itemCount2 - 1);
EffectManager.instance.SimpleImpactEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/ImpactCrowbar"), damageInfo.position, -damageInfo.force, true);
}
}
if (body.isBoss)
{
var itemCount3 = master2.inventory.GetItemCount((ItemIndex)61);
if (itemCount3 > 0)
{
num *= 1.2f + 0.1f * (itemCount3 - 1);
damageInfo.damageColorIndex = (DamageColorIndex)5;
EffectManager.instance.SimpleImpactEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/ImpactBossDamageBonus"), damageInfo.position, -damageInfo.force, true);
}
}
}
}
if (damageInfo.crit)
{
num *= 2f;
}
if ((damageInfo.damageType & DamageType.WeakPointHit) != 0)
{
num *= 1.5f;
damageInfo.damageColorIndex = (DamageColorIndex)5;
}
if ((damageInfo.damageType & DamageType.BypassArmor) == 0)
{
var armor = body.armor;
var num2 = armor >= 0f ? 1f - armor / (armor + 100f) : 2f - 100f / (100f - armor);
num = Mathf.Max(1f, num * num2);
}
if ((damageInfo.damageType & DamageType.BarrierBlocked) != 0)
{
damageInfo.force *= 0.5f;
var component = GetComponent <IBarrier>();
component?.BlockedDamage(damageInfo, num);
damageInfo.procCoefficient = 0f;
num = 0f;
}
if (hasOneshotProtection)
{
num = Mathf.Min(num, fullCombinedHealth * 0.40f); // Make this more aggressive; 90% -> 40%
}
if ((damageInfo.damageType & DamageType.SlowOnHit) != 0)
{
body.AddTimedBuff(0, 2f);
}
if ((damageInfo.damageType & DamageType.ClayGoo) != 0 && (body.bodyFlags & CharacterBody.BodyFlags.ImmuneToGoo) == 0)
{
body.AddTimedBuff((BuffIndex)21, 2f);
}
if (master && master.inventory)
{
var itemCount4 = master.inventory.GetItemCount((ItemIndex)44);
if (itemCount4 > 0)
{
var num3 = num / fullCombinedHealth;
var num4 = (uint)Mathf.Max(master.money * num3 * itemCount4, damageInfo.damage * itemCount4);
master.money = (uint)Mathf.Max(0f, master.money - num4);
EffectManager.instance.SimpleImpactEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/CoinImpact"), damageInfo.position, Vector3.up, true);
}
}
if ((damageInfo.damageType & DamageType.NonLethal) != 0)
{
num = Mathf.Max(Mathf.Min(num, health - 1f), 0f);
}
if (shield > 0f)
{
var num5 = Mathf.Min(num, shield);
var num6 = num - num5;
Networkshield = Mathf.Max(shield - num5, 0f);
if (Mathf.Approximately(shield, 0f))
{
var scale = 1f;
if (body)
{
scale = body.radius;
}
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/ShieldBreakEffect"), new EffectData
{
origin = transform.position,
scale = scale
}, true);
}
if (num6 > 0f)
{
Networkhealth = health - num6;
}
}
else
{
Networkhealth = health - num;
}
TakeDamageForce(damageInfo, false);
SendMessage("OnTakeDamage", damageInfo, SendMessageOptions.DontRequireReceiver);
var damageReport = new DamageReport
{
victim = this,
damageInfo = damageInfo
};
damageReport.damageInfo.damage = num;
if (num > 0f)
{
SendDamageDealt(damageReport);
}
UpdateLastHitTime(damageInfo.damage, damageInfo.position, (damageInfo.damageType & (DamageType)2048) > 0);
if (damageInfo.attacker)
{
damageInfo.attacker.SendMessage("OnDamageDealt", damageReport, SendMessageOptions.DontRequireReceiver);
}
GlobalEventManager.ServerDamageDealt(damageReport);
if (isInFrozenState && (body.bodyFlags & (CharacterBody.BodyFlags) 16) == 0 && combinedHealthFraction < 0.3f)
{
Networkhealth = -1f;
EffectManager.instance.SpawnEffect(FrozenState.executeEffectPrefab, new EffectData
{
origin = body.corePosition,
scale = body ? body.radius : 1f
}, true);
}
if (!alive)
{
BroadcastMessage("OnKilled", damageInfo, SendMessageOptions.DontRequireReceiver);
if (damageInfo.attacker)
{
damageInfo.attacker.SendMessage("OnKilledOther", damageReport, SendMessageOptions.DontRequireReceiver);
}
GlobalEventManager.instance.OnCharacterDeath(damageReport);
return;
}
if (master && master.inventory)
{
var itemCount5 = master.inventory.GetItemCount((ItemIndex)25);
if (itemCount5 > 0 && Util.CheckRoll(damageInfo.damage / fullCombinedHealth * 100f, master))
{
body.AddTimedBuff((BuffIndex)7, 1.5f + itemCount5 * 1.5f);
body.AddTimedBuff((BuffIndex)8, 1.5f + itemCount5 * 1.5f);
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/ProcStealthkit"), new EffectData
{
origin = transform.position,
rotation = Quaternion.identity
}, true);
}
}
}
