public void FireCone(Ray aim)
{
var hits = Physics.OverlapSphere(aim.origin, coneRange, LayerIndex.entityPrecise.mask)
.Where(x => Vector3.Angle(aim.direction, x.ClosestPoint(aim.origin) - aim.origin) < coneHalfAngleDegrees);
HashSet <HealthComponent> hitHCs = new HashSet <HealthComponent>();
foreach (var hit in hits)
{
if (hit && hit.TryGetComponent <HurtBox>(out var hb) && hb.healthComponent && !hitHCs.Contains(hb.healthComponent))
{
hitHCs.Add(hb.healthComponent);
if (this.healthComponent == hb.healthComponent || !FriendlyFireManager.ShouldSplashHitProceed(hb.healthComponent, this.teamComponent.teamIndex))
{
continue;
}
var di = new DamageInfo {
attacker = this.characterBody.gameObject,
canRejectForce = true,
crit = this.characterBody.RollCrit(),
damage = this.characterBody.damage * damageCoeff,
damageColorIndex = DamageColorIndex.Default,
damageType = DamageType.AOE,
force = Vector3.zero,
inflictor = null,
procChainMask = default,
private void ColliderExit(Collider col)
{
if (this.collidersInZone.Contains(col))
{
this.collidersInZone.Remove(col);
}
var hb = col?.GetComponent <HurtBox>();
if (hb == null)
{
return;
}
if (!this.targetBoxes.ContainsValue(hb))
{
return;
}
var hc = hb.healthComponent;
if (hc == null)
{
return;
}
if (!FriendlyFireManager.ShouldDirectHitProceed(hc, this.team))
{
return;
}
if (hc == this.attackerBody.healthComponent)
{
return;
}
this.targetBoxes.RemoveValue(hb);
}
private void ColliderEnter(Collider col)
{
this.collidersInZone.Add(col);
var hb = col?.GetComponent <HurtBox>();
if (hb == null)
{
return;
}
var hc = hb.healthComponent;
if (hc == null)
{
return;
}
if (!FriendlyFireManager.ShouldDirectHitProceed(hc, this.team))
{
return;
}
if (hc == this.attackerBody.healthComponent)
{
return;
}
this.targetBoxes.Add(hc, hb);
}
private void Detonate(Single damage, Vector3 force, Single procCoef, DamageType damageType)
{
HashSet <HealthComponent> mask = HashSetPool <HealthComponent> .item;
//mask.Clear();
var count = Physics.OverlapCapsuleNonAlloc(this.position - new Vector3(0f, 10f, 0f), this.position + new Vector3(0f, 1000f, 0f), this.radius * 2f, colliderBuffer, LayerIndex.entityPrecise.mask);
Log.Warning($"Detonate, count = {count}");
for (Int32 i = 0; i < count; ++i)
{
var col = colliderBuffer[i];
if (col is null)
{
//Main.LogW( "Null collider" );
continue;
}
var hb = col.GetComponent <HurtBox>();
if (hb is null)
{
//Main.LogW( "Null Hurtbox" );
continue;
}
var hc = hb.healthComponent;
if (hc is null)
{
//Main.LogW( "Null healthcomponent" );
continue;
}
if (!mask.Add(hc))
{
//Main.LogW( "Already hit" );
continue;
}
if (!FriendlyFireManager.ShouldDirectHitProceed(hc, this.team))
{
//Main.LogW( "Cannot hit team" );
continue;
}
var info = new DamageInfo
{
attacker = this.owner,
crit = this.crit,
damage = damage,
damageColorIndex = DamageColorIndex.Default,
damageType = damageType,
dotIndex = DotController.DotIndex.None,
force = force,
inflictor = null,
position = hc.transform.position,
procChainMask = default,
private void FireOverlapAttack()
{
if (FriendlyFireManager.ShouldDirectHitProceed(this.stuckObjectHealthComponent, this.teamIndex))
{
this.stuckObjectHealthComponent.TakeDamage(new DamageInfo
{
attacker = this.attacker,
inflictor = this.gameObject,
damage = this.damage,
damageColorIndex = DamageColorIndex.WeakPoint,
damageType = this.damageType,
crit = this.isCrit,
dotIndex = DotController.DotIndex.None,
force = Vector3.zero,
position = this.transform.position,
procChainMask = this.procChainMask,
procCoefficient = this.procCoefficient
});
GlobalEventManager.instance.OnHitEnemy(new DamageInfo
{
attacker = this.attacker,
inflictor = this.gameObject,
damage = this.damage,
damageColorIndex = DamageColorIndex.WeakPoint,
damageType = this.damageType,
crit = this.isCrit,
dotIndex = DotController.DotIndex.None,
force = Vector3.zero,
position = this.transform.position,
procChainMask = this.procChainMask,
procCoefficient = this.procCoefficient
}, this.stuckObject);
EffectManager.SpawnEffect(BootlegThermiteOverlapAttack.burnEffectPrefab, new EffectData
{
origin = this.transform.position,
scale = 2f
}, true);
}
}
public void TickDamage()
{
RaycastHit[] array = Physics.BoxCastAll(boxCollider.center, boxCollider.size / 2, Vector3.forward, Quaternion.identity, 5f, RoR2.LayerIndex.entityPrecise.mask, QueryTriggerInteraction.UseGlobal);
foreach (var hit in array)
{
if (hit.collider)
{
var hc = hit.collider.GetComponent <HealthComponent>();
if (hc)
{
if (FriendlyFireManager.ShouldSplashHitProceed(hc, owner.teamComponent.teamIndex))
{
var damageInfo = new DamageInfo()
{
attacker = owner.gameObject,
inflictor = gameObject,
crit = owner.RollCrit(),
damage = damage,
damageColorIndex = DamageColorIndex.Item,
damageType = DamageType.SlowOnHit,
force = Vector3.zero,
position = hc.body ? hc.body.corePosition : hc.transform.position,
procChainMask = default,
private bool HurtBoxPassesFilter(HurtBox hurtBox)
{
return(!hurtBox.healthComponent || ((!(hurtBox.healthComponent.gameObject == this.attack.attacker) || this.attack.attackerFiltering != AttackerFiltering.NeverHit) && (!(this.attack.attacker == null) || !(hurtBox.healthComponent.gameObject.GetComponent <MaulingRock>() != null)) && FriendlyFireManager.ShouldDirectHitProceed(hurtBox.healthComponent, this.attack.teamIndex)));
}
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;
damageInfo.inflictor = base.gameObject;
damageInfo.position = impactInfo.estimatedPointOfImpact;
damageInfo.force = this.projectileDamage.force * base.transform.forward;
damageInfo.procChainMask = this.projectileController.procChainMask;
damageInfo.procCoefficient = this.projectileController.procCoefficient;
damageInfo.damageColorIndex = this.projectileDamage.damageColorIndex;
damageInfo.damageType = this.projectileDamage.damageType;
}
else
{
Debug.Log(ManipulatorPlugin.MODNAME + ": No projectile damage component on: " + this + "!");
}
HurtBox hurtBox = collider.GetComponent <HurtBox>();
if (hurtBox)
{
HealthComponent healthComponent = hurtBox.healthComponent;
if (healthComponent)
{
if (!this.attack.ignoredHealthComponentList.Contains(healthComponent))
{
this.attack.ignoredHealthComponentList.Add(healthComponent);
if (healthComponent.gameObject == this.projectileController.owner)
{
return;
}
if (FriendlyFireManager.ShouldDirectHitProceed(healthComponent, this.projectileController.teamFilter.teamIndex))
{
Util.PlaySound(this.enemyHitSoundString, base.gameObject);
if (NetworkServer.active)
{
damageInfo.ModifyDamageInfo(hurtBox.damageModifier);
healthComponent.TakeDamage(damageInfo);
GlobalEventManager.instance.OnHitEnemy(damageInfo, hurtBox.healthComponent.gameObject);
}
}
this.HitEnemyEvent();
}
}
}
else if (this.destroyOnWorld)
{
this.alive = false;
}
damageInfo.position = base.transform.position;
if (NetworkServer.active)
{
GlobalEventManager.instance.OnHitAll(damageInfo, collider.gameObject);
}
}
if (!this.alive)
{
if (NetworkServer.active && this.impactEffect)
{
EffectManager.SimpleImpactEffect(this.impactEffect, impactInfo.estimatedPointOfImpact, -base.transform.forward, !this.projectileController.isPrediction);
}
Util.PlaySound(this.hitSoundString, base.gameObject);
}
}
private void BeamAttack(BeamAttackInfo beam)
{
RaycastHit beamRh;
Vector3 end = beam.aim.origin;
//if( Physics.Raycast( beam.aim, out beamRh, beam.range, LayerIndex.world.mask, QueryTriggerInteraction.UseGlobal ) )
if (Util.CharacterRaycast(base.outer.gameObject, beam.aim, out beamRh, beam.range, LayerIndex.world.mask, QueryTriggerInteraction.UseGlobal))
{
end = beamRh.point;
var dmg = new DamageInfo
{
attacker = gameObject,
crit = beam.crit,
damage = beam.damage,
damageColorIndex = DamageColorIndex.Default,
damageType = DamageType.Generic,
force = beam.aim.direction * beam.force,
inflictor = gameObject,
position = end,
procChainMask = default(ProcChainMask),
procCoefficient = beam.procCoef
};
DoNetworkedDamage(dmg, null);
}
else
{
end = beam.aim.GetPoint(beam.range);
}
System.Int32 count = Physics.OverlapCapsuleNonAlloc(beam.aim.origin, end, beam.radius, this.beamCols, LayerIndex.entityPrecise.mask, QueryTriggerInteraction.UseGlobal);
this.beamMask.Clear();
Collider tempCol;
HurtBox tempBox;
HealthComponent tempHc;
DamageInfo tempDmgInfo;
//EffectData effect = new EffectData();
for (System.Int32 i = 0; i < count; i++)
{
if (!this.beamCols[i])
{
continue;
}
tempBox = this.dicCheck(this.beamCols[i]).Get(this.beamCols[i].gameObject);
if (!tempBox)
{
continue;
}
tempHc = tempBox.healthComponent;
if (!tempHc || this.beamMask.Contains(tempHc) || !FriendlyFireManager.ShouldDirectHitProceed(tempHc, this.team) || tempHc == base.healthComponent)
{
continue;
}
this.beamMask.Add(tempHc);
tempDmgInfo = new DamageInfo
{
attacker = gameObject,
crit = beam.crit,
damage = beam.damage,
damageColorIndex = DamageColorIndex.Default,
damageType = DamageType.Generic,
force = beam.aim.direction * beam.force,
inflictor = gameObject,
position = tempBox.transform.position,
procChainMask = default(ProcChainMask),
procCoefficient = beam.procCoef
};
//effect.origin = tempBox.transform.position;
//EffectManager.SpawnEffect( Main.genericImpactEffects[this.skin][0], effect, true );
DoNetworkedDamage(tempDmgInfo, tempBox);
}
}
public override void OnArrival()
{
//Explosion effect
EffectData effect = new EffectData
{
origin = dest,
genericUInt = this.skin
};
EffectManager.SpawnEffect(Main.secondaryExplosion, effect, true);
if (this.attacker)
{
HashSet <HealthComponent> mask = new HashSet <HealthComponent>();
HurtBox box;
DamageInfo bdmg = new DamageInfo();
bdmg.damage = this.damage;
bdmg.attacker = this.attacker;
bdmg.crit = this.crit;
bdmg.damageColorIndex = this.damageColor;
bdmg.damageType = DamageType.Generic;
bdmg.force = (this.direction + Vector3.up) * 50f;
bdmg.inflictor = this.attacker;
bdmg.position = this.dest;
bdmg.procChainMask = this.procMask;
bdmg.procCoefficient = this.procCoef;
GlobalEventManager.instance.OnHitAll(bdmg, null);
//Collider[] cols = Physics.OverlapCapsule(this.dest, this.dest + new Vector3(0f, 20f, 0f), this.radius * this.innerRadScale, LayerIndex.entityPrecise.mask, QueryTriggerInteraction.UseGlobal);
//foreach( Collider col in cols )
//{
// if( !col ) continue;
// box = col.GetComponent<HurtBox>();
// if( !box ) continue;
// HealthComponent hcomp = box.healthComponent;
// if( !hcomp || mask.Contains( hcomp ) || TeamComponent.GetObjectTeam( hcomp.gameObject ) == this.team ) continue;
// DamageInfo dmg = new DamageInfo();
// dmg.damage = this.damage;
// dmg.attacker = this.attacker;
// dmg.crit = this.crit;
// dmg.damageColorIndex = this.damageColor;
// dmg.damageType = DamageType.Generic;
// dmg.force = (this.direction + Vector3.up) * 50f;
// dmg.inflictor = this.attacker;
// dmg.position = col.transform.position;
// dmg.procChainMask = this.procMask;
// dmg.procCoefficient = this.procCoef;
// hcomp.TakeDamage( dmg );
// GlobalEventManager.instance.OnHitEnemy( dmg, hcomp.gameObject );
// GlobalEventManager.instance.OnHitAll( dmg, hcomp.gameObject );
// mask.Add( hcomp );
//}
var cols = Physics.OverlapCapsule(this.dest, this.dest + new Vector3(0f, 20f, 0f), this.radius, LayerIndex.entityPrecise.mask, QueryTriggerInteraction.UseGlobal);
foreach (Collider col in cols)
{
if (!col)
{
continue;
}
box = col.GetComponent <HurtBox>();
if (!box)
{
continue;
}
HealthComponent hcomp = box.healthComponent;
if (!hcomp || mask.Contains(hcomp) || !FriendlyFireManager.ShouldDirectHitProceed(hcomp, this.team) || hcomp.gameObject == this.attacker)
{
continue;
}
DamageInfo dmg = new DamageInfo();
dmg.damage = this.damage;
dmg.attacker = this.attacker;
dmg.crit = this.crit;
dmg.damageColorIndex = this.damageColor;
dmg.damageType = DamageType.Generic;
dmg.force = (this.direction + Vector3.up) * 10f;
dmg.inflictor = this.attacker;
dmg.position = col.transform.position;
dmg.procChainMask = this.procMask;
dmg.procCoefficient = this.procCoef * this.edgePenaltyMult;
if (this.hitMask.Contains(hcomp))
{
dmg.damage *= this.edgePenaltyMult;
dmg.procCoefficient *= this.edgePenaltyMult;
}
hcomp.TakeDamage(dmg);
GlobalEventManager.instance.OnHitEnemy(dmg, hcomp.gameObject);
GlobalEventManager.instance.OnHitAll(dmg, hcomp.gameObject);
mask.Add(hcomp);
this.hitMask.Add(hcomp);
}
}
if (this.stepsLeft > 0 && !this.last)
{
SparkOrb nextOrb = new SparkOrb();
nextOrb.maxFall = this.maxFall;
nextOrb.attacker = this.attacker;
nextOrb.crit = this.crit;
nextOrb.damage = this.damage;
nextOrb.damageColor = this.damageColor;
nextOrb.direction = this.direction;
nextOrb.origin = this.dest;
nextOrb.procCoef = this.procCoef;
nextOrb.procMask = this.procMask;
nextOrb.isFirst = false;
nextOrb.radius = this.radius;
nextOrb.scale = this.scale;
nextOrb.speed = this.speed;
nextOrb.stepDist = this.stepDist;
nextOrb.stepHeight = this.stepHeight;
nextOrb.stepsLeft = this.stepsLeft - 1;
nextOrb.target = this.target;
nextOrb.team = this.team;
nextOrb.skin = this.skin;
nextOrb.hitMask = this.hitMask;
OrbManager.instance.AddOrb(nextOrb);
}
}
public void FixedUpdate()
{
this.fixedAge += Time.fixedDeltaTime;
if (this.fixedAge >= 0.2f && !this.attached)
{
this.alive = false;
}
if (!this.attachedHealth.alive)
{
this.alive = false;
}
if (this.attached)
{
this.timer += Time.fixedDeltaTime;
if (this.timer >= this.attachDuration)
{
this.alive = false;
}
else
{
if (this.attachHitCount > 0)
{
this.nextAttackTimer += Time.fixedDeltaTime;
if (this.nextAttackTimer >= this.attachDuration / (float)this.attachHitCount)
{
this.nextAttackTimer -= this.attachDuration / (float)this.attachHitCount;
if (mainHurtBox)
{
HealthComponent health = mainHurtBox.healthComponent;
DamageInfo damageInfo = new DamageInfo();
if (this.projectileDamage)
{
damageInfo.damage = this.projectileDamage.damage * this.attachDamageCoefficient;
damageInfo.crit = this.projectileDamage.crit;
damageInfo.attacker = this.projectileController.owner;
damageInfo.inflictor = base.gameObject;
damageInfo.position = mainHurtBox.transform.position;
damageInfo.force = new Vector3(0f, 0f, 0f);
damageInfo.procChainMask = this.projectileController.procChainMask;
damageInfo.procCoefficient = this.projectileController.procCoefficient;
damageInfo.damageColorIndex = this.projectileDamage.damageColorIndex;
damageInfo.damageType = this.projectileDamage.damageType;
}
else
{
Debug.Log("No projectile damage component!");
}
if (mainHurtBox.healthComponent.gameObject == this.projectileController.owner)
{
return;
}
if (FriendlyFireManager.ShouldDirectHitProceed(health, this.projectileController.teamFilter.teamIndex))
{
Util.PlaySound(this.attachTickSoundString, base.gameObject);
if (NetworkServer.active)
{
damageInfo.ModifyDamageInfo(mainHurtBox.damageModifier);
health.TakeDamage(damageInfo);
GlobalEventManager.instance.OnHitEnemy(damageInfo, mainHurtBox.healthComponent.gameObject);
}
}
}
}
}
}
}
if (!this.alive)
{
if (this.destroyWhenNotAlive)
{
UnityEngine.Object.Destroy(base.gameObject);
}
}
}
public void OnProjectileImpact(ProjectileImpactInfo impactInfo)
{
Debug.LogWarning($"stopwatch: {this.stopwatch}");
Debug.LogWarning($"stopwatch divided: {this.stopwatch / this.maxCoefficient}");
Debug.LogWarning($"damage: {this.projectileDamage.damage * (this.stopwatch / this.maxCoefficient)}");
if (!this.alive)
{
return;
}
Collider collider = impactInfo.collider;
hitEnemyInfo = impactInfo;
hitEnemyCollider = collider;
if (collider)
{
DamageInfo damageInfo = new DamageInfo();
if (this.projectileDamage)
{
damageInfo.damage = this.projectileDamage.damage * (this.stopwatch / this.maxCoefficient);
damageInfo.crit = this.projectileDamage.crit;
damageInfo.attacker = this.projectileController.owner;
damageInfo.inflictor = base.gameObject;
damageInfo.position = impactInfo.estimatedPointOfImpact;
damageInfo.force = this.projectileDamage.force * base.transform.forward;
damageInfo.procChainMask = this.projectileController.procChainMask;
damageInfo.procCoefficient = this.projectileController.procCoefficient;
damageInfo.damageColorIndex = this.projectileDamage.damageColorIndex;
damageInfo.damageType = this.projectileDamage.damageType;
}
else
{
Debug.Log("No projectile damage component!");
}
HurtBox component = collider.GetComponent <HurtBox>();
if (component)
{
HealthComponent healthComponent = component.healthComponent;
if (healthComponent)
{
if (healthComponent.gameObject == this.projectileController.owner)
{
return;
}
if (FriendlyFireManager.ShouldDirectHitProceed(healthComponent, this.projectileController.teamFilter.teamIndex))
{
Util.PlaySound(this.enemyHitSoundString, base.gameObject);
if (NetworkServer.active)
{
damageInfo.ModifyDamageInfo(component.damageModifier);
healthComponent.TakeDamage(damageInfo);
this.ApplyIceDebuff(healthComponent);
GlobalEventManager.instance.OnHitEnemy(damageInfo, component.healthComponent.gameObject);
}
}
this.alive = false;
}
}
else if (this.destroyOnWorld)
{
this.alive = false;
}
damageInfo.position = base.transform.position;
if (NetworkServer.active)
{
GlobalEventManager.instance.OnHitAll(damageInfo, collider.gameObject);
}
}
if (this.fireChildren)
{
for (int i = 0; i < this.childrenCount; i++)
{
Vector3 vector = new Vector3(UnityEngine.Random.Range(this.minAngleOffset.x, this.maxAngleOffset.x), UnityEngine.Random.Range(this.minAngleOffset.z, this.maxAngleOffset.z), UnityEngine.Random.Range(this.minAngleOffset.z, this.maxAngleOffset.z));
switch (this.transformSpace)
{
case ProjectileImpactExplosion.TransformSpace.World:
this.FireChild(vector);
break;
case ProjectileImpactExplosion.TransformSpace.Local:
this.FireChild(base.transform.forward + base.transform.TransformDirection(vector));
break;
case ProjectileImpactExplosion.TransformSpace.Normal:
this.FireChild(this.impactNormal + vector);
break;
}
}
}
if (!this.alive)
{
if (NetworkServer.active && this.impactEffect)
{
EffectManager.SimpleImpactEffect(this.impactEffect, impactInfo.estimatedPointOfImpact, -base.transform.forward, !this.projectileController.isPrediction);
}
Util.PlaySound(this.hitSoundString, base.gameObject);
if (this.destroyWhenNotAlive)
{
UnityEngine.Object.Destroy(base.gameObject);
}
}
}
private void CharacterBody_FixedUpdate(On.RoR2.CharacterBody.orig_FixedUpdate orig, CharacterBody self)
{
orig(self);
if (!NetworkServer.active || !self)
{
return;
}
var cpt = self.gameObject.GetComponent <HeadsetComponent>();
if (!cpt)
{
cpt = self.gameObject.AddComponent <HeadsetComponent>();
}
var count = GetCount(self);
if (count <= 0)
{
cpt.hitsRemaining = 0;
}
else if (cpt.hitsRemaining > 0)
{
var atkTeam = TeamComponent.GetObjectTeam(self.gameObject);
var p1 = cpt.previousPos;
var p2 = self.transform.position;
Collider[] res;
if (p1 == p2)
{
res = Physics.OverlapSphere(p1, HITBOX_RADIUS, LayerIndex.entityPrecise.mask, QueryTriggerInteraction.Ignore);
}
else
{
res = Physics.OverlapCapsule(p1, p2, HITBOX_RADIUS, LayerIndex.entityPrecise.mask, QueryTriggerInteraction.Ignore);
}
var damageInfo = new DamageInfo {
attacker = self.gameObject,
inflictor = self.gameObject,
crit = false,
damage = self.damage * (baseDamagePct + stackDamagePct * (count - 1)),
damageColorIndex = DamageColorIndex.Item,
damageType = DamageType.Generic,
force = Vector3.zero,
procCoefficient = 1f
};
foreach (var hit in res)
{
if (!hit)
{
continue;
}
var hurtbox = hit.GetComponent <HurtBox>();
if (!hurtbox ||
!hurtbox.healthComponent ||
hurtbox.healthComponent == self.healthComponent ||
!FriendlyFireManager.ShouldSplashHitProceed(hurtbox.healthComponent, atkTeam))
{
continue;
}
var icd = hurtbox.healthComponent.gameObject.GetComponent <HeadsetICDComponent>();
if (!icd)
{
icd = hurtbox.healthComponent.gameObject.AddComponent <HeadsetICDComponent>();
}
if (Time.fixedTime - icd.lastHit < HIT_INTERVAL)
{
continue;
}
icd.lastHit = Time.fixedTime;
damageInfo.position = hit.transform.position;
hurtbox.healthComponent.TakeDamage(damageInfo);
var ssoh = hurtbox.healthComponent.GetComponent <SetStateOnHurt>();
if (ssoh && ssoh.canBeStunned)
{
ssoh.SetStun(stunDuration);
}
cpt.hitsRemaining--;
if (cpt.hitsRemaining <= 0)
{
break;
}
}
cpt.previousPos = p2;
}
int currBuffStacks = self.GetBuffCount(headsetBuff);
if (cpt.hitsRemaining != currBuffStacks)
{
self.SetBuffCount(headsetBuff.buffIndex, cpt.hitsRemaining);
}
}
public void DamageVictim()
{
if (!this.active)
{
return;
}
if (this.stickOnImpact.victim == null)
{
return;
}
if (this.stickOnImpact.victim)
{
DamageInfo damageInfo = new DamageInfo();
if (this.projectileDamage)
{
damageInfo.damage = this.projectileDamage.damage * this.damageCoefficient;
damageInfo.crit = this.projectileDamage.crit;
damageInfo.attacker = this.projectileController.owner;
damageInfo.inflictor = base.gameObject;
damageInfo.position = this.stickOnImpact.victim.transform.position;
damageInfo.force = this.projectileDamage.force * base.transform.forward;
damageInfo.procChainMask = this.projectileController.procChainMask;
damageInfo.procCoefficient = this.projectileController.procCoefficient * this.procCoefficient;
damageInfo.damageColorIndex = this.projectileDamage.damageColorIndex;
damageInfo.damageType = this.projectileDamage.damageType;
}
else
{
Debug.Log("No projectile damage component!");
}
HealthComponent victimHealth = this.stickOnImpact.victim.GetComponent <HealthComponent>();
if (!victimHealth)
{
Debug.Log("No Health Component on Victim!");
return;
}
if (victimHealth)
{
if (victimHealth.gameObject == this.projectileController.owner)
{
return;
}
if (FriendlyFireManager.ShouldDirectHitProceed(victimHealth, this.projectileController.teamFilter.teamIndex))
{
Util.PlaySound(this.enemyHitSoundString, base.gameObject);
if (NetworkServer.active)
{
CharacterBody victimBody = this.stickOnImpact.victim.GetComponent <CharacterBody>();
damageInfo.ModifyDamageInfo(victimBody.mainHurtBox.damageModifier);
victimHealth.TakeDamage(damageInfo);
GlobalEventManager.instance.OnHitEnemy(damageInfo, victimHealth.gameObject);
}
}
}
damageInfo.position = base.transform.position;
if (NetworkServer.active)
{
GlobalEventManager.instance.OnHitAll(damageInfo, victimHealth.gameObject);
UnityEvent unityEvent = this.onServerHit;
if (unityEvent == null)
{
return;
}
unityEvent.Invoke();
}
}
}
private void FixedUpdate_Il3(ILContext il)
{
BindingFlags allFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
FieldInfo characterBody = typeof(HuntressTracker).GetField("characterBody", allFlags);
FieldInfo trackingTarget = typeof(HuntressTracker).GetField("trackingTarget", allFlags);
FieldInfo maxDistance = typeof(HuntressTracker).GetField("maxTrackingDistance", allFlags);
FieldInfo trackerUpdateStopwatch = typeof(HuntressTracker).GetField("trackerUpdateStopwatch", allFlags);
FieldInfo trackerUpdateFrequency = typeof(HuntressTracker).GetField("trackerUpdateFrequency", allFlags);
FieldInfo indicator = typeof(HuntressTracker).GetField("indicator", allFlags);
FieldInfo indicator_targetTransform = typeof(RoR2.Indicator).GetField("targetTransform", allFlags);
FieldInfo hurtBox_group = typeof(HurtBox).GetField(nameof(HurtBox.hurtBoxGroup), allFlags);
FieldInfo mainHurtBox = typeof(HurtBoxGroup).GetField(nameof(HurtBoxGroup.mainHurtBox), allFlags);
//MethodInfo fixedDeltaTime = typeof(Time).GetProperty( "fixedDeltaTime", allFlags ).GetGetMethod();
MethodInfo object_implicit = typeof(UnityEngine.Object).GetMethod("op_Implicit", allFlags);
HurtBox CastTarget(CharacterBody body, Single range)
{
var ray = body.inputBank.GetAimRay();
var myTeam = body.teamComponent.teamIndex;
var hits = Physics.SphereCastNonAlloc(ray, 0.75f, hitResultsBuffer, range, LayerIndex.entityPrecise.mask, QueryTriggerInteraction.UseGlobal);
Single worldDist = Single.PositiveInfinity;
if (hits > 0 && Physics.Raycast(ray, out RaycastHit hit, range, LayerIndex.world.mask, QueryTriggerInteraction.UseGlobal))
{
worldDist = hit.distance + 1f;
}
HurtBox result = null;
Single bestDistance = Single.PositiveInfinity;
for (Int32 i = 0; i < hits; ++i)
{
var res = hitResultsBuffer[i];
if (res.distance > bestDistance)
{
continue;
}
if (res.distance > worldDist)
{
continue;
}
var col = res.collider;
if (col is null)
{
continue;
}
var hb = col.GetComponent <HurtBox>();
if (hb is null)
{
continue;
}
var hc = hb.healthComponent;
if (hc is null)
{
continue;
}
if (hc == body.healthComponent)
{
continue;
}
if (!FriendlyFireManager.ShouldDirectHitProceed(hc, myTeam))
{
continue;
}
result = hb;
bestDistance = res.distance;
}
return(result);
}
var cursor = new ILCursor(il);
_ = cursor.Emit(OpCodes.Stfld, trackingTarget);
_ = cursor.Emit(OpCodes.Ldarg_0);
_ = cursor.Emit(OpCodes.Ldfld, indicator);
_ = cursor.Emit(OpCodes.Ldarg_0);
_ = cursor.Emit(OpCodes.Ldfld, trackingTarget);
_ = cursor.Emit(OpCodes.Ldfld, hurtBox_group);
_ = cursor.Emit(OpCodes.Ldfld, mainHurtBox);
_ = cursor.Emit <Component>(OpCodes.Callvirt, "get_transform");
_ = cursor.Emit(OpCodes.Stfld, indicator_targetTransform);
_ = cursor.Emit(OpCodes.Ldarg_0);
_ = cursor.Emit(OpCodes.Ldarg_0);
_ = cursor.Emit(OpCodes.Ldfld, trackerUpdateStopwatch);
_ = cursor.EmitDelegate <Func <Single> >(() => Time.fixedDeltaTime);
_ = cursor.Emit(OpCodes.Add);
_ = cursor.Emit(OpCodes.Stfld, trackerUpdateStopwatch);
ILLabel normalPath = cursor.MarkLabel();
_ = cursor.Emit(OpCodes.Pop);
_ = cursor.Emit(OpCodes.Pop);
ILLabel breakLabel = null;
_ = cursor.GotoNext(MoveType.AfterLabel, x => x.MatchBltUn(out breakLabel));
cursor.Index = 0;
_ = cursor.Emit(OpCodes.Ldarg_0);
_ = cursor.Emit(OpCodes.Ldarg_0);
_ = cursor.Emit(OpCodes.Ldfld, characterBody);
_ = cursor.Emit(OpCodes.Ldarg_0);
_ = cursor.Emit(OpCodes.Ldfld, maxDistance);
_ = cursor.EmitDelegate <Func <CharacterBody, Single, HurtBox> >(CastTarget);
_ = cursor.Emit(OpCodes.Dup);
_ = cursor.EmitDelegate <Func <HurtBox, Boolean> >((hb) => hb);
_ = cursor.Emit(OpCodes.Brfalse, normalPath);
_ = cursor.GotoLabel(normalPath, MoveType.Before);
_ = cursor.Emit(OpCodes.Br, breakLabel);
}
