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

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;
    }
}

class CycleSlot : Label
{
    public Label UsageLabel { get; set; }

    public CycleSlot(double left, double top)
    {
        this.Left = left;
        this.Top = top;
        this.Size = new Vector(60, 40);

        UsageLabel = new Label("10");
        UsageLabel.IsVisible = false;
        UsageLabel.TextColor = Color.White;
        UsageLabel.X = this.X + 10;
        UsageLabel.Top = this.Bottom;
        UsageLabel.Font = Font.DefaultSmallBold;
    }

    public void UpdateImage(Item item)
    {
        if (item != null)
        {
            this.Image = item.InventoryImage;
            UsageLabel.IsVisible = false;
            if (item.Usages.MaxValue > 0)
            {
                UsageLabel.IsVisible = true;
                UsageLabel.BindTo(item.Usages);
            }
        }
    }
}

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

    private Player player;
    private List<Creature> enemies = new List<Creature>(); 

    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 CycleSlot currentItem; // Laatikossa näkyvä nykyinen kama.
    private CycleSlot nextItem; // Seuraavan kaman kuva.
    private CycleSlot prevItem; // Edellisen kaman kuva.
    private Label swordItem; // Laatikossa näkyvä miekka.

    #region Resources

    public static SoundEffect SwordSound = LoadSoundEffect("swordsound");
    public static SoundEffect GunSound = LoadSoundEffect("gunsound");

    public static Image GunImage = LoadImage("gun");
    public static Image BulletImage = LoadImage("bullet");
    public static Image LetterImage = LoadImage("letter");
    public static Image SmallSwordImage = LoadImage("smallsword");
    public static Image MonocleImage = LoadImage("monocle");
    public static Image BigMonocleImage = LoadImage("bigmonocle");
    public static Image BigSwordImage = LoadImage("bigsword");
    public static Image GrenadeImage = LoadImage("gran");
    public static Image GrenadeSmallImage = LoadImage("gransmall");

    public static Image FrameImage = LoadImage("frame");
    public static Image ActiveItemFrameImageX = LoadImage("activeitemframe");
    public static Image ActiveItemFrameImageZ = LoadImage("activeitemframez");

    //public static Image PlayerHealthImage = LoadImage("playerhealth");
    //public static Image PlayerHealthEmptyImage = LoadImage("playerhealthempty");

    [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;

    [AssetName("coyoteup")]
    private Animation coyoteUp;
    [AssetName("coyoteright")]
    private Animation coyoteRight;
    [AssetName("coyoteright", mirror: true)]
    private Animation coyoteLeft;
    [AssetName("coyotedown")]
    private Animation coyoteDown;

    #endregion

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

    private void BuildHealthBar()
    {
        var bar = new ProgressBar(32 * 10, 32);
        bar.Right = Screen.Right - 50;
        bar.Top = Screen.Top - 50;
        //bar.Image = PlayerHealthEmptyImage;
        //bar.BarImage = PlayerHealthImage;
        bar.BindTo(player.Health);
        Add(bar);
    }

    void BuildInventoryCycle()
    {
        const int spacing = 20;

        prevItem = new CycleSlot(Screen.Left + 50, Screen.Top - 30);
        Add(prevItem);
        Add(prevItem.UsageLabel);

        currentItem = new CycleSlot(prevItem.Right + spacing, prevItem.Top);
        Add(currentItem);
        Add(currentItem.UsageLabel);

        nextItem = new CycleSlot(currentItem.Right + spacing, prevItem.Top);
        Add(nextItem);
        Add(nextItem.UsageLabel);

        // Ruutu jonka sisällä käytössä oleva kama on.
        var frame = new Label();
        frame.Size = new Vector(60, 60);
        frame.Image = ActiveItemFrameImageX;
        frame.X = currentItem.X;
        frame.Top = currentItem.Top;
        Add(frame);

        // Miekan kuva.
        swordItem = new Label();
        swordItem.Size = prevItem.Size;
        swordItem.Left = nextItem.Right + spacing * 2;
        swordItem.Top = currentItem.Top;
        Add(swordItem);

        // Miekan kuvan ympärillä oleva ruutu.
        var swordFrame = new Label();
        swordFrame.Size = new Vector(60, 60);
        swordFrame.Image = ActiveItemFrameImageZ;
        swordFrame.X = swordItem.X;
        swordFrame.Top = swordItem.Top;
        Add(swordFrame);
    }

    void BuildRightBar()
    {
        for (int i = 0; i < STORYITEM_COUNT; i++)
        {
            Label member = new Label(FrameImage);
            member.Size = new Vector(40, 40);
            member.Position = new Vector(Screen.Right - FrameImage.Width, Screen.Top - Screen.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);

            // Gameobjektit ei liiku mukana jos kamera liikkuu joten tein kehyksistä Labeleita.
            /*  
            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);
        }
    }

    Dictionary<Direction, Animation> DirectionalAnimations(Animation left, Animation right, Animation up, Animation down)
    {
        var dict = new Dictionary<Direction, Animation>();
        dict[Direction.Left] = left;
        dict[Direction.Right] = right;
        dict[Direction.Up] = up;
        dict[Direction.Down] = down;
        return dict;
    }

    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;
        frame.Width = Level.Width * 0.25;
        frame.Height = Level.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();
        CreatePlayer(new Vector(0, -300), TILE_SIZE, TILE_SIZE, Angle.Zero, Shape.Rectangle, "", null);
        CreateLevel("level1");
        //CreatePlayer(new Vector(-Level.Width/3, Level.Bottom + TILE_SIZE * 2));
        SetControls();
        //Camera.ZoomToLevel();
        Camera.Follow(player);
        Camera.ZoomFactor = 2.0;
    }

    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 { UseItem(player.ActiveItem, player.Sword, () => player.ActiveItem.UseKeyPressed()); }, null);
        Keyboard.Listen(Key.X, ButtonState.Released, delegate { UseItem(player.ActiveItem, player.Sword, () => player.ActiveItem.UseKeyReleased()); }, null);
        Keyboard.Listen(Key.X, ButtonState.Down, delegate { UseItem(player.ActiveItem, player.Sword, () => player.ActiveItem.UseKeyDown()); }, null);

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

        Keyboard.Listen(Key.Space, ButtonState.Pressed, CycleItems, null);

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

    /// <summary>
    /// Luo pelaajan.
    /// </summary>
    void CreatePlayer(Vector position, double width, double height, Angle angle, Shape shape, string name, Dictionary<string, string> properties)
    {
        player = new Player();
        player.CanRotate = false;
        player.MovementSpeed = new DoubleMeter(2300, 0, 2300);
        player.Position = position;
        player.MoveAnimations = DirectionalAnimations(playerWalkLeft, playerWalkRight, playerWalkUp, playerWalkDown);
        player.SwingAnimations = DirectionalAnimations(playerSwingLeft, playerSwingRight, playerSwingUp, playerSwingDown);
        player.ShootAnimations = DirectionalAnimations(playerShootLeft, playerShootRight, playerShootUp, playerShootDown);
        player.Image = playerWalkDown.CurrentFrame;
        Add(player, 1);

        player.Sword = new Sword(player);
        player.Inventory.Add(new Pistol(player));
        player.Inventory.Add(new Monocle(player));
        player.Inventory.Add(new Grenade(player));

        player.Health.Value = 3; // Alkuun vain kolme sydäntä.

        AddCollisionHandler(player, "exit", CollidesWithExit);
        AddCollisionHandler(player, "enemy", delegate(PhysicsObject p, PhysicsObject e)
        {
            player.Health.Value--;
        });
    }

    void UseItem(Item item, Item otherItem, Action action)
    {
        bool inUse = false;
        if (otherItem != null)
        {
            inUse = otherItem.InUse;
        }

        if (item != null && !inUse)
        {
            action();
        }
    }

    void CycleItems()
    {
        // Kaman vaihtossa simuloidaan että oltaisiin laskettu irti käyttönäppäimestä.
        if (player.ActiveItem != null)
        {
            player.ActiveItem.CancelUse();
        }
        if (player.Sword != null)
        {
            player.Sword.CancelUse();
        }

        player.CycleItems();
        UpdateItemCycleImages();
    }

    void UpdateItemCycleImages()
    {
        prevItem.UpdateImage(player.PrevItem);
        currentItem.UpdateImage(player.ActiveItem);
        nextItem.UpdateImage(player.NextItem);
        /*
        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;
         */

        if (player.Sword != null)
        {
            swordItem.Image = BigSwordImage;
        }
    }

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

        enemies.Clear();

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

        if (targetExit == null)
        {
            throw new Exception("Tarkisita kenttien exittien nimet.");
        }

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

            BuildRightBar();
            BuildInventoryCycle();
            UpdateItemCycleImages();

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

                BuildRightBar();
                BuildInventoryCycle();
                UpdateItemCycleImages();
            }
        }

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

            }
        }
    }

    protected override void Update(Time time)
    {
        player.UpdateCreature(time);
        enemies.ForEach(e => e.UpdateCreature(time));
        base.Update(time);
    }
}