public override void OnEnter()
{
base.OnEnter();
this.duration = SwipeForward.baseDuration / this.attackSpeedStat;
this.modelAnimator = base.GetModelAnimator();
Transform modelTransform = base.GetModelTransform();
this.attack = new OverlapAttack();
this.attack.attacker = base.gameObject;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = TeamIndex.Monster;
this.attack.damage = SwipeForward.damageCoefficient * this.damageStat;
this.attack.hitEffectPrefab = SwipeForward.hitEffectPrefab;
this.attack.isCrit = Util.CheckRoll(this.critStat, base.characterBody.master);
Util.PlaySound(SwipeForward.attackString, base.gameObject);
if (modelTransform)
{
this.attack.hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "Sword");
}
if (this.modelAnimator)
{
base.PlayAnimation("Gesture, Override", "SwipeForward", "SwipeForward.playbackRate", this.duration);
base.PlayAnimation("Gesture, Additive", "SwipeForward", "SwipeForward.playbackRate", this.duration);
}
if (base.characterBody)
{
base.characterBody.SetAimTimer(2f);
}
}
public override void OnEnter()
{
procCoefficient = DoubleSlash.procCoefficient;
selfForce = DoubleSlash.selfForce;
hitEffectPrefab = DoubleSlash.hitEffectPrefab;
swipeEffectPrefab = DoubleSlash.swipeEffectPrefab;
enterSoundString = DoubleSlash.enterSoundString;
slashSoundString = DoubleSlash.slashSoundString;
walkSpeedPenaltyCoefficient = DoubleSlash.walkSpeedPenaltyCoefficient;
base.OnEnter();
duration = baseDuration / attackSpeedStat;
modelAnimator = GetModelAnimator();
modelTransform = GetModelTransform();
base.characterMotor.walkSpeedPenaltyCoefficient = walkSpeedPenaltyCoefficient;
attack = new OverlapAttack();
attack.attacker = base.gameObject;
attack.inflictor = base.gameObject;
attack.teamIndex = TeamComponent.GetObjectTeam(attack.attacker);
attack.damage = damageCoefficient * damageStat;
attack.hitEffectPrefab = hitEffectPrefab;
attack.isCrit = Util.CheckRoll(critStat, base.characterBody.master);
attack.procCoefficient = procCoefficient;
attack.damageType = DamageType.Generic;
Util.PlayAttackSpeedSound(enterSoundString, base.gameObject, attackSpeedStat);
if ((bool)modelAnimator)
{
PlayAnimation("Gesture, Additive", "DoubleSlash", "DoubleSlash.playbackRate", duration);
PlayAnimation("Gesture, Override", "DoubleSlash", "DoubleSlash.playbackRate", duration);
}
if ((bool)base.characterBody)
{
base.characterBody.SetAimTimer(duration + 2f);
}
}
public override void OnEnter()
{
base.OnEnter();
this.duration = MaceSlam.baseDuration / this.attackSpeedStat;
this.priorityReduceDuration = this.duration * MaceSlam.durationBeforePriorityReduces;
this.modelAnimator = base.GetModelAnimator();
this.modelTransform = base.GetModelTransform();
base.PlayCrossfade("FullBody, Override", "MaceSlam", "Whirlwind.playbackRate", this.duration, 0.1f);
Util.PlayAttackSpeedSound(EntityStates.BrotherMonster.WeaponSlam.attackSoundString, base.gameObject, this.attackSpeedStat);
if (base.characterDirection)
{
base.characterDirection.moveVector = base.GetAimRay().direction;
}
if (base.isAuthority)
{
OverlapAttack overlapAttack = new OverlapAttack();
overlapAttack.attacker = base.gameObject;
overlapAttack.damage = MaceSlam.damageCoefficient * this.damageStat;
overlapAttack.damageColorIndex = DamageColorIndex.Default;
overlapAttack.damageType = DamageType.Generic;
overlapAttack.hitEffectPrefab = EntityStates.BrotherMonster.WeaponSlam.weaponHitEffectPrefab;
overlapAttack.hitBoxGroup = Array.Find <HitBoxGroup>(this.modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "LeapStrike");
overlapAttack.impactSound = EntityStates.BrotherMonster.WeaponSlam.weaponImpactSound.index;
overlapAttack.inflictor = base.gameObject;
overlapAttack.procChainMask = default(ProcChainMask);
overlapAttack.pushAwayForce = MaceSlam.weaponForce;
overlapAttack.procCoefficient = 1f;
overlapAttack.teamIndex = base.GetTeam();
this.weaponAttack = overlapAttack;
}
}
//private StyleSystem.StyleComponent styleComponent;
public override void OnEnter()
{
base.OnEnter();
this.duration = this.baseDuration / this.attackSpeedStat;
this.hasFired = false;
this.animator = base.GetModelAnimator();
//this.styleComponent = base.GetComponent<StyleSystem.StyleComponent>();
base.StartAimMode(0.5f + this.duration, false);
base.PlayCrossfade("Gesture, Override", "Crush", "Crush.playbackRate", this.duration, 0.05f);
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "Crush");
}
this.attack = new OverlapAttack();
this.attack.attacker = base.gameObject;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = base.GetTeam();
this.attack.damage = Crush.damageCoefficient * this.damageStat;
this.attack.procCoefficient = 1;
this.attack.hitEffectPrefab = Loader.SwingChargedFist.overchargeImpactEffectPrefab;
this.attack.forceVector = Vector3.zero;
this.attack.pushAwayForce = 1f;
this.attack.hitBoxGroup = hitBoxGroup;
this.attack.isCrit = base.RollCrit();
}
public override void OnEnter()
{
hitEffectPrefab = SwipeForward.hitEffectPrefab;
swingEffectPrefab = SwipeForward.swingEffectPrefab;
base.OnEnter();
duration = baseDuration / attackSpeedStat;
modelAnimator = GetModelAnimator();
Transform modelTransform = GetModelTransform();
attack = new OverlapAttack();
attack.attacker = base.gameObject;
attack.inflictor = base.gameObject;
attack.teamIndex = TeamComponent.GetObjectTeam(attack.attacker);
attack.damage = damageCoefficient * damageStat;
attack.damageType = DamageType.SuperBleedOnCrit;
attack.hitEffectPrefab = hitEffectPrefab;
attack.isCrit = Util.CheckRoll(critStat, base.characterBody.master);
Util.PlaySound(attackString, base.gameObject);
if ((bool)modelTransform)
{
attack.hitBoxGroup = Array.Find(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "Sword");
}
if ((bool)modelAnimator)
{
PlayAnimation("Gesture, Override", "SwipeForward", "SwipeForward.playbackRate", duration);
PlayAnimation("Gesture, Additive", "SwipeForward", "SwipeForward.playbackRate", duration);
}
if ((bool)base.characterBody)
{
base.characterBody.SetAimTimer(2f);
}
}
public override void OnEnter()
{
base.OnEnter();
this.duration = this.baseDuration / this.attackSpeedStat;
this.earlyExitTime = this.baseEarlyExitTime / this.attackSpeedStat;
this.hasFired = false;
this.animator = base.GetModelAnimator();
base.StartAimMode(0.5f + this.duration, false);
base.characterBody.outOfCombatStopwatch = 0f;
this.animator.SetBool("attacking", true);
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == this.hitboxName);
}
this.PlayAttackAnimation();
this.attack = new OverlapAttack();
this.attack.damageType = this.damageType;
this.attack.attacker = base.gameObject;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = base.GetTeam();
this.attack.damage = this.damageCoefficient * this.damageStat;
this.attack.procCoefficient = this.procCoefficient;
this.attack.hitEffectPrefab = this.hitEffectPrefab;
this.attack.forceVector = this.bonusForce;
this.attack.pushAwayForce = this.pushForce;
this.attack.hitBoxGroup = hitBoxGroup;
this.attack.isCrit = base.RollCrit();
this.attack.impactSound = this.impactSound;
}
public override void OnEnter()
{
base.OnEnter();
base.characterBody.SetAimTimer(2f);
this.hitEffectPrefab = Modules.Assets.punchImpactEffect;
this.impactSound = Modules.Assets.drillRushHitSoundEvent.index;
this.duration = this.baseDuration / this.attackSpeedStat;
this.earlyExitTime = this.baseEarlyExitTime / this.attackSpeedStat;
this.hasFired = false;
this.animator = base.GetModelAnimator();
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == this.hitboxName);
}
var childLocator = this.GetModelChildLocator();
this.pullOrigin = childLocator.FindChild(this.hitboxName);
this.pullStrengthCurve = AnimationCurve.EaseInOut(0.1f, 0f, 1f, 1f);
this.PlayAttackAnimation();
this.attack = CreateAttack(hitBoxGroup);
}
public override void OnEnter()
{
base.OnEnter();
this.duration = AirSlamAlt.leapDuration / (0.5f + (0.5f * this.attackSpeedStat));
this.hasFired = false;
this.hasLanded = false;
this.animator = base.GetModelAnimator();
this.swordController = base.GetComponent <PaladinSwordController>();
base.skillLocator.secondary.DeductStock(1);
Vector3 direction = base.GetAimRay().direction;
if (base.isAuthority)
{
base.characterBody.isSprinting = true;
base.characterMotor.velocity *= 0.1f;
base.SmallHop(base.characterMotor, AirSlamAlt.hopVelocity);
}
base.characterBody.bodyFlags |= CharacterBody.BodyFlags.IgnoreFallDamage;
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
string hitboxString = "LeapStrike";
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == hitboxString);
}
base.PlayAnimation("FullBody, Override", "LeapSlam2", "Whirlwind.playbackRate", this.duration * 1.5f);
Util.PlaySound(Modules.Sounds.Lunge, base.gameObject);
Util.PlaySound(Modules.Sounds.Cloth2, base.gameObject);
this.swordController.airSlamStacks++;
float dmg = AirSlam.damageCoefficient;
this.attack = new OverlapAttack();
this.attack.damageType = DamageType.Stun1s;
this.attack.attacker = base.gameObject;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = base.GetTeam();
this.attack.damage = ((0.5f + (0.5f * this.swordController.airSlamStacks)) * dmg) * this.damageStat;
this.attack.procCoefficient = 1;
this.attack.hitEffectPrefab = this.swordController.hitEffect;
this.attack.forceVector = -Vector3.up * 6000f;
this.attack.pushAwayForce = 500f;
this.attack.hitBoxGroup = hitBoxGroup;
this.attack.isCrit = base.RollCrit();
this.attack.impactSound = Modules.Assets.swordHitSoundEventL.index;
if (this.swordController.isBlunt)
{
this.attack.impactSound = Modules.Assets.batHitSoundEventL.index;
}
}
public override void OnEnter()
{
base.OnEnter();
this.animator = base.GetModelAnimator();
this.hasFired = false;
if (base.characterBody.HasBuff(Survivor.Buffs.overpowerBuff))
{
this.duration = SharpClaws.baseDuration / (this.attackSpeedStat * Overpower.attackSpeedMult);
}
else
{
this.duration = SharpClaws.baseDuration / this.attackSpeedStat;
}
// yay strafe animations
// kind of glitchy still so i leave out for this patch
// StartAimMode(2);
base.characterDirection.forward = base.GetAimRay().direction;
if (animator.GetBool("attackSwitch"))
{
this.animator.SetBool("attackSwitch", false);
this.hitBoxGroup = base.FindHitBoxGroup("LeftClaw");
}
else
{
this.animator.SetBool("attackSwitch", true);
this.hitBoxGroup = base.FindHitBoxGroup("RightClaw");
}
attack = new OverlapAttack
{
attacker = base.gameObject,
inflictor = base.gameObject,
damage = base.damageStat * SharpClaws.damageCoefficient,
damageColorIndex = DamageColorIndex.Default,
damageType = DamageType.Generic,
isCrit = Util.CheckRoll(this.critStat, this.characterBody.master),
hitEffectPrefab = Resources.Load <GameObject>("prefabs/effects/impacteffects/ImpactImpSwipe"),
hitBoxGroup = hitBoxGroup,
impactSound = Survivor.Sounds.hitNetworkSoundEventDef.index,
procChainMask = default(ProcChainMask),
procCoefficient = SharpClaws.procCoefficient,
forceVector = Vector3.zero,
pushAwayForce = 400f,
teamIndex = base.GetTeam(),
};
Util.PlayAttackSpeedSound(Core.Assets.SwingSound, base.gameObject, this.attackSpeedStat);
base.PlayAnimation("Gesture, Override", "Attack", "Attack.playbackRate", this.duration);
if (ClientScene.readyConnection != null)
{
Core.Utils.PlayAnimationOnOtherClients(base.gameObject, "Gesture, Override", "Attack", this.duration, true);
}
Core.Utils.RemoveNetworkedTimedBuff(base.gameObject, Survivor.Buffs.overpowerBuff, 1);
}
public override void OnEnter()
{
base.OnEnter();
this.duration = this.baseDuration / this.attackSpeedStat;
this.hasFired = false;
this.animator = base.GetModelAnimator();
this.swordController = base.GetComponent <PaladinSwordController>();
base.StartAimMode(0.5f + this.duration, false);
base.characterBody.isSprinting = false;
base.skillLocator.secondary.DeductStock(1);
if (this.swordController)
{
this.swordController.attacking = true;
}
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
if (NetworkServer.active)
{
base.characterBody.AddBuff(RoR2Content.Buffs.Slow50);
}
string hitboxString = "SpinSlash";
if (this.swordController && this.swordController.swordActive)
{
hitboxString = "SpinSlashLarge";
}
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == hitboxString);
}
base.PlayAnimation("FullBody, Override", "GroundSweepContinuous", "Whirlwind.playbackRate", this.duration * 1.1f);
Util.PlaySound(Modules.Sounds.Cloth3, base.gameObject);
this.attack = new OverlapAttack();
this.attack.damageType = DamageType.Stun1s;
this.attack.attacker = base.gameObject;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = base.GetTeam();
this.attack.damage = GroundSweepAlt.damageCoefficient * this.damageStat;
this.attack.procCoefficient = 1;
this.attack.hitEffectPrefab = this.swordController.hitEffect;
this.attack.forceVector = Vector3.up * 1600f;
this.attack.pushAwayForce = -1500f;
this.attack.hitBoxGroup = hitBoxGroup;
this.attack.isCrit = base.RollCrit();
this.attack.impactSound = Modules.Assets.swordHitSoundEventM.index;
if (this.swordController.isBlunt)
{
this.attack.impactSound = Modules.Assets.batHitSoundEventM.index;
}
}
// Token: 0x06002E07 RID: 11783 RVA: 0x000C3EE0 File Offset: 0x000C20E0
protected override void AuthorityModifyOverlapAttack(OverlapAttack overlapAttack)
{
base.AuthorityModifyOverlapAttack(overlapAttack);
if (base.HasBuff(BuffIndex.LoaderOvercharged))
{
overlapAttack.damage *= 2f;
overlapAttack.hitEffectPrefab = LoaderMeleeAttack.overchargeImpactEffectPrefab;
overlapAttack.damageType |= DamageType.Stun1s;
}
}
public override void OnEnter()
{
base.OnEnter();
if (TTGL_SurvivorPlugin.rideMeExtendedInstalled)
{
TTGL_SurvivorPlugin.ExitSeat(base.gameObject);
}
if (NetworkServer.active)
{
base.characterBody.AddBuff(Buffs.HiddenInvincibility);
}
if (base.isAuthority)
{
m_TrajectoryNodeCount = TrajectoryNodes != null ? TrajectoryNodes.Length : 0;
if (m_TrajectoryNodeCount > CurrentNodeIndex)
{
var nextNode = TrajectoryNodes[CurrentNodeIndex];
m_CurrentTarget = nextNode.Item1;
}
}
this.cancelled = true;
Util.PlaySound(EvisDash.beginSoundString, base.gameObject);
base.characterMotor.useGravity = false;
var childLocator = base.GetModelChildLocator();
this.rootTransform = childLocator.FindChild("LagganArmature");
base.PlayCrossfade("FullBody, Override", "LagannImpact3", 0.2f);
this.CreateBlinkEffect(Util.GetCorePosition(base.gameObject));
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == c_HitboxGroupName);
}
this.overlapAttack = new OverlapAttack
{
attacker = base.gameObject,
damage = damageCoefficient * base.characterBody.damage,
pushAwayForce = this.pushForce,
isCrit = base.RollCrit(),
damageColorIndex = DamageColorIndex.Default,
inflictor = base.gameObject,
procChainMask = default(ProcChainMask),
procCoefficient = procCoefficient,
teamIndex = base.characterBody.teamComponent.teamIndex,
hitBoxGroup = hitBoxGroup,
hitEffectPrefab = Modules.Assets.punchImpactEffect,
impactSound = Modules.Assets.drillRushHitSoundEvent.index,
};
}
// Token: 0x06000328 RID: 808 RVA: 0x0000D234 File Offset: 0x0000B434
public bool FireMeleeOverlap(OverlapAttack attack, Animator animator, string mecanimHitboxActiveParameter, float forceMagnitude)
{
bool result = false;
if (animator && animator.GetFloat(mecanimHitboxActiveParameter) > 0.1f)
{
attack.forceVector = base.transform.forward * forceMagnitude;
result = attack.Fire(null);
}
return(result);
}
public override void OnEnter()
{
base.OnEnter();
if (TTGL_SurvivorPlugin.rideMeExtendedInstalled)
{
TTGL_SurvivorPlugin.ExpulseAnyRider(base.gameObject);
TTGL_SurvivorPlugin.ExitSeat(base.gameObject);
}
this.animator = base.GetModelAnimator();
if (base.isGrounded)
{
base.PlayCrossfade("FullBody, Override", "LagannBurrowerStrikeBurrow", this.playbackRateString, burrowingDuration, 0.2f);
DisplayMound();
}
else
{
falling = true;
fell = true;
base.PlayCrossfade("FullBody, Override", "LagannBurrowerStrikeFall", 0.2f);
if (NetworkServer.active)
{
base.characterBody.AddBuff(RoR2Content.Buffs.HiddenInvincibility);
}
if (base.isAuthority)
{
base.characterMotor.onMovementHit += this.OnMovementHit;
base.characterMotor.velocity.y = GroundSlam.initialVerticalVelocity;
}
}
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "LagannImpactHitbox");
}
this.attack = new OverlapAttack
{
attacker = base.gameObject,
damage = PrepareLagannBurrowerStrike.damageCoefficient * base.characterBody.damage,
pushAwayForce = 300f,
isCrit = base.RollCrit(),
damageColorIndex = DamageColorIndex.Default,
inflictor = base.gameObject,
procChainMask = default(ProcChainMask),
procCoefficient = 1f,
teamIndex = base.characterBody.teamComponent.teamIndex,
hitBoxGroup = hitBoxGroup,
hitEffectPrefab = Modules.Assets.punchImpactEffect,
impactSound = Modules.Assets.drillRushHitSoundEvent.index,
};
}
/// private List<HealthComponent> victimsStruck = new List<HealthComponent>();
public override void OnEnter()
{
base.OnEnter();
this.duration = ShoulderBash.baseDuration;
this.shieldCancel = false;
base.characterBody.isSprinting = true;
Util.PlayScaledSound(Croco.Leap.leapSoundString, base.gameObject, 1.75f);
if (base.isAuthority && base.inputBank && base.characterDirection)
{
this.forwardDirection = ((base.inputBank.moveVector == Vector3.zero) ? base.characterDirection.forward : base.inputBank.moveVector).normalized;
}
this.RecalculateSpeed();
if (base.characterMotor && base.characterDirection)
{
base.characterMotor.velocity.y *= 0.5f;
base.characterMotor.velocity = this.forwardDirection * this.dashSpeed;
}
Vector3 b = base.characterMotor ? base.characterMotor.velocity : Vector3.zero;
this.previousPosition = base.transform.position - b;
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "HeadH");
}
//hitBoxGroup = Array.Find<HitBoxGroup>(modelTransform.GetComponents<HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "HeadH");
this.attack = new OverlapAttack();
this.attack.attacker = base.gameObject;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = base.GetTeam();
this.attack.damage = ShoulderBash.chargeDamageCoefficient * this.damageStat;
this.attack.hitEffectPrefab = Loader.SwingChargedFist.overchargeImpactEffectPrefab;
this.attack.forceVector = Vector3.up * Toolbot.ToolbotDash.upwardForceMagnitude;
this.attack.pushAwayForce = Toolbot.ToolbotDash.awayForceMagnitude;
this.attack.hitBoxGroup = hitBoxGroup;
this.attack.isCrit = base.RollCrit();
// if (base.isAuthority) EffectManager.SimpleMuzzleFlash(EnforcerPlugin.Assets.shoulderBashFX, base.gameObject, "ShieldHitbox", true);
}
public override void OnEnter()
{
base.OnEnter();
this.animator = base.GetModelAnimator();
this.duration = Uppercut.baseDuration / this.attackSpeedStat;
this.overlapAttack = base.InitMeleeOverlap(Uppercut.baseDamageCoefficient, Uppercut.hitEffectPrefab, base.GetModelTransform(), Uppercut.hitboxString);
this.overlapAttack.forceVector = Vector3.down * Uppercut.upwardForceStrength;
if (base.characterDirection && base.inputBank)
{
base.characterDirection.forward = base.inputBank.aimDirection;
}
Util.PlaySound(Uppercut.enterSoundString, base.gameObject);
this.PlayAnim();
}
public override void OnEnter()
{
base.OnEnter();
this.animator = base.GetModelAnimator();
var childLocator = base.GetModelChildLocator();
this.rootTransform = childLocator.FindChild("LagganArmature");
base.characterMotor.Motor.SetPosition(this.spawnLocation + (this.spawnRotation * 4f));
base.PlayAnimation("FullBody, Override", "BurrowerStrikePop", this.playbackRateString, LagannBurrowerStrike.maxDuration);
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "LagannImpactHitbox");
}
this.attack = new OverlapAttack
{
attacker = base.gameObject,
damage = PrepareLagannBurrowerStrike.damageCoefficient * base.characterBody.damage,
damageType = DamageType.BypassArmor,
pushAwayForce = 300f,
isCrit = base.RollCrit(),
damageColorIndex = DamageColorIndex.WeakPoint,
inflictor = base.gameObject,
procChainMask = default(ProcChainMask),
procCoefficient = procCoefficient,
teamIndex = base.characterBody.teamComponent.teamIndex,
hitBoxGroup = hitBoxGroup,
hitEffectPrefab = Modules.Assets.punchImpactEffect,
impactSound = Modules.Assets.drillRushHitSoundEvent.index,
};
base.characterMotor.useGravity = false;
if (NetworkServer.active)
{
base.characterBody.AddBuff(RoR2Content.Buffs.HiddenInvincibility);
}
if (base.isAuthority)
{
base.characterMotor.onMovementHit += this.OnMovementHit;
}
EffectManager.SpawnEffect(Assets.earthMoundEffect, new EffectData
{
origin = this.spawnLocation,
rotation = Util.QuaternionSafeLookRotation(this.spawnRotation) * Quaternion.Euler(new Vector3(90, 0, 0))
}, false);
}
public override void OnEnter()
{
base.OnEnter();
this.tracker = base.GetComponent <HenryTracker>();
this.target = this.tracker.GetTrackingTarget();
if (base.characterBody)
{
base.characterBody.bodyFlags |= CharacterBody.BodyFlags.IgnoreFallDamage;
}
if (base.isGrounded)
{
base.SmallHop(base.characterMotor, 10f);
}
if (this.target && this.target.healthComponent && this.target.healthComponent.alive)
{
this.targetIsValid = true;
}
HitBoxGroup hitBoxGroup = null;
Transform modelTransform = base.GetModelTransform();
if (modelTransform)
{
hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "Punch");
}
this.attack = new OverlapAttack();
this.attack.damageType = DamageType.Generic;
this.attack.attacker = base.gameObject;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = base.GetTeam();
this.attack.damage = DashPunch.damageCoefficient * this.damageStat;
this.attack.procCoefficient = DashPunch.procCoefficient;
this.attack.hitEffectPrefab = DashPunch.hitEffectPrefab;
this.attack.hitBoxGroup = hitBoxGroup;
this.attack.isCrit = base.RollCrit();
this.attack.impactSound = DashPunch.impactSound.index;
this.attack.pushAwayForce = DashPunch.pushForce * 0.2f;
Util.PlaySound("HenryStinger", base.gameObject);
base.PlayAnimation("FullBody, Override", "DashPunch");
if (base.isGrounded)
{
EffectManager.SimpleEffect(Modules.Assets.dustEffect, base.characterBody.footPosition, base.transform.rotation, false);
}
}
// Token: 0x06002E10 RID: 11792 RVA: 0x000C40A0 File Offset: 0x000C22A0
protected override void AuthorityModifyOverlapAttack(OverlapAttack overlapAttack)
{
base.AuthorityModifyOverlapAttack(overlapAttack);
overlapAttack.damage = this.damageCoefficient * this.damageStat + this.bonusDamage;
overlapAttack.forceVector = base.characterMotor.velocity + base.GetAimRay().direction *Mathf.Lerp(this.minPunchForce, this.maxPunchForce, this.charge);
if (base.fixedAge + Time.fixedDeltaTime >= this.duration)
{
HitBoxGroup hitBoxGroup = base.FindHitBoxGroup("PunchLollypop");
if (hitBoxGroup)
{
this.hitBoxGroup = hitBoxGroup;
overlapAttack.hitBoxGroup = hitBoxGroup;
}
}
}
public override void OnEnter()
{
Debug.LogWarning("In PrimarySkill");
base.OnEnter();
this.duration = this.baseDuration / this.attackSpeedStat;
this.fireDuration = 0.25f * this.duration;
base.characterBody.SetAimTimer(2f);
this.animator = base.GetModelAnimator();
this.muzzleString = "Muzzle";
HitBox hitbox = null;
var gameObject = GameObject.Find("spine upper weapon_end");
Transform transform = gameObject.transform;
//ChildLocator childLocator = ExampleSurvivor.ExampleSurvivor.childLocator;
//Transform transform = childLocator.FindChild("spine upper weapon_end");
//Transform transform = ExampleSurvivor.ExampleSurvivor.characterPrefab.transform.Find("Armature/Hips/Spine/Chest/arm right wrist weapon_end/spine upper weapon/spine upper weapon_end");
if (transform == null)
{
Debug.LogError("transform == null");
}
CapsuleCollider collider = transform.GetComponent <CapsuleCollider>();
if (collider == null)
{
Debug.LogError("collider == null");
}
try{
hitbox = transform.GetComponent <CapsuleCollider>().gameObject.AddComponent <HitBox>();
this.hitBox = hitbox;
if (hitbox == null)
{
Debug.LogError("hitbox == null");
}
}
catch
{ Debug.LogError("error while adding Hitbox"); }
overlapAttack = base.InitMeleeOverlap(1000, tracerEffectPrefab, base.GetModelTransform(), hitbox.name);
overlapAttack.damageType = DamageType.BleedOnHit;
base.PlayAnimation("Gesture, Override", "Slash", "FireArrow.playbackRate", this.duration);
}
// Token: 0x06000327 RID: 807 RVA: 0x0000D1A0 File Offset: 0x0000B3A0
public OverlapAttack InitMeleeOverlap(float damageCoefficient, GameObject hitEffectPrefab, Transform modelTransform, string hitboxGroupName)
{
OverlapAttack overlapAttack = new OverlapAttack();
overlapAttack.attacker = base.gameObject;
overlapAttack.inflictor = base.gameObject;
overlapAttack.teamIndex = TeamComponent.GetObjectTeam(overlapAttack.attacker);
overlapAttack.damage = damageCoefficient * this.damageStat;
overlapAttack.hitEffectPrefab = hitEffectPrefab;
overlapAttack.isCrit = this.RollCrit();
if (modelTransform)
{
overlapAttack.hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == hitboxGroupName);
}
return(overlapAttack);
}
public override void OnEnter()
{
base.OnEnter();
this.animator = base.GetModelAnimator();
this.duration = this.baseDuration / this.attackSpeedStat;
this.hasSwung = false;
this.overlapAttack = base.InitMeleeOverlap(this.baseDamageCoefficient, WhirlwindBase.hitEffectPrefab, base.GetModelTransform(), this.hitboxString);
if (base.characterDirection && base.inputBank)
{
base.characterDirection.forward = base.inputBank.aimDirection;
}
base.SmallHop(base.characterMotor, this.smallHopVelocity);
this.PlayAnim();
}
private bool OverlapAttack_Fire(On.RoR2.OverlapAttack.orig_Fire orig, OverlapAttack self, List <HealthComponent> hitResults)
{
if (self.attacker)
{
if (self.attacker.GetComponent <CharacterBody>() is CharacterBody characterBody && characterBody.inventory)
{
if (characterBody.inventory.GetItemCount(this.ItemIndex) is int count && count > 0)
{
for (int i = 0; i < count; i++)
{
orig(self, hitResults);
}
}
}
}
return(orig(self, hitResults));
}
public void ResetOverlap()
{
this.attack = new OverlapAttack();
this.attack.procChainMask = this.projectileController.procChainMask;
this.attack.procCoefficient = this.projectileController.procCoefficient * this.procCoefficient;
this.attack.attacker = this.projectileController.owner;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = this.projectileController.teamFilter.teamIndex;
this.attack.attackerFiltering = this.attackerFiltering;
this.attack.damage = this.damageCoefficient * this.projectileDamage.damage;
this.attack.forceVector = this.bonusForce + this.projectileDamage.force * base.transform.forward;
this.attack.hitEffectPrefab = this.impactEffect;
this.attack.isCrit = this.projectileDamage.crit;
this.attack.damageColorIndex = this.projectileDamage.damageColorIndex;
this.attack.damageType = this.useDamageTypeOverride ? this.damageTypeOverride : this.projectileDamage.damageType;
this.attack.hitBoxGroup = base.GetComponent <HitBoxGroup>();
}
private bool OverlapAttack_Fire(On.RoR2.OverlapAttack.orig_Fire orig, OverlapAttack self, List <HealthComponent> hitResults)
{
if (self.attacker)
{
if (self.attacker.GetComponent <CharacterBody>() is CharacterBody characterBody && characterBody.inventory)
{
if (characterBody.inventory.GetItemCount(this.ItemIndex) is int count && count > 0)
{
List <OverlapAttack> attacks;
if (childAttacks.TryGetValue(self, out attacks))
{
foreach (var attack in attacks)
{
orig(attack, hitResults);
}
}
else
{
attacks = new List <OverlapAttack>();
for (int i = 0; i < count; i++)
{
OverlapAttack overlapAttack = new OverlapAttack();
overlapAttack.attacker = self.attacker;
overlapAttack.attackerFiltering = self.attackerFiltering;
overlapAttack.damage = self.damage;
overlapAttack.damageColorIndex = self.damageColorIndex;
overlapAttack.damageType = self.damageType;
overlapAttack.forceVector = self.forceVector;
overlapAttack.hitBoxGroup = self.hitBoxGroup;
overlapAttack.hitEffectPrefab = self.hitEffectPrefab;
overlapAttack.inflictor = self.inflictor;
overlapAttack.isCrit = self.isCrit;
overlapAttack.procChainMask = self.procChainMask;
overlapAttack.procCoefficient = self.procCoefficient;
overlapAttack.teamIndex = self.teamIndex;
attacks.Add(overlapAttack);
orig(overlapAttack, hitResults);
}
childAttacks.Add(self, attacks);
}
}
}
}
return(orig(self, hitResults));
}
public override void OnEnter()
{
procCoefficient = FireVoidspikes.procCoefficient;
selfForce = FireVoidspikes.selfForce;
hitEffectPrefab = FireVoidspikes.hitEffectPrefab;
swipeEffectPrefab = FireVoidspikes.swipeEffectPrefab;
enterSoundString = FireVoidspikes.enterSoundString;
attackSoundString = FireVoidspikes.attackSoundString;
walkSpeedPenaltyCoefficient = FireVoidspikes.walkSpeedPenaltyCoefficient;
projectileCount = FireVoidspikes.projectileCount;
projectileYawSpread = FireVoidspikes.projectileYawSpread;
projectileDamageCoefficient = FireVoidspikes.projectileDamageCoefficient;
projectileSpeed = FireVoidspikes.projectileSpeed;
projectileSpeedPerProjectile = FireVoidspikes.projectileSpeedPerProjectile;
projectilePrefab = Prefabs.Projectiles.ImpOverlord.IchorSpikePrefab.prefab;
base.OnEnter();
duration = baseDuration / attackSpeedStat;
modelAnimator = GetModelAnimator();
modelTransform = GetModelTransform();
base.characterMotor.walkSpeedPenaltyCoefficient = walkSpeedPenaltyCoefficient;
attack = new OverlapAttack();
attack.attacker = base.gameObject;
attack.inflictor = base.gameObject;
attack.teamIndex = GetTeam();
attack.damage = damageCoefficient * damageStat;
attack.hitEffectPrefab = hitEffectPrefab;
attack.isCrit = Util.CheckRoll(critStat, base.characterBody.master);
attack.procCoefficient = procCoefficient;
attack.damageType = DamageType.Generic;
Util.PlaySound(enterSoundString, base.gameObject);
if (base.isAuthority)
{
chosenAnim = ((!Util.CheckRoll(50f)) ? 1 : 0);
}
if ((bool)modelAnimator)
{
string animationStateName = ((chosenAnim == 1) ? "FireVoidspikesL" : "FireVoidspikesR");
PlayAnimation("Gesture, Additive", animationStateName, "FireVoidspikes.playbackRate", duration);
PlayAnimation("Gesture, Override", animationStateName, "FireVoidspikes.playbackRate", duration);
}
if ((bool)base.characterBody)
{
base.characterBody.SetAimTimer(duration + 3f);
}
}
private void Start()
{
this.attack = new OverlapAttack();
this.attack.procChainMask = this.projectileController.procChainMask;
this.attack.procCoefficient = this.projectileController.procCoefficient * this.overlapProcCoefficient;
this.attack.attacker = this.projectileController.owner;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = this.projectileController.teamFilter.teamIndex;
this.attack.damage = this.overlapCoefficient * this.projectileDamage.damage;
this.attack.forceVector = this.projectileDamage.force * base.transform.forward;
this.attack.hitEffectPrefab = this.impactEffect;
this.attack.isCrit = this.projectileDamage.crit;
this.attack.damageColorIndex = this.projectileDamage.damageColorIndex;
this.attack.damageType = this.projectileDamage.damageType;
this.attack.procChainMask = this.projectileController.procChainMask;
this.attack.maximumOverlapTargets = this.overlapMaxTargets;
this.attack.hitBoxGroup = base.GetComponent <HitBoxGroup>();
}
protected override OverlapAttack CreateAttack(HitBoxGroup hitBoxGroup)
{
var attack = new OverlapAttack();
attack.damageType = DamageType.BypassArmor;
attack.attacker = base.gameObject;
attack.inflictor = base.gameObject;
attack.teamIndex = base.GetTeam();
attack.damage = c_DamageCoefficient * baseDamageCoeficient * this.damageStat;
attack.procCoefficient = procCoefficient;
attack.hitEffectPrefab = this.hitEffectPrefab;
attack.forceVector = Vector3.zero;
attack.pushAwayForce = 0f;
attack.hitBoxGroup = hitBoxGroup;
attack.isCrit = base.RollCrit();
attack.impactSound = this.impactSound;
return(attack);
}
// Token: 0x06004013 RID: 16403 RVA: 0x0010C7BC File Offset: 0x0010A9BC
private void ResetOverlapAttack()
{
if (!this.hitboxGroup)
{
Transform modelTransform = base.GetModelTransform();
if (modelTransform)
{
this.hitboxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "HeadCh");
}
}
this.attack = new OverlapAttack();
this.attack.attacker = base.gameObject;
this.attack.inflictor = base.gameObject;
this.attack.teamIndex = TeamComponent.GetObjectTeam(this.attack.attacker);
this.attack.damage = ChargeAgu.damageCoefficient * this.damageStat;
this.attack.forceVector = Vector3.up * 1f;
this.attack.pushAwayForce = 1f;
this.attack.hitBoxGroup = this.hitboxGroup;
}
private bool OverlapAttack_Fire(On.RoR2.OverlapAttack.orig_Fire orig, OverlapAttack self, List <HurtBox> hitResults)
{
bool didAHit = orig(self, hitResults);
HitboxGroupRevealer hitboxGroupRevealer = _hitboxGroupRevealers.Find((revealer) => {
return(revealer != null && revealer.hitboxGroup == self.hitBoxGroup);
});
if (hitboxGroupRevealer == null)
{
hitboxGroupRevealer = self.hitBoxGroup.gameObject.AddComponent <HitboxGroupRevealer>();
_hitboxGroupRevealers.Add(hitboxGroupRevealer);
hitboxGroupRevealer.init(self.hitBoxGroup, _hitboxBoxPrefab, self.attacker);
}
hitboxGroupRevealer.reveal(true);
return(didAHit);
}
