예제 #1
0
        //Richtige Animation und richtigen FlipState anwenden
        public static void AnimateAccordingToDirection(SpineObject pSpine, Vector2 pDirection, string pAnimUp, string pAnimDown, string pAnimSide)
        {
            string anim = Character.GetRightDirectionAnimation(pDirection, pAnimUp, pAnimDown, pAnimSide);

            Character.SetSkeletonFlipState(pSpine, pDirection);
            Sequences.StartAnimation(pSpine, anim);
        }
예제 #2
0
        public override void Update(Player pPlayer, Player pOtherPlayer)
        {
            switch (pPlayer.mCurrentState)
            {
            case 0:
                //-----Animation starten-----
                Sequences.StartAnimation(pPlayer, Hardcoded.Anim_Amulet_Use);
                ++pPlayer.mCurrentState;
                break;

            case 1:
                //-----Amulett hoch halten-----
                Sequences.UpdateActIProgress(Progress, ActI, pPlayer, new Vector2(0, -1));
                Sequences.UpdateAnimationStepping(pPlayer, Progress.Progress);
                //Abbrechbar
                if (Progress.Progress <= 0f && !Conditions.ActionHold(pPlayer) && !Conditions.ActionHold(pOtherPlayer))
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                }
                if (Progress.Complete)
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                    ActI.SetFadingState(pPlayer, false);
                    //Delete Witch
                    m2ndState = true;
                }
                break;
            }
            ActI.Update();
        }
예제 #3
0
        public override void Update(Player pPlayer, Player pOtherPlayer)
        {
            switch (pPlayer.mCurrentState)
            {
            case 0:
                //-----Zu Position bewegen-----
                if (Conditions.PlayerAtNearestActionPosition(pPlayer))
                {
                    ++pPlayer.mCurrentState;
                }
                Sequences.MovePlayerToNearestActionPosition(pPlayer);
                break;

            case 1:
                //-----Richtung bestimmen-----
                mDestination = rIObj.DistantActionPosition(pPlayer.SkeletonPosition);
                mSource      = pPlayer.SkeletonPosition;
                Sequences.AnimateAccordingToDirection(pPlayer, mDestination - mSource, Hardcoded.Anim_Jump_Up_Hansel, Hardcoded.Anim_Jump_Down_Hansel, Hardcoded.Anim_Jump_Side_Hansel);
                ++pPlayer.mCurrentState;
                break;

            case 2:
                //-----Springen-----
                Sequences.SynchMovementToAnimation(pPlayer, pPlayer, mSource, mDestination);
                if (Conditions.AnimationComplete(pPlayer))
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                }
                break;
            }
        }
예제 #4
0
 public void UpdateOverlay(ref List <InteractiveObject> pRenderList)
 {
     if (Progress.Progress > Hardcoded.UseWell_ShowOverlayProgressBarrier)
     {
         Sequences.SetWellOverlay(rIObj.SkeletonPosition, false, ref pRenderList);                 //Hide Overlay
         return;
     }
     Sequences.SetWellOverlay(rIObj.SkeletonPosition, true, ref pRenderList);             //Display Overlay
 }
예제 #5
0
        public override void Update(Player pPlayer, Player pOtherPlayer)
        {
            switch (pPlayer.mCurrentState)
            {
            case 0:
                //-----Zu Positionen holden-----
                if (!Conditions.ActionHold(pPlayer))
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                    break;
                }
                if (Conditions.PlayersAtActionPositions(pPlayer, pOtherPlayer))
                {
                    ++pPlayer.mCurrentState;
                }
                Sequences.MovePlayerToRightActionPosition(pPlayer);
                break;

            case 1:
                //-----Animation starten-----
                Sequences.StartAnimation(pPlayer, Hardcoded.Anim_Amulet_Charge);
                Sequences.StartAnimation(pOtherPlayer, Hardcoded.Anim_Amulet_Charge);
                ++pPlayer.mCurrentState;
                pOtherPlayer.mCurrentState = pPlayer.mCurrentState;
                break;

            case 2:
                //-----Amulett hoch halten-----
                if (pPlayer.GetType() == typeof(Hansel))
                {
                    Sequences.UpdateActIProgressBoth(Progress, ActI, pPlayer, pOtherPlayer, new Vector2(0, -1));
                    //Sequences.UpdateAnimationStepping(rIObj, Progress.Progress);
                    Sequences.UpdateAnimationStepping(pPlayer, Progress.Progress);
                }
                else
                {
                    Sequences.UpdateAnimationStepping(pPlayer, Progress.Progress);
                }

                if (Progress.Complete)
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                    Sequences.SetPlayerToIdle(pOtherPlayer);
                    ActI.SetFadingState(pPlayer, false);
                    ActI.SetFadingState(pOtherPlayer, false);
                    rIObj.ActionRectList.Clear();
                    m2ndState = true;
                }
                break;
            }
            ActI.Update();
        }
