public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats != null)
{
this.bDidHitMonster = true;
}
PlayerEntity xPlayer;
if ((xPlayer = (xBaseStats.xOwner as PlayerEntity)) != null)
{
if (!Utility.IsWithinRange((int)xPlayer.xRenderComponent.iActiveAnimation, 2600, 2603))
{
FrozenPlayer xMos = (FrozenPlayer)Program.game._EntityMaster_AddDynamicEnvironment(DynamicEnvironmentCodex.ObjectTypes.Debuff_Freeze, xPlayer.xTransform.v2Pos);
xMos.SetPlayer(xPlayer);
}
float fDuration = 300f;
float fSlowFactor = 0.7f;
xBaseStats.AddStatusEffect(BaseStats.StatusEffectSource.Chilled, (int)fDuration);
xBaseStats.AddStatusEffect(BaseStats.StatusEffectSource.SlowLv1, (int)fDuration);
if (!xBaseStats.bSlowImmunity)
{
xBaseStats.AddPercentageMoveSpeedDeBuff(new BaseStats.BuffFloat((int)fDuration, fSlowFactor));
}
}
this.bToBeDestroyed = true;
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats != null)
{
this.bDidHitMonster = true;
}
if (xAtColData.bShielded && xBaseStats.bPerfectGuardedThisFrame)
{
Vector2 v2Normal = Utility.AnimationDirectionToVector2((int)(xBaseStats.xOwner as PlayerEntity).byAnimationDirection);
(this.v2Direction - 2f * (Vector2.Dot(this.v2Direction, v2Normal) * v2Normal)).Normalize();
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Players);
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Neutrals);
this.xAttackPhasePlayer.lenLayers.Add(Collider.ColliderLayers.Enemies);
this.v2Direction *= -1f;
this.xAttackPhasePlayer.xStats.v2KnockbackDirectionOverride = this.v2Direction;
this.xAttackPhasePlayer.xStats.iBaseDamage *= 5;
this.xOwner = xBaseStats.xOwner;
if (xBaseStats.xOwner.enEntityType == IEntity.EntityType.Player && (xBaseStats.xOwner as PlayerEntity).Owner.xEquipment.lenActiveEquipmentEffects.Contains(EquipmentInfo.SpecialEffect._Unique_WispShield_BetterProjectileReflect))
{
this.xAttackPhasePlayer.xStats.iBaseDamage = (int)((float)this.xAttackPhasePlayer.xStats.iBaseDamage * 1.5f);
return;
}
}
else
{
this.bToBeDestroyed = true;
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats == null)
{
this.bToBeDestroyed = true;
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats != null)
{
this.bDidHitMonster = true;
}
if (xAtColData.bShielded && xBaseStats.iPerfectGuardBonus > 0)
{
Vector2 v2Normal = Utility.AnimationDirectionToVector2((int)(xBaseStats.xOwner as PlayerEntity).byAnimationDirection);
(this.v2Direction - 2f * (Vector2.Dot(this.v2Direction, v2Normal) * v2Normal)).Normalize();
this.xAttackPhasePlayer.xStats.sAttackHandle = "PGTest";
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Players);
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Neutrals);
this.xAttackPhasePlayer.lenLayers.Add(Collider.ColliderLayers.DynamicEnvironment);
this.xAttackPhasePlayer.xStats.iBaseDamage *= 3;
this.v2Direction *= -1f;
this.xOwner = xBaseStats.xOwner;
this.xRenderComponent.fScale = 0.2f;
this.xRenderComponent.cColor = Color.Aqua;
this.xRenderComponent.fAlpha = 0.5f;
this.xChallengePG.ShotGuarded();
return;
}
this.bToBeDestroyed = true;
if (this.xAttackPhasePlayer.xStats.sAttackHandle != "PGTest")
{
this.xChallengePG.Fail();
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
foreach (DeligateEntity.OnAttackHitDelegate x in this.lxOnAttackHitDelegates)
{
x(xAtColData, xBaseStats);
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (this.xOwnerEnemy != null)
{
return;
}
if (xBaseStats != null)
{
this.bDidHitMonster = true;
}
if (xBaseStats == null || !(xBaseStats.xOwner is PlayerEntity))
{
this.v2Direction *= -1f;
this.fCurrentRot += 3.14159274f;
return;
}
if (this.iCooldown > 0)
{
return;
}
this.iCooldown = 60;
PlayerEntity xCaughtPlayer = xBaseStats.xOwner as PlayerEntity;
TornadoedPlayer xLol = (TornadoedPlayer)Program.game._EntityMaster_AddDynamicEnvironment(DynamicEnvironmentCodex.ObjectTypes.Debuff_TornadoCatch, Vector2.Zero);
xLol.SetPlayer(xCaughtPlayer, this);
this.xAttackPhaseEnvironment.lxCurrentColliders[0].ibitLayers |= xCaughtPlayer.xCollisionComponent.ibitCurrentColliderLayer;
this.xCurrentCaught = xCaughtPlayer;
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats != null)
{
this.bDidHitMonster = true;
}
if (this.bReflectableOnPerfectGuard && xAtColData.bShielded && xBaseStats.iPerfectGuardBonus > 0)
{
Vector2 v2NewDir = this.v2Direction * -1f;
v2NewDir.Normalize();
base.SendClientInstruction(0, new float[]
{
v2NewDir.X,
v2NewDir.Y
});
this.xAttackPhaseEnemy.lenLayers.Remove(Collider.ColliderLayers.Players);
this.xAttackPhaseEnemy.lenLayers.Remove(Collider.ColliderLayers.Neutrals);
this.xAttackPhaseEnemy.lenLayers.Add(Collider.ColliderLayers.Enemies);
this.xAttackPhaseEnemy.lenLayers.Add(Collider.ColliderLayers.DynamicEnvironment);
this.xAttackPhaseEnemy.xStats.iBaseDamage *= 5;
if (xBaseStats.xOwner.enEntityType == IEntity.EntityType.Player && (xBaseStats.xOwner as PlayerEntity).Owner.xEquipment.lenActiveEquipmentEffects.Contains(EquipmentInfo.SpecialEffect._Unique_WispShield_BetterProjectileReflect))
{
this.xAttackPhaseEnemy.xStats.iBaseDamage = (int)((float)this.xAttackPhaseEnemy.xStats.iBaseDamage * 1.5f);
}
this.v2Direction = v2NewDir;
this.xOwner = xBaseStats.xOwner;
}
}
public DynamicEnvironment()
{
this.xRenderComponent = new AnimatedRenderComponent(this);
this.xTransform = new TransformComponent(Vector2.Zero);
this.xRenderComponent.xTransform = this.xTransform;
this.enEntityType = IEntity.EntityType.DynamicEnvironment;
this.xBaseStats = new BaseStats(this);
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
base.OnAttackHit(xAtColData, xBaseStats);
if (xAtColData.bShielded)
{
this.xOwner.xRenderComponent.SwitchAnimation((ushort)(this.xOwner.xRenderComponent.GetCurrentAnimation().byAnimationDirection + 22), Animation.CancelOptions.UseAnimationDefault);
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats != null)
{
this.bDidHitMonster = true;
}
this.bToBeDestroyed = true;
base.SendClientInstruction(0, new float[0]);
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (!xAtColData.bShielded && Program.GetTheGame().bEffectsOn)
{
IEffect kaktus = Program.GetTheGame()._EffectMaster_AddEffect(new SortedAnimated(xAtColData.v2PointOfImpact, SortedAnimated.SortedAnimatedEffects._HitEffect_Pang1));
kaktus.xRenderComponent.fVirtualHeight += this.xOwner.xRenderComponent.fVirtualHeight;
kaktus.xRenderComponent.xTransform = xBaseStats.xOwner.xTransform;
kaktus.xRenderComponent.v2OffsetRenderPos = new Vector2(0f, -10f);
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (this.iPowerLevel == 5)
{
return;
}
this.bToBeDestroyed = true;
SortedAnimated xDestroy = new SortedAnimated(this.xTransform.v2Pos + this.xRenderComponent.v2OffsetRenderPos, SortedAnimated.SortedAnimatedEffects._SpellEffects_Fire_FireballImpact);
xDestroy.xRenderComponent.fVirtualHeight = this.xRenderComponent.fVirtualHeight + 10f;
Program.GetTheGame()._EffectMaster_AddEffect(xDestroy);
base.SendClientInstruction(0, new float[0]);
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats != null)
{
this.bDidHitMonster = true;
}
if (this.bReflectableOnPerfectGuard && xAtColData.bShielded && xBaseStats.iPerfectGuardBonus > 0)
{
Vector2 v2Normal = Utility.AnimationDirectionToVector2((int)(xBaseStats.xOwner as PlayerEntity).byAnimationDirection);
(this.v2Direction - 2f * (Vector2.Dot(this.v2Direction, v2Normal) * v2Normal)).Normalize();
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Players);
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Neutrals);
this.xAttackPhasePlayer.lenLayers.Add(Collider.ColliderLayers.DynamicEnvironment);
this.xAttackPhasePlayer.xStats.iBaseDamage *= 3;
this.v2Direction *= -1f;
this.xOwner = xBaseStats.xOwner;
return;
}
this.bToBeDestroyed = true;
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xAtColData.bShielded)
{
ushort kaktus = 0;
if (this.xOwner.xRenderComponent.GetCurrentAnimation().byAnimationDirection == 3)
{
kaktus = 1;
}
this.xOwner.xRenderComponent.SwitchAnimation(Convert.ToUInt16(kaktus + 8), Animation.CancelOptions.UseAnimationDefault);
this.iShieldKnockLol = 10;
this.iDowned = 180 - 30 * GameSessionData.iBaseDifficulty;
if (xBaseStats.bPerfectStance)
{
this.iDowned *= 3;
}
this.xOwner.bAutoSwitchToHitAnimation = false;
base.SendClientInstruction(0, new float[0]);
Program.GetTheGame().xGameSessionData.henActiveFlags.Add(FlagCodex.FlagID._BagTips_BlockedBee);
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
float fEpiLol = this.fEpicenter;
if (this.iChargeLevel == 3)
{
fEpiLol = 12f;
}
if (this.iChargeLevel > 1 && xBaseStats != null && xBaseStats.bCanBeKnockedUp && xBaseStats.xOwner.enEntityType == IEntity.EntityType.Enemy)
{
Enemy xEn = xBaseStats.xOwner as Enemy;
if (Vector2.Distance(xAtColData.v2PointOfImpact, this.xTransform.v2Pos) < fEpiLol && xBaseStats.iHP > 0)
{
Game1 master = Program.GetTheGame();
float fKnockupSpeed = 3f;
float fSpeedFalloff = 0.15f;
if (this.iChargeLevel == 3)
{
fKnockupSpeed = 4f;
}
master._EntityMaster_AddWatcher(new EnemyKnockupWatcher(xEn, fKnockupSpeed, fSpeedFalloff));
xEn.xRenderComponent.SwitchAnimation((ushort)((int)xEn.byAnimationDirection + 40000), Animation.CancelOptions.IgnoreIfPlaying);
if (master.xNetworkInfo.enCurrentRole == NetworkHelperInterface.NetworkRole.Server)
{
foreach (PlayerView xOtherView in master.dixPlayers.Values)
{
if (xOtherView != master.xLocalPlayer && xOtherView.bInitializedToServer)
{
NetOutgoingMessage om = master.xNetworkInfo.server.CreateMessage();
om.Write(255);
om.Write(7);
om.Write(xEn.iID);
om.Write(fKnockupSpeed);
om.Write(fSpeedFalloff);
master.xNetworkInfo.server.SendMessage(om, xOtherView.netConnection, NetDeliveryMethod.ReliableUnordered);
}
}
}
}
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (CAS.NetworkRole == NetworkHelperInterface.NetworkRole.Client)
{
return;
}
if (this.bToBeDestroyed)
{
return;
}
if (xBaseStats == null || xBaseStats.xOwner == null)
{
this.bToBeDestroyed = true;
if (this.xTravelingEntity is Enemy)
{
Enemy x = this.xTravelingEntity as Enemy;
Program.game._Enemy_TakeArbitraryDamage(x, Program.game._AttackStats_CalculateDefenseReduction(this.iDamageAtCollide, x.xBaseStats, 0f, false), 0, this.xAttackPhaseEnemy);
if (Program.game.xCamera.recViewRec.Contains(Utility.Vector2ToPoint(this.xTravelingEntity.xTransform.v2Pos)))
{
Program.game.xCamera.SetShake((int)(5 + (int)x.xBaseStats.enSize * (int)(BaseStats.BodySize)15));
return;
}
}
}
else if (xBaseStats.xOwner is Enemy)
{
if (xBaseStats.enSize > this.xTravelingEntity.xBaseStats.enSize)
{
this.v2TravelDir = Utility.DirectionBetweenVectors(xBaseStats.xOwner.xTransform.v2Pos, this.xTravelingEntity.xTransform.v2Pos);
base.SendClientInstruction(0, new float[]
{
this.xTravelingEntity.xTransform.v2Pos.X,
this.xTravelingEntity.xTransform.v2Pos.Y,
this.v2TravelDir.X,
this.v2TravelDir.Y
});
}
Program.game._EffectMaster_AddEffect(new SortedAnimated(xBaseStats.xOwner.xTransform.v2Pos, SortedAnimated.SortedAnimatedEffects._HitEffect_SmashOnHitWall01));
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats != null)
{
this.bDidHitMonster = true;
}
if (this.iPhase == 0 && xAtColData.bShielded && xBaseStats.iPerfectGuardBonus > 0)
{
Utility.AnimationDirectionToVector2((int)(xBaseStats.xOwner as PlayerEntity).byAnimationDirection);
this.iDestroyAt = 120;
this.xAttackPhasePlayer.xStats.sAttackHandle = "SupahPhase";
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Players);
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Neutrals);
this.xAttackPhasePlayer.lenLayers.Add(Collider.ColliderLayers.Enemies);
this.xAttackPhasePlayer.xStats.iBaseDamage *= 3;
this.fVelocity = 4f;
this.v2Direction *= -1f;
this.xOwner = xBaseStats.xOwner;
base.SendClientInstruction(1, new float[]
{
this.v2Direction.X,
this.v2Direction.Y
});
if (xBaseStats.xOwner.enEntityType == IEntity.EntityType.Player && (xBaseStats.xOwner as PlayerEntity).Owner.xEquipment.lenActiveEquipmentEffects.Contains(EquipmentInfo.SpecialEffect._Unique_WispShield_BetterProjectileReflect))
{
this.xAttackPhasePlayer.xStats.iBaseDamage = (int)((float)this.xAttackPhasePlayer.xStats.iBaseDamage * 1.5f);
return;
}
}
else
{
IEntity xOwn = this.xOwner.GetTrueOwner();
if (xOwn.enEntityType == IEntity.EntityType.Enemy && (xOwn as Enemy).xBehaviour is RoguePhasemanAI)
{
((xOwn as Enemy).xBehaviour as RoguePhasemanAI).BulletShieldedNotPG();
}
this.bToBeDestroyed = true;
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (!xAtColData.bShielded)
{
if (Program.GetTheGame().bEffectsOn)
{
IEffect kaktus = Program.GetTheGame()._EffectMaster_AddEffect(new SortedAnimated(xAtColData.v2PointOfImpact, SortedAnimated.SortedAnimatedEffects._HitEffect_Pang1));
kaktus.xRenderComponent.fVirtualHeight += this.xOwner.xRenderComponent.fVirtualHeight;
kaktus.xRenderComponent.xTransform = xBaseStats.xOwner.xTransform;
kaktus.xRenderComponent.v2OffsetRenderPos = new Vector2(0f, -10f);
return;
}
}
else if (xBaseStats.iPerfectGuardBonus > 0)
{
this.iSubMeri = 2;
this.iMeriGoRound = 3;
this.v2RandMoveDir = Vector2.Zero;
this.iNextHardUpdate = 28;
this.xOwner.xAttackPhase.CancelPhase();
this.xOwner.xRenderComponent.SwitchAnimation((ushort)(8 + this.xOwner.byAnimationDirection), Animation.CancelOptions.RestartIfPlaying);
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (!xAtColData.bShielded)
{
if (Program.GetTheGame().bEffectsOn)
{
IEffect kaktus = Program.GetTheGame()._EffectMaster_AddEffect(new SortedAnimated(xAtColData.v2PointOfImpact, SortedAnimated.SortedAnimatedEffects._HitEffect_Pang1));
kaktus.xRenderComponent.fVirtualHeight += this.xOwner.xRenderComponent.fVirtualHeight;
kaktus.xRenderComponent.xTransform = xBaseStats.xOwner.xTransform;
kaktus.xRenderComponent.v2OffsetRenderPos = new Vector2(0f, -10f);
return;
}
}
else
{
this.xOwner.xRenderComponent.SwitchAnimation((ushort)(this.xOwner.byAnimationDirection + 12), Animation.CancelOptions.IgnoreIfPlaying);
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats.bPerfectStance)
{
this.iNextHardUpdate += 30;
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
xBaseStats.AddPercentageMoveSpeedDeBuff(new BaseStats.BuffFloat(4, 0.4f));
Vector2 v2EfPos = xAtColData.v2PointOfImpact + Utility.RandomizeVector2Direction(CAS.RandomInVisual);
SortedAnimated asd = (SortedAnimated)Program.game._EffectMaster_AddEffect(new SortedAnimated(v2EfPos, SortedAnimated.SortedAnimatedEffects._HitEffect_BatChew));
Program.game._EffectMaster_SendSortedAnimatedEffectToClient(asd);
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (xBaseStats != null)
{
this.bDidHitMonster = true;
}
if (xAtColData.bShielded && xBaseStats.iPerfectGuardBonus > 0)
{
Vector2 v2Normal = Utility.AnimationDirectionToVector2((int)(xBaseStats.xOwner as PlayerEntity).byAnimationDirection);
(this.v2Direction - 2f * (Vector2.Dot(this.v2Direction, v2Normal) * v2Normal)).Normalize();
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Players);
this.xAttackPhasePlayer.lenLayers.Remove(Collider.ColliderLayers.Neutrals);
this.xAttackPhasePlayer.lenLayers.Add(Collider.ColliderLayers.Enemies);
if (GameSessionData.iBaseDifficulty == 0)
{
this.xAttackPhasePlayer.xStats.iBaseDamage *= 5;
}
else
{
this.xAttackPhasePlayer.xStats.iBaseDamage *= 5;
}
if (xBaseStats.xOwner.enEntityType == IEntity.EntityType.Player && (xBaseStats.xOwner as PlayerEntity).Owner.xEquipment.lenActiveEquipmentEffects.Contains(EquipmentInfo.SpecialEffect._Unique_WispShield_BetterProjectileReflect))
{
this.xAttackPhasePlayer.xStats.iBaseDamage = (int)((float)this.xAttackPhasePlayer.xStats.iBaseDamage * 1.5f);
}
this.v2Direction *= -1f;
Enemy xOldOwner = this.xOwner as Enemy;
this.xOwner = xBaseStats.xOwner;
this.iDestroyAt += 120;
if (this.fVelocity < 2f)
{
this.fVelocity = 2f;
}
if (!xOldOwner.bToBeDestroyed)
{
this.xTargetActor = xOldOwner;
return;
}
List<Enemy> lxEnemies = Program.GetTheGame()._Enemies_GetEnemiesByDistanceToHitbox(this.xTransform.v2Pos, 300f, false);
lxEnemies.ShuffleList<Enemy>();
bool bTargetFound = false;
this.bReflected = true;
using (List<Enemy>.Enumerator enumerator = lxEnemies.GetEnumerator())
{
if (enumerator.MoveNext())
{
Enemy x = enumerator.Current;
this.xTargetActor = x;
bTargetFound = true;
}
}
if (!bTargetFound)
{
this.bToBeDestroyed = true;
return;
}
}
else
{
this.bToBeDestroyed = true;
}
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
base.OnAttackHit(xAtColData, xBaseStats);
if (this.iMeriGoRoundLogic == 4)
{
this.iHitWithSpin = 120;
base.SendClientInstruction(2, new float[0]);
}
}
public GlowEndAndBaseStatWrapper(GlowParameters xGlow, BaseStats xStats, BaseStats.StatusEffectSource enTypeToWatch)
{
this.xGlow = xGlow;
this.xStats = xStats;
this.enTypeToWatch = enTypeToWatch;
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (this.v2KnockBackDir == Vector2.Zero && Utility.IsWithinRange((int)this.xOwner.xRenderComponent.iActiveAnimation, 12, 15))
{
Vector2 v2Dirmos = Utility.Normalize(xAtColData.v2PointOfImpact - this.xOwner.xTransform.v2Pos);
v2Dirmos *= -1f;
this.v2KnockBackDir = v2Dirmos * 3f;
base.SendClientInstruction(0, new float[]
{
this.v2KnockBackDir.X,
this.v2KnockBackDir.Y
});
this.xOwner.xRenderComponent.GetCurrentAnimation().bDisableAnimationMovement = true;
this.xOwner.xAttackPhase.UnregisterCurrent();
}
bool arg_C8_0 = xAtColData.bShielded;
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
this.xBehaviour.OnAttackHit(xAtColData, xBaseStats);
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (this.bToBeDestroyed)
{
return;
}
if (xBaseStats != null && xBaseStats.xOwner.enEntityType == IEntity.EntityType.Player)
{
this.bDidHitMonster = true;
PlayerEntity xHit = xBaseStats.xOwner as PlayerEntity;
this.xAttackPhasePlayer.UnregisterCurrent();
this.xAttackPhaseEnvironment.UnregisterCurrent();
this.fVelocity = 0f;
this.iInRootCounter = 1;
this.xRootedPlayer = (RootedPlayer)Program.game._EntityMaster_AddDynamicEnvironment(DynamicEnvironmentCodex.ObjectTypes.Debuff_Root_Teal, xHit.xTransform.v2Pos);
this.xRootedPlayer.SetPlayer(xHit);
Program.GetTheGame();
base.SendClientInstruction(2, new float[0]);
return;
}
this.bToBeDestroyed = true;
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
int arg_08_0 = this.iChargeLevel;
}
public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
{
if (!xAtColData.bShielded)
{
if (Program.GetTheGame().bEffectsOn)
{
IEffect kaktus = Program.GetTheGame()._EffectMaster_AddEffect(new SortedAnimated(xAtColData.v2PointOfImpact, SortedAnimated.SortedAnimatedEffects._HitEffect_Pang1));
kaktus.xRenderComponent.fVirtualHeight += this.xOwner.xRenderComponent.fVirtualHeight;
kaktus.xRenderComponent.xTransform = xBaseStats.xOwner.xTransform;
kaktus.xRenderComponent.v2OffsetRenderPos = new Vector2(0f, -10f);
return;
}
}
else if (xBaseStats.bPerfectStance && this.enCurrentAction == GundamHandAI.GundamHandAction.InHit)
{
this.EndPunch();
this.enCurrentAction = GundamHandAI.GundamHandAction.PerfectGuarded;
base.SendClientInstruction(3, new float[0]);
}
}