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();
     }
 }
Beispiel #5
0
		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;
     }
 }
Beispiel #8
0
 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);
 }
Beispiel #9
0
 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]);
 }
Beispiel #11
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;
 }
Beispiel #14
0
 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;
     }
 }
Beispiel #18
0
 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);
     }
 }
Beispiel #19
0
 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);
     }
 }
Beispiel #20
0
 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;
     }
 }
Beispiel #23
0
 public override void OnAttackHit(AttackCollisionData xAtColData, BaseStats xBaseStats)
 {
 }
Beispiel #24
0
 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;
 }
Beispiel #27
0
 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;
 }
Beispiel #30
0
 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]);
     }
 }