protected override void SequenceMissBranch()
        {
            switch (SequenceStep)
            {
            case 0:
                User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);

                //When Watt misses Electro Dash, she goes in a downwards arc to around where the next enemy slot would be
                Vector2 destPos = BattleManager.Instance.GetPositionInFront(EntitiesAffected[0], EntitiesAffected[0].EntityType == Enumerations.EntityTypes.Player);
                Vector2 curDest = User.Position + new Vector2(UtilityGlobals.DifferenceDivided(destPos.X, User.Position.X, 2f), MissHeight);

                CurSequenceAction = new MoveToSeqAction(curDest, MissMoveDur, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadOut);
                break;

            case 1:
                destPos = BattleManager.Instance.GetPositionInFront(EntitiesAffected[0], EntitiesAffected[0].EntityType == Enumerations.EntityTypes.Player);
                curDest = User.Position + new Vector2(UtilityGlobals.DifferenceDivided(destPos.X, User.Position.X, 2f), -MissHeight);

                CurSequenceAction = new MoveToSeqAction(curDest, MissMoveDur, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadIn);
                break;

            case 2:
                User.AnimManager.PlayAnimation(AnimationGlobals.IdleName);

                CurSequenceAction = new WaitSeqAction(MissWaitDur);
                ChangeSequenceBranch(SequenceBranch.End);
                break;

            default:
                PrintInvalidSequence();
                break;
            }
        }
Example #2
0
        protected override void SequenceStartBranch()
        {
            switch (SequenceStep)
            {
            case 0:
                Vector2 frontPos = BattleManagerUtils.GetPositionInFront(User.BManager.GetFrontmostBattleEntity(CurTarget.EntityType, null), User.EntityType != EntityTypes.Enemy);
                frontPos.Y = User.Position.Y;

                User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
                CurSequenceAction = new MoveToSeqAction(User, frontPos, WalkDuration);

                break;

            case 1:

                User.AnimManager.PlayAnimation(AnimationGlobals.JumpStartName);
                CurSequenceAction = new WaitForAnimationSeqAction(User, AnimationGlobals.JumpStartName);
                ChangeSequenceBranch(SequenceBranch.Main);

                //Store the jump distance
                XDiffOverTwo = UtilityGlobals.DifferenceDivided(CurTarget.Position.X, User.Position.X, 2f);
                break;

            default:
                PrintInvalidSequence();
                break;
            }
        }
Example #3
0
        /// <summary>
        /// The interruption that occurs when jumping on a Spiked entity
        /// </summary>
        protected void SpikedEntityInterruption()
        {
            switch (SequenceStep)
            {
            case 0:
                User.AnimManager.PlayAnimation(AnimationGlobals.SpikedTipHurtName, true);

                Vector2 offset = new Vector2(-50, -JumpHeight);
                if (User.EntityType != EntityTypes.Player)
                {
                    offset.X = -offset.X;
                }

                Vector2 pos = BattleManager.Instance.GetPositionInFront(CurTarget, User.EntityType != EntityTypes.Player) + offset;
                CurSequenceAction = new MoveToSeqAction(pos, WalkDuration / 4d);
                break;

            case 1:
                CurSequenceAction = new WaitForAnimationSeqAction(AnimationGlobals.SpikedTipHurtName);
                break;

            case 2:
                CurSequenceAction = new MoveAmountSeqAction(new Vector2(0f, User.BattlePosition.Y - User.Position.Y), JumpDuration / 2f, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadIn);
                break;

            case 3:
                //Do the same bounce as the end sequence, except keep playing the same animation
                Vector2 endPos  = BattleManager.Instance.GetPositionInFront(CurTarget, User.EntityType == EntityTypes.Player);
                Vector2 moveAmt = new Vector2(UtilityGlobals.DifferenceDivided(endPos.X, User.Position.X, 2f), -(JumpHeight / 2f));

                CurSequenceAction = new MoveAmountSeqAction(moveAmt, JumpDuration / 2f, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadOut);
                break;

            case 4:
                endPos = BattleManager.Instance.GetPositionInFront(CurTarget, User.EntityType == EntityTypes.Player);

                moveAmt = new Vector2(UtilityGlobals.DifferenceDivided(endPos.X, User.Position.X, 2f), (JumpHeight / 2f));

                CurSequenceAction = new MoveAmountSeqAction(moveAmt, JumpDuration / 2f, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadIn);

                ChangeSequenceBranch(SequenceBranch.End);

                SequenceStep = 1;
                break;

            default:
                PrintInvalidSequence();
                break;
            }
        }
Example #4
0
        protected override void SequenceSuccessBranch()
        {
            switch (SequenceStep)
            {
            case 0:
                base.SequenceSuccessBranch();
                break;

            case 1:
                InteractionResult[] interactions = AttemptDamage(DamageDealt, CurTarget, Action.DamageProperties, false);

                //Show VFX for the highest command rank
                if (interactions[0] != null && interactions[0].WasVictimHit == true && interactions[0].WasAttackerHit == false)
                {
                    ShowCommandRankVFX(HighestCommandRank, CurTarget.Position);

                    //Set Stylish data
                    SetStylishData(200d, 600d, 0);

                    //Restart with the next target
                    if (NextTargetIndex < EntitiesAffected.Length)
                    {
                        CurrentTargetIndex = NextTargetIndex;
                        ChangeSequenceBranch(SequenceBranch.Main);

                        XDiffOverTwo = UtilityGlobals.DifferenceDivided(CurTarget.Position.X, User.Position.X, 2f);
                    }
                    //Otherwise end it since we're on the last target
                    else
                    {
                        ChangeSequenceBranch(SequenceBranch.End);
                    }
                }
                break;

            default:
                PrintInvalidSequence();
                break;
            }
        }
Example #5
0
        protected override void SequenceEndBranch()
        {
            switch (SequenceStep)
            {
            case 0:
                //Do a little bounce at the end
                Vector2 endPos  = BattleManagerUtils.GetPositionInFront(CurTarget, User.EntityType == EntityTypes.Player);
                Vector2 moveAmt = new Vector2(UtilityGlobals.DifferenceDivided(endPos.X, User.Position.X, 2f), -(JumpHeight / 2f));

                User.AnimManager.PlayAnimation(AnimationGlobals.JumpRisingName);
                CurSequenceAction = new MoveAmountSeqAction(User, moveAmt, JumpDuration / 2f, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadOut);
                break;

            case 1:
                float moveDiffY = User.Position.Y - User.BattlePosition.Y;

                endPos = BattleManagerUtils.GetPositionInFront(CurTarget, User.EntityType == EntityTypes.Player);

                moveAmt = new Vector2(UtilityGlobals.DifferenceDivided(endPos.X, User.Position.X, 2f), /*(JumpHeight / 2f)*/ -moveDiffY);

                User.AnimManager.PlayAnimation(AnimationGlobals.JumpFallingName);
                CurSequenceAction = new MoveAmountSeqAction(User, moveAmt, JumpDuration / 2f, Interpolation.InterpolationTypes.Linear, Interpolation.InterpolationTypes.QuadIn);
                break;

            case 2:
                User.AnimManager.PlayAnimation(AnimationGlobals.RunningName);
                CurSequenceAction = new MoveToSeqAction(User, User.BattlePosition, WalkDuration);
                break;

            case 3:
                User.AnimManager.PlayAnimation(User.GetIdleAnim());
                EndSequence();
                break;

            default:
                PrintInvalidSequence();
                break;
            }
        }