예제 #6
0
        public override void Update(Player pPlayer, Player pOtherPlayer)
        {
            switch (pPlayer.mCurrentState)
            {
            case 0:
                //-----Zu Position bewegen-----
                if (Conditions.PlayerAtNearestActionPosition(pPlayer))
                {
                    ++pPlayer.mCurrentState;
                }
                Sequences.MovePlayerToNearestActionPosition(pPlayer);
                break;

            case 1:
                //-----Animation starten-----
                Sequences.StartAnimation(pPlayer, Hardcoded.Anim_SlipAway_Gretel);                         //Weg bewegen
                ++pPlayer.mCurrentState;
                break;

            case 2:
                //-----Weg bewegt?-----
                if (Conditions.AnimationComplete(pPlayer))
                {
                    Destination       = rIObj.DistantActionPosition(pPlayer.SkeletonPosition);
                    pPlayer.IsVisible = false;
                    ++pPlayer.mCurrentState;
                }
                break;

            case 3:
                //-----Durch Felsspalt bewegen-----
                if (pPlayer.SkeletonPosition == Destination)
                {
                    Sequences.StartAnimation(pPlayer, Hardcoded.Anim_SlipBack_Gretel);                             //Wieder "auftauchen"
                    pPlayer.IsVisible = true;
                    ++pPlayer.mCurrentState;
                    break;
                }
                Sequences.MoveToPosition(pPlayer, Destination);
                break;

            case 4:
                //-----Wieder komplett da?-----
                if (Conditions.AnimationComplete(pPlayer))
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                }
                break;
            }
        }
