source: 2015/27/ohjaajat/TheLegendOfGabriel/TheLegendOfGabriel/TheLegendOfGabriel/TheLegendOfGabriel.cs @ 6540

using System;
using System.Collections.Generic;
using System.Linq;
using Jypeli;
using Jypeli.Assets;
using Jypeli.Controls;
using Jypeli.Effects;
using Jypeli.Widgets;

sealed class Exit : PhysicsObject
{
    /// <summary>
    /// Kentän nimi johon siirrytään.
    /// </summary>
    public string TargetLevel { get; set; }

    /// <summary>
    /// Kohdekentässä olevan exitin nimi jonka päältä aloitetaan.
    /// </summary>
    public string TargetExitName { get; set; }

    /// <summary>
    /// Tämän uloskäynnin nimi.
    /// </summary>
    public string Name { get; set; }

    public Exit(double width, double height)
        : base(width, height)
    {
        Color = new Color(255, 0, 0, 60); // Debuggausta varten jotta näkee uloskäynnit.
        IgnoresCollisionResponse = true;
        Tag = "exit";
    }
}

class Creature : PhysicsObject
{
    public double MovementSpeed { get; set; }

    public Creature(double width, double height)
        : base(width, height)
    {
        LinearDamping = 0.5;
    }

    public void Move(Direction direction)
    {
        if (!Game.IsPaused)
            Push(direction.GetVector() * MovementSpeed);
    }
}

public partial class TheLegendOfGabriel : PhysicsGame
{
    public const int TILE_SIZE = 20;

    private Creature player;

    private bool transition = false;
    List<GameObject> oldObjects = new List<GameObject>();
    List<Exit> exits = new List<Exit>();

    public override void Begin()
    {
        SmoothTextures = false;
        StartGame();
    }

    private void StartGame()
    {
        ClearAll();
        CreateLevel("testlevel");
        CreatePlayer(new Vector(30, -30));
        SetControls();
        Camera.ZoomToLevel();
    }

    void SetControls()
    {
        Keyboard.Listen(Key.Left, ButtonState.Down, player.Move, null, Direction.Left);
        Keyboard.Listen(Key.Right, ButtonState.Down, player.Move, null, Direction.Right);
        Keyboard.Listen(Key.Up, ButtonState.Down, player.Move, null, Direction.Up);
        Keyboard.Listen(Key.Down, ButtonState.Down, player.Move, null, Direction.Down);

        Keyboard.Listen(Key.Escape, ButtonState.Pressed, ConfirmExit, null);
    }

    /// <summary>
    /// Luo pelaajan.
    /// </summary>
    void CreatePlayer(Vector position)
    {
        player = new Creature(TILE_SIZE, TILE_SIZE);
        player.MovementSpeed = 2300;
        player.Position = position;
        Add(player);

        AddCollisionHandler(player, "exit", CollidesWithExit);
    }

    void CollidesWithExit(PhysicsObject pPlayer, PhysicsObject pExit)
    {
        var oldExit = pExit as Exit;
        if (oldExit == null || transition)
            return;

        transition = true;

        // Otetaan vanhat objektit talteen.
        oldObjects.Clear();
        foreach (var obj in GetObjects(o => o != player))
        {
            if (obj != player)
            {
                oldObjects.Add(obj);
            }
        }

        // Luodaan seuraava kenttä.
        exits.Clear();
        CreateLevel(oldExit.TargetLevel);

        // Pysäytetään peli siirtymän ajaksi.
        Pause();
        PhysicsEnabled = false;

        // Etsitään seuraavan kentän kohde exitti johon siirrytään.
        var targetExit = exits.FirstOrDefault(e => e.Name == oldExit.TargetExitName);

        // Lasketaan siirtymävektorit.
        Direction dir = GetExitDirection(targetExit);
        Vector exitDelta = targetExit.Position - oldExit.Position;
        Vector transitionVector = Level.Size;
        if (dir == Direction.Left || dir == Direction.Right)
        {
            transitionVector.X *= dir.GetVector().X;
            transitionVector.Y = exitDelta.Y;
        }
        else
        {
            transitionVector.Y *= dir.GetVector().Y;
            transitionVector.X = exitDelta.X;
        }

        // Siirretään vanhoja objekteja ja pelaajaa.
        foreach (var obj in oldObjects)
        {
            obj.Position += transitionVector;
        }
        player.Position += transitionVector + Direction.Inverse(dir).GetVector() * TILE_SIZE * 4;

        // Zoomataan kameraa sopivasti ja liikutetaan se vanhan kentän päälle, josta se sitten siirtyy uuden kentän päälle.
        Camera.Position += transitionVector;
        Vector pos = Camera.Position;
        Camera.ZoomToLevel();
        Camera.Position = pos;
    }

    /// <summary>
    /// Palauttaa suunnan millä puolella kenttää uloskäynti on.
    /// </summary>    
    Direction GetExitDirection(Exit exit)
    {
        const double epsilon = 1e-3;
        Func<double, double, bool> isSame = (x, y) => Math.Abs(y - x) < epsilon;
        
        if (isSame(exit.Top, Level.Top))
        {
            return Direction.Up;
        }
        if (isSame(exit.Bottom, Level.Bottom))
        {
            return Direction.Down;
        }
        if (isSame(exit.Left, Level.Left))
        {
            return Direction.Left;
        }
        if (isSame(exit.Right, Level.Right))
        {
            return Direction.Right;
        }
        return Direction.None;
    }

    protected override void PausedUpdate(Time gameTime)
    {
        base.PausedUpdate(gameTime);
        double dt = gameTime.SinceLastUpdate.TotalSeconds;

        const double transitionSpeed = 5.0;

        if (transition)
        {
            Camera.Position += Camera.Position * -transitionSpeed * dt;

            // Siirtymä on ohi, jatketaan peliä ja poistetaan edellinen kenttä.
            if (Camera.Position.Magnitude < 1.0)
            {
                transition = false;
                Pause();
                PhysicsEnabled = true;
                Camera.Position = Vector.Zero;

                foreach (var obj in oldObjects)
                {
                    obj.Destroy();
                }
                oldObjects.Clear();
            }
        }
    }
}