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

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;
    List<StoryItem> storyItems = new List<StoryItem>();

    private bool canUseExit = true;
    private bool woodDestroyed = false;

    public IntMeter BossHealth;
    private List<Vector> bossSpawnPositions = new List<Vector>();

    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 SoundEffect EnemyDieSound = LoadSoundEffect("enemydie");
    public static SoundEffect ChestOpenSound = LoadSoundEffect("chestopen2");

    public static Image GunImage = LoadImage("gun");
    public static Image BulletImage = LoadImage("bullet");
    public static Image LetterImage = LoadImage("letter");
    public static Image FenceImage = LoadImage("fence");
    public static Image FoodImage = LoadImage("food");
    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 MaskImage = LoadImage("helm");
    public static Image MaskLargeImage = LoadImage("helmlarge");
    public static Image GoldenHeartImage = LoadImage("goldenheart");
    public static Image ChestImage = LoadImage("chest");
    public static Image ChestOpenImage = LoadImage("chestopen");

    public static Image crackedWallImage = LoadImage("cracked");

    public static Image GrenadeBoxImage = LoadImage("grenadebox");
    public static Image AmmoBoxImage = LoadImage("ammobox");

    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("nwalkright")]
    internal Animation nWalkRight;
    [AssetName("nwalkright", mirror: true)]
    internal Animation nWalkLeft;
    [AssetName("nwalkup")]
    private Animation nWalkUp;
    [AssetName("nwalkdown")]
    private Animation nWalkDown;

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

    [AssetName("train")]
    private Animation trainAnimation;
    [AssetName("carriage")]
    private Animation carriageAnimation;

    [AssetName("smoke")]
    private Animation smokeAnimation;

    #endregion

    public override void Begin()
    {
        Mouse.IsCursorVisible = true;
        SmoothTextures = false;
        LoadAnimations();
        StartGame();
        BuildUI();
        Intro();
    }

    void Victory()
    {
        ClearAll();
        Level.Background.Color = Color.Black;

        var text = new Label("Voitit muutes belin."); // Tekstin voisi vaihtaa.
        text.TextColor = Color.White;
        Add(text);
    }

    void BuildUI()
    {
        BuildRightBar();
        BuildInventoryCycle();
        BuildHealthBar();
        UpdateItemCycleImages();
    }
    
    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 (storyItems.Count > i &&  storyItems[i] != null)
            {
                inner.Image = storyItems[i].InventoryImage;
                Mouse.ListenOn(inner, MouseButton.Left, ButtonState.Pressed, ShowTextItem, "View those precious memories", storyItems[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()
    {
        storyItems.Add(new StoryItem(new Queue<string>(new[] { "Oi, Alex",
        "",
        "Coyotes on a train.",
        "Coyotes on a train, that's all I'm sayin'",
        "-Gabriel"
        }), LetterImage));

        ShowTextItem(storyItems[0]);
    }

    void ShowTextItem(StoryItem item)
    {
        viewing = true;
        messagesviewed = new Queue<string>(item.Message);
        
        Level.AmbientLight -= 0.75;

        frame = new GameObject(item.InventoryImage) { Width = Window.Width * 0.25, Height = Window.Height * 0.25, Position = Camera.Position };
        Add(frame, 2);

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

    }

    /// <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.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.Inventory.Add(new Monocle(player));
        
        //player.Sword = new Sword(player);
        //player.Inventory.Add(new Pistol(player));
        //player.Inventory.Add(new Grenade(player));

        player.Health.Value = 5;
        //player.Health.Value = player.Health.MaxValue = 100;

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

        AddCollisionHandler(player, "ammobox", delegate(PhysicsObject p, PhysicsObject box)
        {
            box.Destroy();
            var gun = player.Inventory.FirstOrDefault(i => i is Pistol);
            if (gun != null)
            {
                gun.Usages.Value += 5;
            }
        });

        AddCollisionHandler(player, "grenadebox", delegate(PhysicsObject p, PhysicsObject box)
        {
            box.Destroy();
            var grenades = player.Inventory.FirstOrDefault(i => i is Grenade);
            if (grenades != null)
            {
                grenades.Usages.Value += 5;
            }
        });

        AddCollisionHandler(player, "storyTime", StoryTime);

        AddCollisionHandler(player, "pistol", delegate(PhysicsObject p, PhysicsObject item)
        {
            item.Destroy();
            player.Inventory.Add(new Pistol(player));
            UpdateItemCycleImages();
        });

        AddCollisionHandler(player, "grenade", delegate(PhysicsObject p, PhysicsObject item)
        {
            item.Destroy();
            player.Inventory.Add(new Grenade(player));
            UpdateItemCycleImages();
        });

        AddCollisionHandler(player, "mask", delegate(PhysicsObject p, PhysicsObject item)
        {
            item.Destroy();
            player.Inventory.Add(new Mask(player));
            UpdateItemCycleImages();
        });

        AddCollisionHandler(player, "chest", delegate(PhysicsObject p, PhysicsObject chest)
        {
            // Arkusta saa nyt aina uuden sydämen.
            ChestOpenSound.Play();
            chest.Tag = null;

            Timer.SingleShot(1.0, delegate
            {
                chest.Image = ChestOpenImage;

                var heart = PhysicsObject.CreateStaticObject(20, 20);
                heart.IgnoresCollisionResponse = true;
                heart.Image = GoldenHeartImage;
                heart.Position = chest.Position;
                heart.Velocity = new Vector(0, 14);
                heart.LifetimeLeft = TimeSpan.FromSeconds(2.0);
                Add(heart, 3);

                player.Health.Value++;
            });
        });
    }

    void StoryTime(PhysicsObject pPlayer, PhysicsObject storyBlock)
    {
        storyItems.Add(new StoryItem(new Queue<string>(new[] { "Oi, boy!",
            "There something wrong with your head?",
            "It's dangerous out there - you did see the coyotes, right?",
            "",
            "Just... take this.",
            "You've used a sword before, right?",
            "",
            "-Hobo in a cave"
        }), FoodImage));

        storyBlock.Tag = "none";
        storyBlock.IgnoresCollisionResponse = true;

        if (player.Sword == null)
        {
            player.Sword = new Sword(player);
            UpdateItemCycleImages();
        }

        ShowTextItem(storyItems[1]);
        BuildRightBar();
    }

    void UseItem(Item item, Item otherItem, Action action)
    {
        if (player.IsDestroyed)
            return;

        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.Sword != null)
        {
            swordItem.Image = BigSwordImage;
        }
    }

    void CollidesWithEnemy(PhysicsObject player, PhysicsObject enemy)
    {

    }

    /*
    void CollidesWithExit(PhysicsObject pPlayer, PhysicsObject pExit)
    {
        var oldExit = pExit as Exit;
        if (oldExit == null || oldExit.TargetLevel == null || pExit.IsDestroying || pExit.IsDestroyed)
            return;

        enemies.Clear();
        ClearAll();

        CreateLevel(oldExit.TargetLevel);
        var targetExit = exits.FirstOrDefault(e => e.Name == oldExit.TargetExitName);
        
        BuildUI();
        SetControls();
        player.Position = targetExit.Position + Direction.Inverse(targetExit.Position.Angle.MainDirection).GetVector() * TILE_SIZE * 2;
        Add(player);
    }
     */

    void CollidesWithExit(PhysicsObject pPlayer, PhysicsObject pExit)
    {
        if (!canUseExit)
            return;

        canUseExit = false;
        Timer.SingleShot(2, () => canUseExit = true);

        var oldExit = pExit as Exit;
        if (oldExit == null || transition || oldExit.TargetLevel == null || pExit.IsDestroying || pExit.IsDestroyed)
            return;

        oldExit.Destroy();

        var oldExitDirection = GetExitDirection(oldExit);
        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 || oldExitDirection == Direction.None)
        {
            transition = false;
            oldObjects.ForEach(o => o.Destroy());
            oldObjects.Clear();

            BuildUI();

            // Yritetään päätellä pelaajalle joku järkevä paikka.
            player.Position = targetExit.Position + Direction.Inverse(targetExit.Position.Angle.MainDirection).GetVector() * TILE_SIZE * 4;
            
            //Camera.Follow(player);
            //Camera.ZoomFactor = 2.0;
            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;
        player.Position = targetExit.Position + Direction.Inverse(targetExit.Position.Angle.MainDirection).GetVector() * TILE_SIZE * 2;

        // 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.Follow(player);
        //Camera.ZoomFactor = 2.0;
        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 = 400.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();

                BuildUI();
            }
        }

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