예제 #7
0
        public override void Update(Player pPlayer, Player pOtherPlayer)
        {
            switch (pPlayer.mCurrentState)
            {
            case 0:
                //-----Zu Positionen holden-----
                if (!Conditions.ActionHold(pPlayer))
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                    break;
                }
                if (Conditions.PlayersAtActionPositions(pPlayer, pOtherPlayer))
                {
                    ++pPlayer.mCurrentState;
                }
                Sequences.MovePlayerToRightActionPosition(pPlayer);
                break;

            case 1:
                //-----Richtung bestimmen-----
                if (m2ndState)
                {
                    ++pPlayer.mCurrentState;
                    break;
                }
                m2ndState = true;
                if (pPlayer.GetType() == typeof(Hansel))
                {
                    mSourceHansel = pPlayer.SkeletonPosition;
                    mSourceGretel = pOtherPlayer.SkeletonPosition;
                }
                else
                {
                    mSourceHansel = pOtherPlayer.SkeletonPosition;
                    mSourceGretel = pPlayer.SkeletonPosition;
                }
                mSourceIObj = rIObj.SkeletonPosition;                         //new Vector2(rIObj.CollisionRectList[0].X, rIObj.CollisionRectList[0].Y);

                Vector2 ActionToCollisionRectDirection = new Vector2(rIObj.CollisionRectList[0].X - rIObj.ActionRectList[0].X, rIObj.CollisionRectList[0].Y - rIObj.ActionRectList[0].Y);

                Vector2 DestinationDelta;
                if (ActionToCollisionRectDirection.Y > 0)
                {
                    DestinationDelta = new Vector2(0, Hardcoded.PushRock_RockMoveDistance);
                    ActI.SetThumbstickDirBoth(ActivityInstruction.ThumbstickDirection.Down);
                }
                else if (ActionToCollisionRectDirection.Y < 0)
                {
                    DestinationDelta = new Vector2(0, -Hardcoded.PushRock_RockMoveDistance);
                    ActI.SetThumbstickDirBoth(ActivityInstruction.ThumbstickDirection.Up);
                }
                else if (ActionToCollisionRectDirection.X > 0)
                {
                    DestinationDelta = new Vector2(Hardcoded.PushRock_RockMoveDistance, 0);
                    ActI.SetThumbstickDirBoth(ActivityInstruction.ThumbstickDirection.Right);
                }
                else
                {
                    DestinationDelta = new Vector2(-Hardcoded.PushRock_RockMoveDistance, 0);
                    ActI.SetThumbstickDirBoth(ActivityInstruction.ThumbstickDirection.Left);
                }

                mDestinationIObj   = rIObj.SkeletonPosition + DestinationDelta;
                mDestinationHansel = mSourceHansel + DestinationDelta;
                mDestinationGretel = mSourceGretel + DestinationDelta;

                //Passende Animation entsprechend AnimationDirection starten
                Sequences.AnimateAccordingToDirection(pPlayer, ActionToCollisionRectDirection, Hardcoded.Anim_PushRock_Up, Hardcoded.Anim_PushRock_Down, Hardcoded.Anim_PushRock_Side);
                Sequences.AnimateAccordingToDirection(pOtherPlayer, ActionToCollisionRectDirection, Hardcoded.Anim_PushRock_Up, Hardcoded.Anim_PushRock_Down, Hardcoded.Anim_PushRock_Side);
                ++pPlayer.mCurrentState;
                pOtherPlayer.mCurrentState = pPlayer.mCurrentState;
                break;

            case 2:
                //-----Fels bewegen-----
                Sequences.UpdateActIProgressBoth(Progress, ActI, pPlayer, pOtherPlayer, mDestinationIObj - mSourceIObj, false);
                if (Progress.Progress >= 0f && !Conditions.ActionHold(pPlayer) && !Conditions.ActionHold(pOtherPlayer))
                {                         //Abbrechbar
                    Sequences.SetPlayerToIdle(pPlayer);
                    Sequences.SetPlayerToIdle(pOtherPlayer);
                }
                if (pPlayer.GetType() == typeof(Hansel))
                {
                    Sequences.UpdateMovementStepping(rIObj, Progress.Progress, mSourceIObj, mDestinationIObj);
                    Sequences.UpdateMovementStepping(pPlayer, Progress.Progress, mSourceHansel, mDestinationHansel);
                    Sequences.UpdateMovementStepping(pOtherPlayer, Progress.Progress, mSourceGretel, mDestinationGretel);
                    Sequences.UpdateAnimationStepping(pPlayer, Progress.Progress);
                    Sequences.UpdateAnimationStepping(pOtherPlayer, Progress.Progress);
                }
                if (Progress.Complete)
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                    Sequences.SetPlayerToIdle(pOtherPlayer);
                    ActI.SetFadingState(pPlayer, false);
                    ActI.SetFadingState(pOtherPlayer, false);
                    rIObj.ActionRectList.Clear();
                }
                break;
            }
            ActI.Update();
        }
예제 #8
0
 public override void Draw(SpriteBatch pSpriteBatch, Player pPlayer, Player pOtherPlayer)
 {
     Sequences.DrawActI(ActI, pSpriteBatch, pPlayer, pOtherPlayer);
 }
