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

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

public class StoryItem
{
    // Iso kuvake joka näkyy inventoryssä.
    public Image InventoryImage { get; set; }

    public Queue<string> Message { get; set; }

    public StoryItem(Queue<String> message, Image image)
    {
        this.InventoryImage = image;
        this.Message = message;
    }
}

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

    private Player player;

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

    private bool viewing;
    private double midpoint;
    private double second;
    GameObject frame;
    Queue<string> messagesviewed;

    private const int STORYITEM_COUNT = 3;
    StoryItem[] storyItem = new StoryItem[3];

    private Label currentItem;
    private Label nextItem;
    private Label prevItem;

    #region Resources

    public static Image GunImage = LoadImage("gun");
    public static Image LetterImage = LoadImage("letter");
    public static Image SmallSwordImage = LoadImage("smallsword");
    public static Image MonocleImage = LoadImage("monocle");

    public static Image FrameImage = LoadImage("frame");

    [AssetName("walkright")]
    internal Animation playerWalkRight;
    [AssetName("walkright", mirror: true)]
    internal Animation playerWalkLeft;
    [AssetName("walkup")]
    private Animation playerWalkUp;
    [AssetName("walkdown")]
    private Animation playerWalkDown;

    [AssetName("swingup")]
    private Animation playerSwingUp;
    [AssetName("swingright")]
    private Animation playerSwingRight;
    [AssetName("swingright", mirror: true)]
    private Animation playerSwingLeft;
    [AssetName("swingdown")]
    private Animation playerSwingDown;

    [AssetName("shootup")]
    private Animation playerShootUp;
    [AssetName("shootright")]
    private Animation playerShootRight;
    [AssetName("shootright", mirror: true)]
    private Animation playerShootLeft;
    [AssetName("shootdown")]
    private Animation playerShootDown;

    #endregion

    public override void Begin()
    {
        Mouse.IsCursorVisible = true;
        SmoothTextures = false;
        LoadAnimations();
        StartGame();
        //Intro();
        BuildRightBar();
        BuildInventoryCycle();
        UpdateItemCycleImages();
    }

    void BuildInventoryCycle()
    {
        const int spacing = 20;

        prevItem = new Label();
        prevItem.Size = new Vector(60, 40);
        prevItem.X = Screen.Left + 100;
        prevItem.Y = Screen.Top - 50;
        Add(prevItem);

        currentItem = new Label();
        currentItem.Size = prevItem.Size;
        currentItem.Left = prevItem.Right + spacing;
        currentItem.Y = prevItem.Y;
        Add(currentItem);

        nextItem = new Label();
        nextItem.Size = prevItem.Size;
        nextItem.Left = currentItem.Right + spacing;
        nextItem.Y = prevItem.Y;
        Add(nextItem);
    }

    void BuildRightBar()
    {
        for (int i = 0; i < STORYITEM_COUNT; i++)
        {
            GameObject member = new GameObject(FrameImage);
            member.Position = new Vector(Level.Right + FrameImage.Width, Level.Top - Level.Width * 0.25 - FrameImage.Height * i * 1.5);
            Add(member);

            GameObject inner = new GameObject(TILE_SIZE, TILE_SIZE);
            inner.Color = Color.Black;
            if (storyItem[i] != null)
            {
                inner.Image = storyItem[i].InventoryImage;
                Mouse.ListenOn(inner, MouseButton.Left, ButtonState.Pressed, ShowTextItem, "View those precious memories", storyItem[i]);
            }
            member.Add(inner);
        }
    }

    /// <summary>
    /// Lataa automaagisesti kaikki animaatiot.
    /// </summary>
    private void LoadAnimations()
    {
        // Haetaan tämän luokan kaikki ei-julkiset attribuutit.
        foreach (var field in GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance))
        {
            // Jos attribuutille on laitettu AsseName, niin ladataan sen niminen animaatio.
            var assetAttr = Attribute.GetCustomAttribute(field, typeof(AssetNameAttribute)) as AssetNameAttribute;
            if (assetAttr == null) continue;
            var anim = LoadAnimation(assetAttr.AssetName);
            field.SetValue(this, assetAttr.Mirror ? MirrorAnimation(anim) : anim);
        }
    }

    void Intro()
    {
        storyItem[0] = new StoryItem(new Queue<string>(new[] { "Dear Alexander,", 
            "",
            "",
            "I have accepted a position at the Communal Assets for Justice.",
            "Please do not consider this an act of rejection. I am simply",
            "a victim to the scathing uncertainty of your release from service.",
            "",
            "I still see your face in my dreams. I believe that when",
            "our immediate circumstances change, we'll meet again, we'll",
            "work it out. Were you here, we'd certainly fall in love.",
            "",
            "And perhaps then nothing could keep us apart.",
            "-Ana" 
        }), LetterImage);

        ShowTextItem(storyItem[0]);
    }

    void ShowTextItem(StoryItem item)
    {
        viewing = true;
        messagesviewed = new Queue<string>(item.Message);
        Pause();

        Level.AmbientLight -= 0.75;

        frame = new GameObject(LetterImage);
        frame.Image = LetterImage;
        frame.Width = Window.Width * 0.25;
        frame.Height = Window.Height * 0.25;
        Add(frame);

        midpoint = 26 * item.Message.Count() * 0.5;

    }

    /// <summary>
    /// Peilaa kaikki animaation kuvat.
    /// </summary>
    private static Animation MirrorAnimation(Animation anim)
    {
        return new Animation(anim.Select(Image.Mirror).ToArray()) { FPS = anim.FPS };
    }

    private void StartGame()
    {
        ClearAll();
        CreateLevel("level1");
        //CreatePlayer(new Vector(-Level.Width/3, Level.Bottom + TILE_SIZE * 2));
        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.X, ButtonState.Pressed, delegate { if (player.ActiveItem != null) player.ActiveItem.UseKeyPressed(); }, null);
        Keyboard.Listen(Key.X, ButtonState.Released, delegate { if (player.ActiveItem != null) player.ActiveItem.UseKeyReleased(); }, null);
        Keyboard.Listen(Key.X, ButtonState.Down, delegate { if (player.ActiveItem != null) player.ActiveItem.UseKeyDown(); }, null);

        Keyboard.Listen(Key.Z, ButtonState.Pressed, delegate { if (player.Sword != null) player.Sword.UseKeyPressed(); }, null);
        Keyboard.Listen(Key.Z, ButtonState.Released, delegate { if (player.Sword != null) player.Sword.UseKeyReleased(); }, null);
        Keyboard.Listen(Key.Z, ButtonState.Down, delegate { if (player.Sword != null) player.Sword.UseKeyDown(); }, null);

        Keyboard.Listen(Key.Space, ButtonState.Pressed, delegate { player.CycleItems(); UpdateItemCycleImages(); }, null);

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

    void UpdateItemCycleImages()
    {
        if (player.PrevItem != null) prevItem.Image = player.PrevItem.InventoryImage;
        if (player.NextItem != null) nextItem.Image = player.NextItem.InventoryImage;
        if (player.ActiveItem != null) currentItem.Image = player.ActiveItem.InventoryImage;
    }

    ///// <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);

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

        // Jompikumpi uloskäynti ei ole kentän laidalla, sulava siirtyminen ei ole mahdollista.
        if (GetExitDirection(targetExit) == Direction.None || GetExitDirection(oldExit) == Direction.None)
        {
            transition = false;
            oldObjects.ForEach(o => o.Destroy());
            oldObjects.Clear();

            // Yritetään päätellä pelaajalle joku järkevä paikka.
            player.Position = targetExit.Position + Direction.Inverse(targetExit.Position.Angle.MainDirection).GetVector() * TILE_SIZE * 2;
            Camera.ZoomToLevel();
            return;
        }

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

        // 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 = 500.0;

        if (transition && !viewing)
        {
            Camera.Position += Camera.Position.Normalize() * -transitionSpeed * dt;

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

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

        if(viewing && !transition)  //!transition perhaps being somewhat unnecessary, but now I do feel a bit safer.
        {
            second += dt;
            if(second > 1)
            {
                if (messagesviewed.Count < 1)   //The letter's read, we better head back.
                {
                    Level.AmbientLight = 1;
                    frame.Destroy();
                    GetObjectsWithTag("labelWaitingToDie").ForEach(g => g.Destroy());
                    viewing = false;
                    Pause();
                    return;
                }

                second = 0;
                var storyLabel = new Label(messagesviewed.Dequeue()) { TextColor = Color.White };
                storyLabel.Y = -midpoint + storyLabel.Height * messagesviewed.Count() + 1;
                storyLabel.Tag = "labelWaitingToDie";
                Add(storyLabel);

            }
            //Timer textTimer = new Timer();
            //textTimer.Interval = 1;
            //textTimer.Timeout += delegate
            //{
            //    if (messages.Count < 1)
            //    {
            //        Keyboard.EnableAll();
            //        Level.AmbientLight = 1;
            //        frame.Destroy();
            //        GetObjectsWithTag("labelWaitingToDie").ForEach(g => g.Destroy());
            //        textTimer.Stop();
            //        Pause();
            //        return;
            //    }

            //    var storyLabel = new Label(messages.Dequeue()) { TextColor = Color.White };
            //    storyLabel.Y = -midpoint + storyLabel.Height * messages.Count() + 1;
            //    storyLabel.Tag = "labelWaitingToDie";
            //    Add(storyLabel);
            //};
            //textTimer.Start();
        }
    }

    protected override void Update(Time time)
    {
        player.UpdateCreature(time);
        base.Update(time);
    }
}