// Token: 0x060030C6 RID: 12486 RVA: 0x000D1F04 File Offset: 0x000D0104
public override void OnEnter()
{
base.OnEnter();
if (base.isAuthority)
{
FireMine.ResolveVelocities();
Transform transform = base.transform.Find("FirePoint");
ProjectileDamage component = base.GetComponent <ProjectileDamage>();
Vector3 forward = transform.TransformVector(FireMine.velocities[this.fireIndex]);
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
crit = component.crit,
damage = component.damage,
damageColorIndex = component.damageColorIndex,
force = component.force,
owner = base.owner,
position = transform.position,
procChainMask = base.projectileController.procChainMask,
projectilePrefab = FireMine.projectilePrefab,
rotation = Quaternion.LookRotation(forward),
fuseOverride = -1f,
useFuseOverride = false,
speedOverride = forward.magnitude,
useSpeedOverride = true
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
}
private void fireArrow()
{
Ray aim = GetAimRay();
PlayCrossfade("Gesture, Override", "FireSeekingShot", "FireSeekingShot.playbackRate", arrowTime, arrowTime * 0.2f / attackSpeedStat);
PlayCrossfade("Gesture, Additive", "FireSeekingShot", "FireSeekingShot.playbackRate", arrowTime, arrowTime * 0.2f / attackSpeedStat);
Util.PlayScaledSound(fireSoundString, base.gameObject, attackSpeedStat);
FireProjectileInfo info = new FireProjectileInfo
{
projectilePrefab = projPrefab,
position = aim.origin,
rotation = Util.QuaternionSafeLookRotation(CalculateSpreadVector(aim.direction, characterBody.spreadBloomAngle, 0f, 2)),
owner = gameObject,
useSpeedOverride = false,
useFuseOverride = false,
damage = damageStat * 0.6f,
force = 1f,
crit = base.RollCrit(),
damageColorIndex = DamageColorIndex.Default,
procChainMask = new ProcChainMask()
};
ProjectileManager.instance.FireProjectile(info);
arrowCounter++;
base.characterBody.AddSpreadBloom(baseSpread / Mathf.Sqrt(arrowCounter) + flatSpread);
}
protected virtual void CreateExplosion()
{
if (!this.hasFired)
{
this.hasFired = true;
if (base.isAuthority)
{
Ray aimRay = base.GetAimRay();
FireProjectileInfo blinkExplosionInfo = new FireProjectileInfo
{
projectilePrefab = this.explosionPrefab,
position = this.entryLocation,
rotation = Util.QuaternionSafeLookRotation(aimRay.direction),
owner = base.gameObject,
damage = StaticValues.explosionDamageCoefficient * this.damageStat * this.fireDamageBonus,
force = 400f,
crit = base.RollCrit(),
damageColorIndex = DamageColorIndex.Default,
target = null,
speedOverride = -1f
};
ProjectileManager.instance.FireProjectile(blinkExplosionInfo);
}
}
}
// Token: 0x06002B66 RID: 11110 RVA: 0x000B6E5C File Offset: 0x000B505C
private void Fire()
{
RaycastHit raycastHit;
Vector3 point;
if (base.inputBank.GetAimRaycast(FireMortar2.maxDistance, out raycastHit))
{
point = raycastHit.point;
}
else
{
point = base.inputBank.GetAimRay().GetPoint(FireMortar2.maxDistance);
}
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = FireMortar2.projectilePrefab,
position = point,
rotation = Quaternion.identity,
owner = base.gameObject,
damage = FireMortar2.damageCoefficient * this.damageStat,
force = FireMortar2.force,
crit = base.RollCrit(),
damageColorIndex = DamageColorIndex.Default,
target = null,
speedOverride = 0f,
fuseOverride = -1f
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
// Token: 0x06002E23 RID: 11811 RVA: 0x000C43E4 File Offset: 0x000C25E4
public override void OnEnter()
{
base.OnEnter();
this.duration = ThrowPylon.baseDuration / this.attackSpeedStat;
if (base.isAuthority)
{
Ray aimRay = base.GetAimRay();
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
crit = base.RollCrit(),
damage = this.damageStat * ThrowPylon.damageCoefficient,
damageColorIndex = DamageColorIndex.Default,
force = 0f,
owner = base.gameObject,
position = aimRay.origin,
procChainMask = default(ProcChainMask),
projectilePrefab = ThrowPylon.projectilePrefab,
rotation = Quaternion.LookRotation(aimRay.direction),
target = null
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
EffectManager.SimpleMuzzleFlash(ThrowPylon.muzzleflashObject, base.gameObject, ThrowPylon.muzzleString, false);
Util.PlaySound(ThrowPylon.soundString, base.gameObject);
}
public override void OnEnter()
{
base.OnEnter();
EffectManager.SimpleMuzzleFlash(this.muzzleFlashPrefab, base.gameObject, this.muzzleName, false);
this.duration = this.baseDuration / this.attackSpeedStat;
Util.PlaySound(this.enterSoundString, base.gameObject);
base.PlayAnimation(this.animationLayerName, this.animationStateName, this.playbackRateParam, this.duration);
if (base.isAuthority)
{
Ray aimRay = base.GetAimRay();
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
crit = base.RollCrit(),
damage = this.damageCoefficient * this.damageStat,
damageColorIndex = DamageColorIndex.Default,
damageTypeOverride = DamageType.LunarSecondaryRootOnHit,
force = 0f,
owner = base.gameObject,
position = aimRay.origin,
procChainMask = default(ProcChainMask),
projectilePrefab = this.projectilePrefab,
rotation = Quaternion.LookRotation(aimRay.direction),
useSpeedOverride = false
};
for (int i = 0; i < 3; i++)
{
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
}
}
private void Fire()
{
if (this.isAuthority)
{
Ray aimRay = this.GetAimRay();
if (this.projectilePrefab != null)
{
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = this.projectilePrefab,
owner = this.gameObject,
position = aimRay.origin,
rotation = Util.QuaternionSafeLookRotation(aimRay.direction),
damage = this.damageCoefficient * this.damageStat,
force = 0,
crit = this.RollCrit()
};
if (this.bombSoundString != null)
{
Util.PlaySound(this.bombSoundString, this.gameObject);
}
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
this.hasFired = true;
}
}
}
public override void OnEnter()
{
base.OnEnter();
this.duration = FireLunarNeedle.baseDuration / this.attackSpeedStat;
if (base.isAuthority)
{
Ray aimRay = base.GetAimRay();
aimRay.direction = Util.ApplySpread(aimRay.direction, 0f, FireLunarNeedle.maxSpread, 1f, 1f, 0f, 0f);
FireProjectileInfo fireProjectileInfo = default(FireProjectileInfo);
fireProjectileInfo.position = aimRay.origin;
fireProjectileInfo.rotation = Quaternion.LookRotation(aimRay.direction);
fireProjectileInfo.crit = base.characterBody.RollCrit();
fireProjectileInfo.damage = base.characterBody.damage * FireLunarNeedle.damageCoefficient;
fireProjectileInfo.damageColorIndex = DamageColorIndex.Default;
fireProjectileInfo.owner = base.gameObject;
fireProjectileInfo.procChainMask = default(ProcChainMask);
fireProjectileInfo.force = 0f;
fireProjectileInfo.useFuseOverride = false;
fireProjectileInfo.useSpeedOverride = false;
fireProjectileInfo.target = null;
fireProjectileInfo.projectilePrefab = FireLunarNeedle.projectilePrefab;
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
base.AddRecoil(-0.4f * FireLunarNeedle.recoilAmplitude, -0.8f * FireLunarNeedle.recoilAmplitude, -0.3f * FireLunarNeedle.recoilAmplitude, 0.3f * FireLunarNeedle.recoilAmplitude);
base.characterBody.AddSpreadBloom(FireLunarNeedle.spreadBloomValue);
base.StartAimMode(2f, false);
EffectManager.SimpleMuzzleFlash(FireLunarNeedle.muzzleFlashEffectPrefab, base.gameObject, "Head", false);
Util.PlaySound(FireLunarNeedle.fireSound, base.gameObject);
base.PlayAnimation(this.animationLayerName, this.animationStateName, this.playbackRateParam, this.duration);
}
private void LaunchFireRing()
{
if (base.isAuthority && this.projectilePrefab)
{
Ray aimRay = base.GetAimRay();
FireProjectileInfo fireRingInfo = new FireProjectileInfo
{
projectilePrefab = this.projectilePrefab,
position = aimRay.origin,
rotation = Util.QuaternionSafeLookRotation(aimRay.direction),
owner = base.gameObject,
damage = this.damageStat * StaticValues.fireSpellDamageCoefficient * this.fireDamageBonus,
force = StaticValues.fireSpellForce,
crit = base.RollCrit(),
damageColorIndex = DamageColorIndex.Default
};
ProjectileManager.instance.FireProjectile(fireRingInfo);
this.hasFired = true;
if (!this.hasRemovedBuff)
{
ElementalBonus(1);
}
}
}
private void Fire()
{
if (base.isAuthority)
{
Ray aimRay = base.GetAimRay();
if (this.projectilePrefab != null)
{
float num = Util.Remap(this.charge, 0f, 1f, this.minDamageCoefficient, this.maxDamageCoefficient);
float num2 = this.charge * this.force;
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = this.projectilePrefab,
position = aimRay.origin,
rotation = Util.QuaternionSafeLookRotation(aimRay.direction),
owner = base.gameObject,
damage = this.damageStat * num,
force = num2,
crit = base.RollCrit(),
speedOverride = 120f
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
if (base.characterMotor)
{
base.characterMotor.ApplyForce(aimRay.direction * (-this.selfForce * this.charge), false, false);
}
}
}
private void Fire()
{
if (this.isAuthority)
{
Ray aimRay = this.GetAimRay();
if (this.projectilePrefab != null)
{
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = this.projectilePrefab,
owner = base.gameObject,
position = base.GetModelChildLocator().FindChild("Ball2").position,
rotation = Util.QuaternionSafeLookRotation(aimRay.direction),
damage = this.damageCoef * base.damageStat,
force = 0,
crit = this.RollCrit()
};
//Util.PlaySound(this.bombSound, this.gameObject);
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
this.hasFired = true;
}
}
}
private void FireServer(Ray aimRay, float scale)
{
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = Projectiles.yokoPiercingRoundPrefab,
position = aimRay.origin,
rotation = Util.QuaternionSafeLookRotation(aimRay.direction),
owner = base.gameObject,
damage = YokoPiercingRifle.damageCoefficient * this.damageStat * scale,
force = 100f,
crit = base.RollCrit(),
damageColorIndex = DamageColorIndex.Default,
target = null,
speedOverride = YokoPiercingRifle.throwForce,
fuseOverride = -1f,
damageTypeOverride = null
};
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(fireProjectileInfo.projectilePrefab, fireProjectileInfo.position, fireProjectileInfo.rotation);
ProjectileController component = gameObject.GetComponent <ProjectileController>();
component.NetworkpredictionId = 0;
ProjectileManager.InitializeProjectile(component, fireProjectileInfo);
var scaleProjectileController = gameObject.GetComponent <ScaleProjectileController>();
scaleProjectileController.NetworkChargeRate = scale;
NetworkServer.Spawn(gameObject);
}
private void Fire()
{
if (this.hasFired)
{
return;
}
this.hasFired = true;
if (!this.projectilePrefab)
{
return;
}
if (base.isAuthority)
{
Ray aimRay = base.GetAimRay();
if (this.projectilePrefab != null)
{
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = this.projectilePrefab,
position = this.spellPosition,
rotation = this.spellRotation,
owner = base.gameObject,
damage = this.damageStat,
force = 0f,
crit = base.RollCrit()
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
}
}
private void ProcMissile(int mNum, CharacterBody attackerBody, ProcChainMask procChainMask, GameObject victim, DamageInfo damageInfo, int stack)
{
GameObject gameObject = attackerBody.gameObject;
InputBankTest component = gameObject.GetComponent <InputBankTest>();
Vector3 position = component ? component.aimOrigin : gameObject.transform.position;
float dmgCoef = dmgCoefficient + (dmgStack * stack);
float damage = Util.OnHitProcDamage(damageInfo.damage, attackerBody.damage, dmgCoef);
ProcChainMask procChainMask2 = procChainMask;
procChainMask2.AddProc(ProcType.Missile);
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = GlobalEventManager.instance.missilePrefab,
position = position,
rotation = Util.QuaternionSafeLookRotation(DetermineFacing(mNum)),
procChainMask = procChainMask2,
target = victim,
owner = gameObject,
damage = damage,
crit = damageInfo.crit,
force = 200f,
damageColorIndex = DamageColorIndex.Item
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
// Token: 0x06002B4E RID: 11086 RVA: 0x000B68AF File Offset: 0x000B4AAF
protected override void ModifyProjectile(ref FireProjectileInfo fireProjectileInfo)
{
base.ModifyProjectile(ref fireProjectileInfo);
fireProjectileInfo.position = this.currentTrajectoryInfo.hitPoint;
fireProjectileInfo.rotation = Quaternion.identity;
fireProjectileInfo.speedOverride = 0f;
}
private void ProcMissile(CharacterBody attackerBody, ProcChainMask procChainMask, float damage, bool crit, int stack)
{
GameObject gameObject = attackerBody.gameObject;
InputBankTest component = gameObject.GetComponent <InputBankTest>();
Vector3 position = component ? component.aimOrigin : gameObject.transform.position;
float dmgCoef = missileDamage + (missileStackDamage * (stack - 1));
damage *= dmgCoef;
ProcChainMask procChainMask2 = procChainMask;
procChainMask2.AddProc(ProcType.Missile);
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = GlobalEventManager.instance.missilePrefab,
position = position,
rotation = Util.QuaternionSafeLookRotation(Vector3.up),
procChainMask = procChainMask2,
owner = gameObject,
damage = damage,
crit = crit,
force = 200f,
damageColorIndex = DamageColorIndex.Item
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
private static void ProcMissile(int stack, CharacterBody attackerBody, CharacterMaster attackerMaster,
TeamIndex attackerTeamIndex, ProcChainMask procChainMask, GameObject victim, DamageInfo damageInfo)
{
if (stack > 0)
{
GameObject gameObject = attackerBody.gameObject;
InputBankTest component = gameObject.GetComponent <InputBankTest>();
Vector3 position = component ? component.aimOrigin : gameObject.transform.position;
Vector3 vector = component ? component.aimDirection : gameObject.transform.forward;
Vector3 up = Vector3.up;
if (Util.CheckRoll(10f * GNCProtoRocketConfig.GNCProtoRocketProcChance.Value, attackerMaster))
{
float damageCoefficient = 2f * (float)stack;
float damage = Util.OnHitProcDamage(damageInfo.damage, attackerBody.damage, damageCoefficient);
ProcChainMask procChainMask2 = procChainMask;
procChainMask2.AddProc(ProcType.Missile);
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = GlobalEventManager.instance.daggerPrefab,
position = position,
rotation = Util.QuaternionSafeLookRotation(Vector3.up + Random.insideUnitSphere * 0.1f),
procChainMask = procChainMask2,
target = victim,
owner = gameObject,
damage = damage,
crit = damageInfo.crit,
force = 200f,
damageColorIndex = DamageColorIndex.Item
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
}
}
private void Detonate()
{
if (this.hasExploded)
{
return;
}
this.hasExploded = true;
if (base.modelLocator)
{
if (base.modelLocator.modelBaseTransform)
{
EntityState.Destroy(base.modelLocator.modelBaseTransform.gameObject);
}
if (base.modelLocator.modelTransform)
{
EntityState.Destroy(base.modelLocator.modelTransform.gameObject);
}
}
new BlastAttack
{
attacker = base.gameObject,
inflictor = base.gameObject,
teamIndex = TeamComponent.GetObjectTeam(base.gameObject),
baseDamage = this.damageStat * ExplosiveHeadbutt.damageCoefficent,
baseForce = 0f,
position = base.transform.position,
radius = ExplosiveHeadbutt.explosionRadius,
procCoefficient = 2f,
attackerFiltering = AttackerFiltering.NeverHit,
damageType = DamageType.PoisonOnHit
}.Fire();
Vector3 footPosition = base.characterBody.footPosition;
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = EntityStates.Croco.BaseLeap.projectilePrefab,
crit = base.RollCrit(),
force = 0f,
damage = this.damageStat,
owner = base.gameObject,
rotation = Quaternion.identity,
position = footPosition
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
EffectManager.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/CrocoLeapExplosion"), new EffectData
{
origin = footPosition,
scale = ExplosiveHeadbutt.explosionRadius
}, true);
if (base.healthComponent)
{
base.healthComponent.Suicide(null, null, DamageType.Generic);
}
}
public override void OnEnter()
{
base.OnEnter();
float baseMaxDuration = 2f;
float autoFireDuration = baseMaxDuration / attackSpeedStat;
Ray aimRay = base.GetAimRay();
base.StartAimMode(aimRay, 2f, false);
base.PlayAnimation("Gesture, Additive", "FireNovaBomb", "FireShotgun", autoFireDuration * 3f);
base.PlayAnimation("Gesture, Override", "FireNovaBomb", "FireShotgun", autoFireDuration * 3f);
bool isAuthority = base.isAuthority;
if (isAuthority)
{
if (!projectilePrefab)
{
projectilePrefab = Resources.Load <GameObject>("Prefabs/Projectiles/gravsphere").InstantiateClone("ArtificerSpecialGrav");
var temp = projectilePrefab.AddComponent <ProjectileImpactExplosion>();
temp.destroyOnEnemy = false;
temp.destroyOnWorld = true;
temp.blastRadius = 10f;
temp.blastAttackerFiltering = AttackerFiltering.Default;
temp.blastDamageCoefficient = 10f;
temp.childrenCount = 0;
temp.blastProcCoefficient = 0.2f;
var temp2 = projectilePrefab.GetComponentInChildren <RadialForce>();
temp2.radius *= 2;
temp2.forceMagnitude *= 3;
}
bool crit = Util.CheckRoll(base.characterBody.crit, base.characterBody.master);
Vector3 position = base.characterBody.inputBank ? base.characterBody.inputBank.aimOrigin : base.transform.position;
FireProjectileInfo info = new FireProjectileInfo()
{
projectilePrefab = projectilePrefab,
position = position,
rotation = Util.QuaternionSafeLookRotation(base.GetAimRay().direction),
owner = base.characterBody.gameObject,
damage = base.characterBody.damage * 10f,
force = 20f,
crit = crit,
damageColorIndex = DamageColorIndex.Default,
target = null,
speedOverride = 16f,
useFuseOverride = true,
fuseOverride = 4f
};
ProjectileManager.instance.FireProjectile(info);
}
OnExit();
}
private void FireTheSwordOnBulletAttack(On.RoR2.BulletAttack.orig_Fire orig, RoR2.BulletAttack self)
{
var projectileOwner = self.owner;
if (projectileOwner)
{
var projectileBody = projectileOwner.GetComponent <CharacterBody>();
if (projectileBody)
{
var InventoryCount = GetCount(projectileBody);
if (InventoryCount > 0)
{
if (projectileBody.healthComponent.combinedHealthFraction >= 1)
{
var newProjectileInfo = new FireProjectileInfo();
newProjectileInfo.owner = projectileOwner;
newProjectileInfo.projectilePrefab = SwordProjectile;
newProjectileInfo.speedOverride = 100.0f;
newProjectileInfo.damage = projectileBody.damage * baseSwordDamageMultiplier + (projectileBody.damage * additionalSwordDamageMultiplier * (InventoryCount - 1));
newProjectileInfo.damageTypeOverride = null;
newProjectileInfo.damageColorIndex = DamageColorIndex.Default;
newProjectileInfo.procChainMask = default(RoR2.ProcChainMask);
Vector3 MuzzleTransform = self.origin;
var weapon = self.weapon;
if (weapon)
{
var weaponModelLocator = weapon.GetComponent <ModelLocator>();
if (weaponModelLocator && weaponModelLocator.transform)
{
ChildLocator childLocator = weaponModelLocator.modelTransform.GetComponent <ChildLocator>();
if (childLocator)
{
if (self.muzzleName != null)
{
MuzzleTransform = childLocator.FindChild(self.muzzleName).position;
}
}
}
}
newProjectileInfo.position = MuzzleTransform;
newProjectileInfo.rotation = RoR2.Util.QuaternionSafeLookRotation(self.aimVector);
try
{
RecursionPrevention = true;
RoR2.Projectile.ProjectileManager.instance.FireProjectile(newProjectileInfo);
}
finally
{
RecursionPrevention = false;
}
}
}
}
}
orig(self);
}
private void FireSplinter(On.RoR2.HealthComponent.orig_TakeDamage orig, RoR2.HealthComponent self, RoR2.DamageInfo damageInfo)
{
var body = self.body;
if (body)
{
if (body.HasBuff(EliteBuffIndex))
{
var newProjectileInfo = new FireProjectileInfo();
newProjectileInfo.owner = body.gameObject;
newProjectileInfo.projectilePrefab = SplinteringProjectile;
newProjectileInfo.speedOverride = 50.0f;
newProjectileInfo.damage = body.damage;
newProjectileInfo.damageTypeOverride = null;
newProjectileInfo.damageColorIndex = DamageColorIndex.Default;
newProjectileInfo.procChainMask = default(RoR2.ProcChainMask);
//var theta = (Math.PI * 2) / swordsPerFlower;
//var angle = theta * i;
//var radius = 3;
//var positionChosen = new Vector3((float)(radius * Math.Cos(angle) + damageInfo.position.x), damageInfo.position.y + 3, (float)(radius * Math.Sin(angle) + damageInfo.position.z));
Vector3 PositionChosen;
if (damageInfo.attacker)
{
var attackerBody = damageInfo.attacker.GetComponent <CharacterBody>();
if (attackerBody)
{
PositionChosen = attackerBody.corePosition;
}
else
{
PositionChosen = body.transform.position;
}
}
else
{
PositionChosen = body.transform.position;
}
if (random.nextNormalizedFloat > 0.15f)
{
var randomOffset = new Vector3(random.RangeFloat(-1, 1), random.RangeFloat(-1, 1), random.RangeFloat(-1, 1));
if (randomOffset.Equals(Vector3.zero))
{
randomOffset = Vector3.one;
}
PositionChosen += randomOffset.normalized * random.RangeFloat(0, 10);
}
newProjectileInfo.position = damageInfo.position;
newProjectileInfo.rotation = RoR2.Util.QuaternionSafeLookRotation(PositionChosen - damageInfo.position);
if (NetworkServer.active)
{
EffectManager.SimpleEffect(Resources.Load <GameObject>("Prefabs/Effects/BrittleDeath"), newProjectileInfo.position, newProjectileInfo.rotation, true);
}
ProjectileManager.instance.FireProjectile(newProjectileInfo);
}
}
orig(self, damageInfo);
}
private void FireSwordsFromFlower(ILContext il)
{
var c = new ILCursor(il);
int damageInfoIndex = 15;
c.GotoNext(x => x.MatchNewobj <DamageInfo>());
c.GotoNext(x => x.MatchStloc(out damageInfoIndex));
c.GotoNext(MoveType.After, x => x.MatchLdfld <HurtBox>("hurtBoxGroup"));
c.Emit(OpCodes.Ldloc, damageInfoIndex);
c.EmitDelegate <Action <DamageInfo> >((damageInfo) =>
{
if (damageInfo.attacker)
{
var body = damageInfo.attacker.GetComponent <CharacterBody>();
if (body)
{
var InventoryCount = GetCount(body);
if (InventoryCount > 0)
{
if (body.healthComponent.combinedHealthFraction >= 1)
{
var swordsPerFlower = (int)body.attackSpeed * 2;
for (int i = 1; i <= swordsPerFlower; i++)
{
var newProjectileInfo = new FireProjectileInfo();
newProjectileInfo.owner = body.gameObject;
newProjectileInfo.projectilePrefab = SwordProjectile;
newProjectileInfo.speedOverride = 150.0f;
newProjectileInfo.damage = body.damage * baseSwordDamageMultiplier + (body.damage * additionalSwordDamageMultiplier * (InventoryCount - 1));
newProjectileInfo.damageTypeOverride = null;
newProjectileInfo.damageColorIndex = DamageColorIndex.Default;
newProjectileInfo.procChainMask = default(RoR2.ProcChainMask);
var theta = (Math.PI * 2) / swordsPerFlower;
var angle = theta * i;
var radius = 3;
var positionChosen = new Vector3((float)(radius * Math.Cos(angle) + damageInfo.position.x), damageInfo.position.y + 3, (float)(radius * Math.Sin(angle) + damageInfo.position.z));
newProjectileInfo.position = positionChosen;
newProjectileInfo.rotation = RoR2.Util.QuaternionSafeLookRotation(damageInfo.position - positionChosen);
try
{
RecursionPrevention = true;
RoR2.Projectile.ProjectileManager.instance.FireProjectile(newProjectileInfo);
}
finally
{
RecursionPrevention = false;
}
}
}
}
}
}
});
}
public static void Fire(Vector3 position, Quaternion rotation, float speed)
{
var info = new FireProjectileInfo();
info.position = position;
info.rotation = rotation;
info.projectilePrefab = HailstormAssets.AsteroidProjectilePrefab;
info.force = 10000;
info.damage = 50;
info.speedOverride = speed;
info.useSpeedOverride = true;
ProjectileManager.instance.FireProjectile(info);
}
public override void FixedUpdate()
{
base.FixedUpdate();
timer += Time.fixedDeltaTime;
if (timer >= intervalFire)
{
timer -= intervalFire;
Vector3 position = aimOrigin.position;
Vector3 direction = transform.forward;
direction = RoR2Util.ApplySpread(direction, 0, spread, 1, 1);
Quaternion rotation = RoR2Util.QuaternionSafeLookRotation(direction);
StopSound();
soundId = (int)RoR2Util.PlaySound(soundString, gameObject);
if (effectPrefab)
{
EffectData effectData = new EffectData
{
origin = position,
rootObject = aimOrigin.gameObject,
rotation = rotation
};
EffectManager.SpawnEffect(effectPrefab, effectData, false);
Util.EffectOptions(characterBody, effectPrefab, false);
}
if (isAuthority)
{
float computedDamage = damageStat * damageCoefficient;
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = grenadePrefab,
crit = RollCrit(),
damage = computedDamage,
damageColorIndex = DamageColorIndex.Default,
force = 0f,
owner = gameObject,
position = position,
rotation = rotation
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
Util.FireOptions(characterBody, fireProjectileInfo, (_o, optionDirection) =>
{
return(RoR2Util.ApplySpread(optionDirection, 0, spread, 1, 1));
});
Util.TriggerArmsRace(characterBody, computedDamage);
}
}
if (isAuthority && fixedAge >= duration)
{
outer.SetNextStateToMain();
}
}
private void DeflectServer()
{
if (!NetworkServer.active)
{
return;
}
Ray aimRay = base.GetAimRay();
bool reflected = false;
Collider[] array = Physics.OverlapBox(base.transform.position + aimRay.direction * HeatWave.hitboxOffset, HeatWave.hitboxDimensions, Quaternion.LookRotation(aimRay.direction, Vector3.up), LayerIndex.projectile.mask);
for (int i = 0; i < array.Length; i++)
{
ProjectileController pc = array[i].GetComponentInParent <ProjectileController>();
if (pc)
{
if (pc.owner != base.gameObject)
{
Vector3 aimSpot = (aimRay.origin + 100 * aimRay.direction) - pc.gameObject.transform.position;
pc.owner = base.gameObject;
FireProjectileInfo info = new FireProjectileInfo()
{
projectilePrefab = reflectProjectilePrefab,
position = pc.gameObject.transform.position,
rotation = base.characterBody.transform.rotation * Quaternion.FromToRotation(new Vector3(0, 0, 1), aimSpot),
owner = base.characterBody.gameObject,
damage = base.characterBody.damage * HeatWave.reflectDamageCoefficient,
force = 3000f,
crit = base.RollCrit(),
damageColorIndex = DamageColorIndex.Default,
target = null,
speedOverride = 90f,
useSpeedOverride = true
};
ProjectileManager.instance.FireProjectile(info);
Destroy(pc.gameObject);
if (!reflected)
{
reflected = true;
Util.PlaySound(HeatWave.reflectSoundString, base.gameObject);
}
}
}
}
}
public static void ArmsRaceItemHook()
{
On.RoR2.GlobalEventManager.OnHitEnemy += (orig, self, damage, victim) =>
{
if (damage.attacker)
{
CharacterBody Attacker = damage.attacker.GetComponent <CharacterBody>();
CharacterMaster AttackerMaster = Attacker.master;
if (Attacker.name.ToLower().Contains("drone") || Attacker.name.ToLower().Contains("turret"))
{
if (!damage.procChainMask.HasProc(ProcType.Missile))
{
var inventory = AttackerMaster.minionOwnership.ownerMaster.inventory;
int itemCount = inventory.GetItemCount(ArmsRaceItemIndex);
if (itemCount > 0)
{
GameObject gameObject = Attacker.gameObject;
InputBankTest component = gameObject.GetComponent <InputBankTest>();
Vector3 position = component ? component.aimOrigin : gameObject.transform.position;
Vector3 vector = component ? component.aimDirection : gameObject.transform.forward;
Vector3 up = Vector3.up;
if (Util.CheckRoll(15f, AttackerMaster))
{
float damageCoefficient = 3f * itemCount;
float dealdamage = Util.OnHitProcDamage(damage.damage, Attacker.damage, damageCoefficient);
ProcChainMask procChainMask2 = damage.procChainMask;
procChainMask2.AddProc(ProcType.Missile);
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = GlobalEventManager.instance.missilePrefab,
position = position,
rotation = Util.QuaternionSafeLookRotation(up),
procChainMask = procChainMask2,
target = victim,
owner = gameObject,
damage = dealdamage,
crit = damage.crit,
force = 200f,
damageColorIndex = DamageColorIndex.Item
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
}
}
}
orig(self, damage, victim);
}
};
}
private void Anime(ILContext il)
{
var c = new ILCursor(il);
int damageInfoIndex = 4;
c.GotoNext(x => x.MatchNewobj <DamageInfo>(), x => x.MatchStloc(out damageInfoIndex));
c.GotoNext(MoveType.After, x => x.MatchCallOrCallvirt <GlobalEventManager>("OnHitAll"));
c.Emit(OpCodes.Ldloc, damageInfoIndex);
c.EmitDelegate <Action <DamageInfo> >((damageInfo) =>
{
if (damageInfo.attacker)
{
var body = damageInfo.attacker.GetComponent <CharacterBody>();
if (body)
{
var InventoryCount = GetCount(body);
if (InventoryCount > 0)
{
if (body.healthComponent.combinedHealthFraction >= 1)
{
var newProjectileInfo = new FireProjectileInfo();
newProjectileInfo.owner = body.gameObject;
newProjectileInfo.projectilePrefab = SwordProjectile;
newProjectileInfo.speedOverride = 100.0f;
newProjectileInfo.damage = body.damage * baseSwordDamageMultiplier + (body.damage * additionalSwordDamageMultiplier * (InventoryCount - 1));
newProjectileInfo.damageTypeOverride = null;
newProjectileInfo.damageColorIndex = DamageColorIndex.Default;
newProjectileInfo.procChainMask = default(RoR2.ProcChainMask);
var positionChosen = damageInfo.position + new Vector3(swordRandom.RangeFloat(-10, 10), swordRandom.RangeFloat(0, 10), swordRandom.RangeFloat(-10, 10)).normalized * 4;
newProjectileInfo.position = positionChosen;
newProjectileInfo.rotation = RoR2.Util.QuaternionSafeLookRotation(damageInfo.position - positionChosen);
try
{
RecursionPrevention = true;
RoR2.Projectile.ProjectileManager.instance.FireProjectile(newProjectileInfo);
}
finally
{
RecursionPrevention = false;
}
}
}
}
}
});
}
protected void DropAcidPoolAuthority()
{
Vector3 footPosition = base.characterBody.footPosition;
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = projectilePrefab,
crit = this.isCritAuthority,
force = 0f,
damage = this.damageStat,
owner = base.gameObject,
rotation = Quaternion.identity,
position = footPosition
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
private void SuperMissileICBMLaunch(Vector3 position, CharacterBody attacker, ProcChainMask procChainMask, GameObject victim, float missileDamage, bool isCrit, GameObject projectilePrefab, DamageColorIndex damageColorIndex)
{
Vector3 initialDirection = Vector3.up + UnityEngine.Random.insideUnitSphere * 0.1f;
float force = 200f;
bool addMissileProc = true;
int num1 = characterBody.inventory?.GetItemCount(DLC1Content.Items.MoreMissile) ?? 0;
float num2 = Mathf.Max(1f, (1 + 0.5f * (num1 - 1)));
InputBankTest component = inputBank;
ProcChainMask procChainMask1 = procChainMask;
if (addMissileProc)
{
procChainMask1.AddProc(ProcType.Missile);
}
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo()
{
projectilePrefab = projectilePrefab,
position = position,
rotation = Util.QuaternionSafeLookRotation(gunRay.direction),
procChainMask = procChainMask1,
target = victim,
owner = attacker.gameObject,
damage = missileDamage * num2,
crit = isCrit,
force = force,
damageColorIndex = damageColorIndex
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
if (num1 <= 0)
{
return;
}
Vector3 axis = component ? component.aimDirection : attacker.transform.position;
FireProjectileInfo fireProjectileInfo1 = fireProjectileInfo;
fireProjectileInfo1.rotation = Util.QuaternionSafeLookRotation(Quaternion.AngleAxis(45f, axis) * initialDirection);
fireProjectileInfo1.projectilePrefab = sMissileExtraMissiles;
fireProjectileInfo1.damage = Modules.StaticValues.missileDamageCoefficient * damageStat;
FireProjectileInfo fireProjectileInfo2 = fireProjectileInfo;
fireProjectileInfo2.rotation = Util.QuaternionSafeLookRotation(Quaternion.AngleAxis(-45f, axis) * initialDirection);
fireProjectileInfo2.projectilePrefab = sMissileExtraMissiles;
fireProjectileInfo2.damage = Modules.StaticValues.missileDamageCoefficient * damageStat;
ProjectileManager.instance.FireProjectile(fireProjectileInfo1);
ProjectileManager.instance.FireProjectile(fireProjectileInfo2);
}
private void LaunchMortar(CharacterBody attackerBody, ProcChainMask procChainMask, GameObject victim, DamageInfo damageInfo, int stack)
{
GameObject gameObject = attackerBody.gameObject;
InputBankTest component = gameObject.GetComponent <InputBankTest>();
Vector3 position = component ? component.aimOrigin : gameObject.transform.position;
float dmgCoef = dmgCoefficient + (dmgStack * stack);
float damage = Util.OnHitProcDamage(damageInfo.damage, attackerBody.damage, dmgCoef);
ProcChainMask procChainMask2 = procChainMask;
procChainMask2.AddProc(ProcType.Missile);
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
projectilePrefab = mortarPrefab,
position = position,
procChainMask = procChainMask2,
target = victim,
owner = gameObject,
damage = damage,
crit = damageInfo.crit,
force = 500f,
damageColorIndex = DamageColorIndex.Item,
speedOverride = -1f,
damageTypeOverride = DamageType.AOE
};
int times = (int)(1 + stackAmount * stack);
for (int t = 0; t < times; t++)
{
Vector3 direction;
if (fixedAim)
{
direction = gameObject.transform.forward;
}
else
{
direction = component ? component.aimDirection : gameObject.transform.forward;
}
direction = direction.normalized + new Vector3(0f, launchAngle, 0f);
direction += new Vector3(Random.Range(-inaccuracyRate, inaccuracyRate),
Random.Range(-inaccuracyRate, inaccuracyRate),
Random.Range(-inaccuracyRate, inaccuracyRate));
fireProjectileInfo.rotation = Util.QuaternionSafeLookRotation(direction);
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
}