예제 #9
0
        public override void Update(Player pPlayer, Player pOtherPlayer)
        {
            if (!m2ndState)             //KnockOverTree
            {
                switch (pPlayer.mCurrentState)
                {
                case 0:
                    //-----Zu Position bewegen-----
                    if (Conditions.PlayerAtActionPosition(pPlayer))
                    {
                        ++pPlayer.mCurrentState;
                    }
                    Sequences.MovePlayerToActionPosition(pPlayer);
                    break;

                case 1:
                    //-----Richtung bestimmen-----
                    Sequences.StartAnimation(pPlayer, Hardcoded.Anim_KnockOverTree_Up);
                    ActivityInstruction.ThumbstickDirection dir = ActivityInstruction.ThumbstickDirection.None;
                    Vector2 DestinationDelta = rIObj.ActionPosition2 - rIObj.ActionPosition1;
                    DestinationDelta.Normalize();
                    if (DestinationDelta.Y > Math.Sin(MathHelper.ToRadians(67.5f)))                             //Runter
                    {
                        dir = ActivityInstruction.ThumbstickDirection.Down;
                    }
                    else if (DestinationDelta.Y > Math.Sin(MathHelper.ToRadians(-22.5f))) //Seitlich
                    {
                        if (DestinationDelta.X < 0)                                       //Links
                        {
                            dir = ActivityInstruction.ThumbstickDirection.Left;
                        }
                        else                                 //Rechts
                        {
                            dir = ActivityInstruction.ThumbstickDirection.Right;
                        }
                    }
                    else                             //Hoch
                    {
                        dir = ActivityInstruction.ThumbstickDirection.Up;
                    }

                    string animPlayer = Character.GetRightDirectionAnimation(rIObj.ActionPosition2 - rIObj.ActionPosition1, Hardcoded.Anim_KnockOverTree_Up, Hardcoded.Anim_KnockOverTree_Down, Hardcoded.Anim_KnockOverTree_Side);
                    string animTree   = Character.GetRightDirectionAnimation(rIObj.ActionPosition2 - rIObj.ActionPosition1, Hardcoded.Anim_Tree_KnockOver_Up, Hardcoded.Anim_Tree_KnockOver_Down, Hardcoded.Anim_Tree_KnockOver_Side);

                    Character.SetSkeletonFlipState(pPlayer, rIObj.ActionPosition2 - rIObj.ActionPosition1);
                    Character.SetSkeletonFlipState(rIObj, rIObj.ActionPosition2 - rIObj.ActionPosition1);
                    Sequences.StartAnimation(pPlayer, animPlayer);
                    Sequences.StartAnimation(rIObj, animTree);

                    ActI.SetThumbstickDir(pPlayer, dir);
                    ActI.SetThumbstickDir(pOtherPlayer, ActivityInstruction.ThumbstickDirection.None);
                    ++pPlayer.mCurrentState;
                    break;

                case 2:
                    //-----Baum umwerfen-----
                    if (!Conditions.ActionThumbstickPressed(pPlayer, rIObj.ActionPosition2 - rIObj.ActionPosition1))
                    {
                        ActI.SetFadingState(pPlayer, true);
                        Progress.StepBackward();
                    }
                    else
                    {
                        ActI.SetFadingState(pPlayer, false, false);
                        Progress.StepForward();
                    }
                    Sequences.UpdateAnimationStepping(rIObj, Progress.Progress);
                    Sequences.UpdateAnimationStepping(pPlayer, Progress.Progress);

                    if (Progress.Complete)
                    {
                        //Baum fällt
                        string anim = Character.GetRightDirectionAnimation(rIObj.ActionPosition2 - rIObj.ActionPosition1, Hardcoded.Anim_Tree_Falling_Up, Hardcoded.Anim_Tree_Falling_Down, Hardcoded.Anim_Tree_Falling_Side);
                        Sequences.StartAnimation(rIObj, anim);
                        //Sequences.StartAnimation(pPlayer, "attack"); kann weg?
                        ActI.SetFadingState(pPlayer, false);
                        ++pPlayer.mCurrentState;
                    }
                    break;

                case 3:
                    //-----Baum umgefallen?-----
                    if (Conditions.AnimationComplete(rIObj))
                    {
                        Sequences.SetPlayerToIdle(pPlayer);
                        m2ndState = true;
                    }
                    break;
                }
                ActI.Update();
            }
            else             //BalanceOverTree
            {
                switch (pPlayer.mCurrentState)
                {
                case 0:
                    //-----Zu Position bewegen-----
                    if (!Conditions.ActivityNotInUseByOtherPlayer(pOtherPlayer, this))
                    {
                        Sequences.SetPlayerToIdle(pPlayer);
                        return;
                    }
                    if (Conditions.PlayerAtNearestActionPosition(pPlayer))
                    {
                        ++pPlayer.mCurrentState;
                    }
                    Sequences.MovePlayerToNearestActionPosition(pPlayer);
                    break;

                case 1:
                    //-----Richtung bestimmen-----
                    IsAvailable   = false;
                    StartPosition = pPlayer.SkeletonPosition;
                    Direction     = rIObj.DistantActionPosition(pPlayer.SkeletonPosition) - StartPosition;
                    Sequences.AnimateAccordingToDirection(pPlayer, Direction, Hardcoded.Anim_Balance_Enter_Up, Hardcoded.Anim_Balance_Enter_Down, Hardcoded.Anim_Balance_Enter_Side);
                    ++pPlayer.mCurrentState;
                    break;

                case 2:
                    //-----Auf Baum steigen-----
                    Direction.Normalize();
                    Sequences.SynchMovementToAnimation(pPlayer, pPlayer, StartPosition, StartPosition + (Direction * Hardcoded.KnockOverTree_EnterBalanceDistance));
                    if (Conditions.AnimationComplete(pPlayer))
                    {
                        ++pPlayer.mCurrentState;
                    }
                    break;

                case 3:
                    //-----Auf Baum balancieren-----
                    //Update Movement
                    Vector2 MovementInput = pPlayer.Input.Movement;
                    if (MovementInput == Vector2.Zero)
                    {
                        Sequences.StartAnimation(pPlayer, Hardcoded.Anim_Balance_Idle);
                        break;                                 //Performance quit
                    }

                    //Sideways?
                    Vector2 DirectionTest = rIObj.ActionPosition2 - rIObj.ActionPosition1;
                    DirectionTest.Normalize();
                    bool Sideways = false;
                    if (DirectionTest.Y <= Math.Sin(MathHelper.ToRadians(45f)) && DirectionTest.Y >= -Math.Sin(MathHelper.ToRadians(45f)))
                    {
                        Sideways = true;
                    }

                    //Runter fallen?
                    if ((MovementInput.X == 0 && MovementInput.Y != 0 && Sideways) || (MovementInput.X != 0 && MovementInput.Y == 0 && !Sideways))
                    {
                        GameScene.End = true;
                        break;
                    }

                    //BalancingMovement ausführen
                    Sequences.AnimateAccordingToDirection(pPlayer, DirectionTest, Hardcoded.Anim_Balance_Up, Hardcoded.Anim_Balance_Down, Hardcoded.Anim_Balance_Side);
                    pPlayer.MoveAgainstPoint(rIObj.NearestActionPosition(pPlayer.SkeletonPosition + MovementInput * 1000f), Hardcoded.KnockOverTree_BalanceSpeedFactor, null, true, false, false);

                    //Leave Tree?
                    Vector2 TargetActionPosition = rIObj.NearestActionPosition(pPlayer.SkeletonPosition + MovementInput * 1000f);
                    Vector2 MovementDirection    = TargetActionPosition - pPlayer.SkeletonPosition;
                    MovementDirection.Normalize();
                    //Wenn Entfernung vom Player zum TargetActionPoint <= EnterBalanceEntfernung
                    if ((TargetActionPosition - pPlayer.SkeletonPosition).Length() <= (MovementDirection * Hardcoded.KnockOverTree_EnterBalanceDistance).Length())
                    {
                        ++pPlayer.mCurrentState;
                        StartPosition = pPlayer.SkeletonPosition;
                        Sequences.AnimateAccordingToDirection(pPlayer, MovementDirection, Hardcoded.Anim_Balance_Leave_Up, Hardcoded.Anim_Balance_Leave_Down, Hardcoded.Anim_Balance_Leave_Side);
                    }
                    break;

                case 4:
                    //-----Von Baum steigen-----
                    Sequences.SynchMovementToAnimation(pPlayer, pPlayer, StartPosition, StartPosition + (Direction * Hardcoded.KnockOverTree_EnterBalanceDistance));
                    while (pPlayer.CollisionBox.Intersects(pOtherPlayer.CollisionBox))
                    {
                        pOtherPlayer.MoveManually(Direction);
                    }
                    if (Conditions.AnimationComplete(pPlayer))
                    {
                        Sequences.SetPlayerToIdle(pPlayer);
                        IsAvailable = true;
                        //pPlayer.mCurrentState = 0;
                    }
                    break;
                }
            }
        }
예제 #10
0
        public override void Update(Player pPlayer, Player pOtherPlayer)
        {
            switch (pPlayer.mCurrentState)
            {
            case 0:
                //-----Zu Positionen holden-----
                if (!Conditions.ActionHold(pPlayer))
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                    break;
                }
                //Wenn Spieler an passenden Positionen sind
                if ((!m2ndState && Conditions.PlayersAtWellPositions(pPlayer, pOtherPlayer, false)) ||
                    (m2ndState && Conditions.PlayersAtWellPositions(pPlayer, pOtherPlayer, true))
                    )
                {
                    ++pPlayer.mCurrentState;
                }
                //Spieler zu passenden Positionen bewegen
                if (m2ndState)                         //Gretel im Brunnen zum Korb bewegen
                {
                    Sequences.MovePlayerToWellActionPosition(pPlayer, true);
                }
                else
                {
                    Sequences.MovePlayerToWellActionPosition(pPlayer, false);
                }
                break;

            case 1:
                //Nur gemeinsam starten
                if (pOtherPlayer.mCurrentState > 0)
                {
                    ++pPlayer.mCurrentState;
                }
                break;

            case 2:
                //-----Animationen starten (Hansel an Kurbel bereit machen, Gretel in Korb steigen)-----
                m2ndState = true;
                if (pPlayer.GetType() == typeof(Hansel))
                {
                    pPlayer.SetAnimation(Hardcoded.Anim_Well_GrabWind_Hansel);                             //An Kurbel
                }
                else
                {
                    pPlayer.SetAnimation(Hardcoded.Anim_Well_Enter_Gretel, false);                             //In Korb steigen
                }
                ++pPlayer.mCurrentState;
                break;

            case 3:
                //-----Gretel bereit / im Korb?-----
                if (pOtherPlayer.mCurrentState < 3)
                {
                    break;
                }
                bool finished = false;
                if (pPlayer.GetType() == typeof(Gretel))                         //Gretel im Korb
                {
                    finished = Conditions.AnimationComplete(pPlayer);
                }
                else
                {
                    finished = Conditions.AnimationComplete(pOtherPlayer);
                }
                if (finished)
                {
                    ++pPlayer.mCurrentState;
                }
                break;

            case 4:
                //-----Brunnen hochziehen / herablassen-----
                if (pOtherPlayer.mCurrentState != 4)
                {
                    break;
                }
                if (pPlayer.GetType() == typeof(Hansel))
                {
                    if (pPlayer.Input.ActionIsPressed && pPlayer.Input.LeftStickRotation != 0f && pOtherPlayer.Input.ActionIsPressed)                             //Brunnen wird bewegt?
                    {
                        if (pPlayer.Input.LeftStickRotation > 0f)
                        {
                            pPlayer.SetAnimation(Hardcoded.Anim_Well_Wind_Down_Hansel);                                     //Brunnen runter lassen Animation
                            pOtherPlayer.SetAnimation(Hardcoded.Anim_Well_Hang_Gretel);
                        }
                        else if (pPlayer.Input.LeftStickRotation < 0f)
                        {
                            pPlayer.SetAnimation(Hardcoded.Anim_Well_Wind_Up_Hansel);                                     //Brunnen hoch ziehen Animation
                            pOtherPlayer.SetAnimation(Hardcoded.Anim_Well_Hang_Gretel);
                        }
                        ActI.SetFadingState(pPlayer, false, false);
                        ActI.SetFadingState(pOtherPlayer, false, false);
                        Progress.StepFromRotation(pPlayer.Input.LeftStickRotation, Hardcoded.UseWell_ProgressPerRotation, Hardcoded.UseWell_UpRotationFrictionFactor);
                    }
                    else
                    {
                        pPlayer.SetAnimation(Hardcoded.Anim_Well_Wind_Idle_Hansel);                                 //Brunnen idle Animation
                        pOtherPlayer.SetAnimation(Hardcoded.Anim_Well_Idle_Gretel);
                        if (pPlayer.Input.ActionIsPressed && pPlayer.Input.LeftStickRotation != 0f)                 //Hansel versucht Brunnen zu bewegen?
                        {
                            ActI.SetFadingState(pPlayer, false, false);
                        }
                        else
                        {
                            ActI.SetFadingState(pPlayer, true, false);
                        }
                        if (pOtherPlayer.Input.ActionIsPressed)
                        {
                            ActI.SetFadingState(pOtherPlayer, false, false);
                        }
                        else
                        {
                            ActI.SetFadingState(pOtherPlayer, true);
                        }
                    }

                    if (Progress.Progress <= 0f && pPlayer.Input.LeftStickRotation < 0f)
                    {
                        ActI.SetFadingState(pPlayer, false);
                        ActI.SetFadingState(pOtherPlayer, false);
                        Progress.Reset();
                        pPlayer.SetAnimation();                                 //Hansel von Kurbel weg nehmen
                        pPlayer.mCurrentState      = 10;
                        pOtherPlayer.mCurrentState = 8;
                    }
                    if (Progress.Progress >= 1f && pPlayer.Input.LeftStickRotation > 0f)
                    {
                        ActI.SetFadingState(pPlayer, false);
                        ActI.SetFadingState(pOtherPlayer, false);
                        Progress.Reset(true);
                        pOtherPlayer.mCurrentState = 8;
                    }
                    Sequences.UpdateAnimationStepping(rIObj, Progress.Progress);
                    Sequences.UpdateMovementStepping(pOtherPlayer, Progress.Progress, Conditions.WellActionPosition2Up(rIObj), rIObj.ActionPosition2);
                }
                break;

            case 8:
                //-----Oben/Unten aussteigen-----
                pPlayer.SetAnimation(Hardcoded.Anim_Well_Leave_Gretel, false);                         // Aus Eimer aussteigen
                ++pPlayer.mCurrentState;
                break;

            case 9:
                if (Conditions.AnimationComplete(pPlayer))
                {
                    pPlayer.SetAnimation();
                    ++pPlayer.mCurrentState;
                }
                break;

            case 10:
                //-----States setzen-----
                if (Conditions.AnimationComplete(pPlayer))
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                    if (pPlayer.GetType() == typeof(Hansel))
                    {
                        Progress.Reset();
                        m2ndState = false;
                    }
                }
                break;
            }
            ActI.Update();
        }
예제 #11
0
        //-----Workaround für linerare Abhängigkeit HG_Game -> HG_Data -> KryptonEngine-----
        public void SetupInteractiveObjectsFromDeserialization(Savegame pSavegame, Hansel pHansel, Gretel pGretel)
        {
            for (int i = 0; i < pSavegame.Scenes.Length; i++)
            {
                foreach (InteractiveObject iObj in pSavegame.Scenes[i].InteractiveObjects)
                {
                    switch (iObj.ActivityId)
                    {
                    case Activity.None:
                        iObj.ActivityState = None;
                        break;

                    case Activity.KnockOverTree:
                        iObj.ActivityState = new KnockOverTree(pHansel, pGretel, iObj);
                        break;

                    case Activity.BalanceOverTree:
                        iObj.ActivityState = new KnockOverTree(pHansel, pGretel, iObj);
                        Sequences.AnimateAccordingToDirection(iObj, iObj.ActionPosition2 - iObj.ActionPosition1, Hardcoded.Anim_Tree_Fallen_Up, Hardcoded.Anim_Tree_Fallen_Down, Hardcoded.Anim_Tree_Fallen_Side);
                        iObj.ActivityState.m2ndState = true;
                        break;

                    case Activity.PushRock:
                        iObj.ActivityState = new PushRock(pHansel, pGretel, iObj);
                        break;

                    case Activity.SlipThroughRock:
                        iObj.ActivityState = new SlipThroughRock(pHansel, pGretel, iObj);
                        break;

                    case Activity.JumpOverGap:
                        iObj.ActivityState = new JumpOverGap(pHansel, pGretel, iObj);
                        break;

                    case Activity.LegUp:
                        iObj.ActivityState = new LegUp(pHansel, pGretel, iObj);
                        break;

                    case Activity.LegUpGrab:
                        iObj.ActivityState           = new LegUp(pHansel, pGretel, iObj);
                        iObj.ActivityState.m2ndState = true;
                        break;

                    case Activity.PushDoor:
                        iObj.ActivityState = new PushDoor(pHansel, pGretel, iObj);
                        break;

                    case Activity.PullDoor:
                        throw new Exception("Es gibt keine Tür mehr die von den Spielern geschlossen werden soll");

                        /*iObj.ActivityState = new PushDoor(pHansel, pGretel, iObj);
                         * Sequences.AnimateAccordingToDirection(iObj, new Vector2(iObj.CollisionRectList[0].X - iObj.ActionRectList[0].X, iObj.CollisionRectList[0].Y - iObj.ActionRectList[0].Y), Hardcoded.Anim_Door_Open_Up, Hardcoded.Anim_Door_Open_Down, Hardcoded.Anim_Door_Open_Side);
                         * iObj.ActivityState.m2ndState = true;*/
                        break;

                    case Activity.UseWell:
                        iObj.ActivityState = new UseWell(pHansel, pGretel, iObj);
                        break;

                    case Activity.ChargeAmulet:
                        iObj.ActivityState = new ChargeAmulet(pHansel, pGretel, iObj);
                        AmuletStates.Add((ChargeAmulet)iObj.ActivityState);
                        break;

                    default:
                        throw new Exception("Im InteractiveObject " + iObj.ObjectId.ToString() + " in Scene " + i.ToString() + " ist eine ungültige Action angegeben!");
                    }
                }
            }
        }
예제 #12
0
        public override void Update(Player pPlayer, Player pOtherPlayer)
        {
            switch (pPlayer.mCurrentState)
            {
            case 0:
                //-----Zu Position holden-----
                if (!m2ndState)                         //LegUp
                {
                    Progress.Reset();                   //LegUp kann mehrfach ausgeführt werden
                }
                if (!Conditions.ActionHold(pPlayer))
                {
                    Sequences.SetPlayerToIdle(pPlayer);
                    break;
                }
                if (Conditions.PlayersAtActionPositions(pPlayer, pOtherPlayer, Hardcoded.LegUp_StartOffsetGretel))
                {
                    ++pPlayer.mCurrentState;
                }
                Sequences.MovePlayerToRightActionPosition(pPlayer, Hardcoded.LegUp_StartOffsetGretel);
                break;

            case 1:
                Sequences.StartAnimation(pPlayer, Hardcoded.Anim_LegUp_Raise);
                ActI.ThumbstickDirHansel = ActivityInstruction.ThumbstickDirection.Up;
                ActI.ThumbstickDirGretel = ActivityInstruction.ThumbstickDirection.None;
                ++pPlayer.mCurrentState;
                break;

            case 2:
                //-----Hoch heben-----
                if (pPlayer.GetType() == typeof(Hansel))
                {
                    Sequences.UpdateActIProgressBothLegUp(Progress, ActI, pPlayer, pOtherPlayer, new Vector2(0, -1));
                    if (Progress.Progress <= 0f && !Conditions.ActionHold(pPlayer) && !Conditions.ActionHold(pOtherPlayer))
                    {                             //Abbrechbar
                        Sequences.SetPlayerToIdle(pPlayer);
                        Sequences.SetPlayerToIdle(pOtherPlayer);
                    }
                    Sequences.UpdateAnimationStepping(pPlayer, Progress.Progress);
                    Sequences.UpdateAnimationStepping(pOtherPlayer, Progress.Progress);

                    if (Progress.Complete)
                    {                             //GretelGrab am höchsten Punkt
                        ActI.ThumbstickDirGretel = ActivityInstruction.ThumbstickDirection.Up;
                        if (Conditions.ActionThumbstickPressed(pOtherPlayer, new Vector2(0, -1)))
                        {                                 //Start Grab
                            ActI.SetFadingState(pPlayer, false);
                            ActI.SetFadingState(pOtherPlayer, false, false);
                            ++pPlayer.mCurrentState;
                            pOtherPlayer.mCurrentState = pPlayer.mCurrentState;
                        }
                        else                                 //Show ActI f Gretel
                        {
                            ActI.SetFadingState(pOtherPlayer, true);
                        }
                    }
                    else
                    {                             //Nicht am höchsten Punkt: ActI.Gretel nicht Thumbstick anzeigen
                        ActI.ThumbstickDirGretel = ActivityInstruction.ThumbstickDirection.None;
                    }
                }
                break;

            case 3:
                //-----Gretel nächste Animation starten-----
                if (pPlayer.GetType() == typeof(Gretel))
                {
                    if (!m2ndState)                                                          //LegUp
                    {
                        Sequences.StartAnimation(pPlayer, Hardcoded.Anim_LegUp_Lift_Gretel); //hoch ziehen
                    }
                    else                                                                     //LegUpGrab
                    {
                        Sequences.StartAnimation(pPlayer, Hardcoded.Anim_LegUp_Grab_Gretel); //Item greifen
                        rIObj.ActionRectList.Clear();                                        //LegUpGrab kann nicht mehrfach ausgeführt werden
                    }
                    ++pPlayer.mCurrentState;
                    pOtherPlayer.mCurrentState = pPlayer.mCurrentState;
                }
                break;

            case 4:
                //-----Gretel fertig?-----
                if (pPlayer.GetType() == typeof(Hansel) && Conditions.AnimationComplete(pOtherPlayer))
                {
                    ActI.SetFadingState(pOtherPlayer, false);
                    if (m2ndState)                             //LegUpGrab
                    {
                        //Gretel runter lassen
                        Sequences.StartAnimation(pPlayer, Hardcoded.Anim_LegUp_Lower);
                        Sequences.StartAnimation(pOtherPlayer, Hardcoded.Anim_LegUp_Lower);
                    }
                    ++pPlayer.mCurrentState;
                    pOtherPlayer.mCurrentState = pPlayer.mCurrentState;
                }
                break;

            case 5:
                //-----Beide fertig?-----
                if (Conditions.AnimationComplete(pPlayer))
                {
                    if (!m2ndState && pPlayer.GetType() == typeof(Gretel))
                    {
                        Sequences.Move(pPlayer, Hardcoded.LegUp_OffsetGretel[GameReferenzes.SceneID]);                                 //Bei LegUp Gretel hoch setzen
                    }
                    Sequences.SetPlayerToIdle(pPlayer);
                }
                break;
            }
            ActI.Update();
        }