source: 2015/24/ohjaajat/Dungeon/Dungeon/Dungeon/Dungeon.cs @ 6004

using System;
using System.Linq;
using System.Collections.Generic;
using Jypeli;
using Jypeli.Assets;
using Jypeli.Controls;
using Jypeli.Effects;
using Jypeli.Widgets;
using Point = Microsoft.Xna.Framework.Point;

class Room : GameObject
{
    // Sijainti pelin ruudukossa.
    public Point Location { get; set; }

    // Päällä näkyvä "katto" kun huone ei ole vielä kaivettu.
    public GameObject Roof { get; set; }

    // Neljä seinää, jotka on GameObjekteja.
    public Dictionary<Direction, GameObject> Walls { get; set; }

    public String Type { get; set; }

    public int Damage { get; set; }

    public int Culture { get; set; }

    private bool dug; // Onko huone kaivettu?
    public bool Dug
    {
        get { return dug; }
        set
        {
            dug = value;
            Roof.IsVisible = !Dug;
        }
    }

    public Room(Point paikka)
        : base(Dungeon.RUUDUN_KOKO, Dungeon.RUUDUN_KOKO)
    {
        Walls = new Dictionary<Direction, GameObject>();
        Location = paikka;
    }

    public int Price { get; set; }

}

public class Dungeon : PhysicsGame
{
    public const int RUUDUN_KOKO = 64;

    #region Kuvat
    Image lattiaKuva = LoadImage("floor");
    Image seinaKuva = LoadImage("wall");
    Image reikaSeinaKuva = LoadImage("wallhole");
    Image kiviKuva = LoadImage("rock");
    static Image kulttuuriKuva1 = LoadImage("es");
    static Image kulttuuriKuva2 = LoadImage("nyan");
    static Image kulttuuriKuva3 = LoadImage("spurdo");
    Image[] huoneKuvat = new Image[] { kulttuuriKuva1, kulttuuriKuva2, kulttuuriKuva3 };
    Image[] vihuKuvat = LoadImages((from i in Enumerable.Range(1, 10) select String.Format("v{0:0000}", i)).ToArray());
    Image partikkeli = LoadImage("partikkeli");
    #endregion

    int[] hinnat = new int[] { 100, 200, 300 };
    private int barbaariMaara = 3;

    Room[,] huoneet;
    Room spawn;
    Timer barbaariAjastin = new Timer();
    Room ostettu;
    Point digStart; // Huoneen sijainti, josta kaivuu aloitetaan.
    bool digging = false;

    GameObject digArrow;
    GameObject digArrowHead;

    IntMeter kulttuuri = new IntMeter(300, 0, 2000);

    int vaakaHuoneet = 12;
    int pystyHuoneet = 8;

    public override void Begin()
    {
        ClearAll();
        Kontrollit();
        UlkoAsuRoskaa();
        Kauppa();
        Nuoli();

        // Luodaan huoneet ruutuihin.
        huoneet = new Room[vaakaHuoneet, pystyHuoneet];
        foreach (var paikka in RuutujenPaikat())
        {
            var huone = CreateRoom(paikka);
            Mouse.ListenOn(huone, MouseButton.Left, ButtonState.Pressed, () => RoomPressed(huone), null);
            Mouse.ListenOn(huone, MouseButton.Left, ButtonState.Released, () => RoomReleased(huone), null);
            huoneet[paikka.X, paikka.Y] = huone;
        }

        LuoSpawn();

        barbaariAjastin.Timeout += delegate { LuoBarbaareja(); };
        barbaariAjastin.Interval = 3;
    }

    void Nuoli()
    {
        digArrow = new GameObject(5, 5);
        digArrowHead = new GameObject(15, 15);
        digArrowHead.Shape = Shape.Triangle;
        digArrowHead.IsVisible = digArrow.IsVisible = false;
        Add(digArrow, 3);
        Add(digArrowHead, 3);
    }

    void UlkoAsuRoskaa()
    {
        Level.Background.Color = Color.Black;

        Label rahat = new Label();
        rahat.BindTo(kulttuuri);
        rahat.Position = new Vector(Level.Right + Level.Width * 0.2, Level.Bottom + Level.Height * 0.1);
        rahat.TextColor = Color.White;
        rahat.IntFormatString = "Käytettävää kulttuuria: {0:D3}";
        Add(rahat);
    }

    void Kauppa()
    {
        for (int i = 0; i < huoneKuvat.Length; i++)
        {
            Point lokaatio = new Point(0, 0);

            Room kuva = new Room(lokaatio);
            kuva.Position = new Vector((Level.Right + Level.Width * 0.05), (Level.Top - Level.Height * 0.25 - (i * RUUDUN_KOKO)));
            kuva.Image = huoneKuvat[i];
            kuva.Price = hinnat[i];
            Add(kuva);

            Mouse.ListenOn(kuva, MouseButton.Left, ButtonState.Pressed, delegate(Room a) { ostettu = a; }, "Asetetaan ostettu huone paikoilleen", kuva);

            Label teksti = new Label();
            teksti.Position = kuva.Position + new Vector((RUUDUN_KOKO * 1.2), 0);
            teksti.TextColor = Color.White;
            teksti.Text = hinnat[i].ToString();
            Add(teksti);
        }
    }

    void LuoBarbaareja()
    {
        PhysicsObject barbaari = new PhysicsObject(RUUDUN_KOKO * 0.4, RUUDUN_KOKO * 0.4);
        barbaari.Color = Color.Red;
        //barbaari.Position = RandomGen.NextVector(Level.Right, Level.Bottom, Level.Left, Level.Top);
        barbaari.Position = spawn.Position;
        barbaari.Animation = new Animation(vihuKuvat);
        barbaari.Animation.FPS = 10;
        barbaari.Animation.Start();
        Add(barbaari);
    }

    void Kontrollit()
    {
        IsMouseVisible = true;
        Keyboard.Listen(Key.Escape, ButtonState.Pressed, ConfirmExit, "Lopeta peli");
        Keyboard.Listen(Key.F1, ButtonState.Pressed, Begin, null);

        Keyboard.Listen(Key.Space, ButtonState.Pressed, SeuraavaAalto, "Anna kivan barbaariaallon tulla");
    }

    void SeuraavaAalto()
    {
        barbaariMaara += 2;
        barbaariAjastin.Start(barbaariMaara);
    }

    void LuoSpawn()
    {
        spawn = huoneet[(int)(huoneet.GetLength(0) * 0.5), 0];
        spawn.Dug = true;

        Direction oviSuunta = ((spawn.Position - new Vector(0, RUUDUN_KOKO * 0.5)).Angle.MainDirection);
        spawn.Walls[oviSuunta].Image = reikaSeinaKuva;

        Light valo = new Light();
        valo.Position = spawn.Position;
        valo.Intensity = 1;
        valo.Distance = 40;
        Add(valo);
        
    }

    void LuoKiviPartikkelit(Vector alkupaikka)
    {
        /*  Ei toimi koska jää huoneiden kattojen alle.
        ExplosionSystem rajahdys = new ExplosionSystem(LoadImage("partikkeli"), 200);
        Add(rajahdys);
        rajahdys.AddEffect(paikka.X, paikka.Y, 20);
         */

        // Feikki 3D partikkeli juttu.
        // Heittää ilmaan GameObjekteja joiden alla on varjo.
        for (int i = 0; i < 6; i++)
        {
            GameObject p = new GameObject(25, 25);
            p.Image = partikkeli;
            p.Position = alkupaikka + RandomGen.NextVector(0.0, RUUDUN_KOKO * 0.4);
            Add(p, 3);

            GameObject varjo = new GameObject(20, 10);
            varjo.Position = p.Position;
            varjo.Shape = Shape.Circle;
            varjo.Color = Color.Lerp(Color.Black, Color.Transparent, 0.5);
            Add(varjo, 2);

            Vector paikka = p.Position;
            Vector nopeus = RandomGen.NextVector(0.2, 3.0);
            nopeus.Y *= 0.3;
            double g = -0.2; // painovoima
            double z = 0.0; // sijainti z-akselilla
            double vz = RandomGen.NextDouble(3.5, 4.5); // nopeus z-akselilla
            double angularVelocity = RandomGen.NextDouble(-1.0, 1.0) * 8;

            Timer ajastin = new Timer();
            ajastin.Interval = 0.02;
            ajastin.Timeout += delegate
            {
                vz += g;
                z += vz;
                paikka += nopeus;
                p.Position = paikka + new Vector(0.0, 1.0) * z;
                p.Angle += Angle.FromDegrees(angularVelocity);
                varjo.Position = paikka;

                if (z < 0.0)
                {
                    ajastin.Stop();
                    p.Destroy();
                    varjo.Destroy();
                }
            };
            ajastin.Start();
        }
    }

    void RoomPressed(Room huone)
    {
        digStart = huone.Location;
        digging = true;
        digArrowHead.IsVisible = digArrow.IsVisible = true;
    }

    void RoomReleased(Room kohdeHuone)
    {
        digging = false;
        digArrowHead.IsVisible = digArrow.IsVisible = false;
        if (CanDig()) 
        {
            var alkuHuone = huoneet[digStart.X, digStart.Y];

            // Hienot partikkeliefektit.
            if (!kohdeHuone.Dug)
                LuoKiviPartikkelit(kohdeHuone.Position);
            if (!alkuHuone.Dug)
                LuoKiviPartikkelit(alkuHuone.Position);

            // Merkataan huoneet kaivetuksi.
            kohdeHuone.Dug = alkuHuone.Dug = true;

            // Reiät seinään.
            Direction oviSuunta = (kohdeHuone.Position - alkuHuone.Position).Angle.MainDirection;
            Direction toinenOviSuunta = Direction.Inverse(oviSuunta);
            alkuHuone.Walls[oviSuunta].Image = reikaSeinaKuva;
            kohdeHuone.Walls[toinenOviSuunta].Image = reikaSeinaKuva;
        }
    }

    Room CreateRoom(Point paikka)
    {
        Room huone = new Room(paikka);
        huone.Image = lattiaKuva;
        huone.Position = new Vector(paikka.X - huoneet.GetLength(0) / 2, paikka.Y - huoneet.GetLength(1) / 2) * RUUDUN_KOKO;
        foreach (var suunta in Suunnat())
            huone.Walls[suunta] = CreateWall(huone.Position, suunta);
        Add(huone, -1);
        huone.Roof = new GameObject(RUUDUN_KOKO, RUUDUN_KOKO);
        huone.Roof.Image = kiviKuva;
        huone.Roof.Position = huone.Position;
        Add(huone.Roof, 1);

        Mouse.ListenOn(huone, MouseButton.Left, ButtonState.Pressed, AsetaHuone, "Asetetaan ostettu huone paikoilleen", huone);

        return huone;
    }

    void AsetaHuone(Room huone)
    {
        if(ostettu != null && huone.Dug && (kulttuuri.Value > huone.Price))
        {
            huone.Damage = ostettu.Damage;
            huone.Culture = ostettu.Culture;
            huone.Image = ostettu.Image;
            kulttuuri.Value -= ostettu.Price;
            ostettu = null;
        }
    }

    GameObject CreateWall(Vector paikka, Direction suunta)
    {
        GameObject wall = new GameObject(RUUDUN_KOKO + 2, RUUDUN_KOKO + 2);
        wall.Position = paikka;
        wall.Image = seinaKuva;
        wall.Angle = suunta.Angle;
        Add(wall, 0);
        return wall;
    }

    bool CanDig()
    {
        Room kohdeHuone = GetRoom(MuunnaJypelista(Mouse.PositionOnWorld));
        if (kohdeHuone == null)
        {
            return false;
        }
        int dx = Math.Abs(kohdeHuone.Location.X - digStart.X);
        int dy = Math.Abs(kohdeHuone.Location.Y - digStart.Y);
        return dx + dy == 1;
    }

    protected override void Update(Time time)
    {
        if (digging)
        {
            Color vari = CanDig() ? Color.White : Color.Red;
            Vector alku = huoneet[digStart.X, digStart.Y].Position;
            Vector loppu = Mouse.PositionOnWorld;
            Vector suunta = loppu - alku;
            double pituus = suunta.Magnitude;
            if (pituus <= 2) pituus = 2;

            digArrow.Color = vari;
            digArrow.Position = alku + suunta * 0.5;
            digArrow.Angle = suunta.Angle;
            digArrow.Width = pituus;

            digArrowHead.Color = vari;
            digArrowHead.Position = alku + suunta;
            digArrowHead.Angle = suunta.Angle - Angle.FromDegrees(90);
        }

        base.Update(time);
    }

    protected override void Paint(Canvas canvas)
    {
        canvas.BrushColor = Color.Purple;

        var points = FindPath(new Point(6, 0), MuunnaJypelista(Mouse.PositionOnWorld));
        for (int i = 0; i < points.Count - 1; i++)
        {
            Vector v = new Vector(points[i].X - huoneet.GetLength(0) / 2, points[i].Y - huoneet.GetLength(1) / 2) * RUUDUN_KOKO;
            Vector v2 = new Vector(points[i+1].X - huoneet.GetLength(0) / 2, points[i+1].Y - huoneet.GetLength(1) / 2) * RUUDUN_KOKO;
            canvas.DrawLine(v, v2);
        }

        base.Paint(canvas);
    }

    #region Reitinlöytö

    List<Point> FindPath(Point alku, Point loppu)
    {
        if (GetRoom(alku) == null || GetRoom(loppu) == null)
            return new List<Point>();

        bool[,] walkable = new bool[huoneet.GetLength(0), huoneet.GetLength(1)];
        foreach (var paikka in RuutujenPaikat())
        {
            walkable[paikka.X, paikka.Y] = huoneet[paikka.X, paikka.Y].Dug;
        }
        var finder = new AStar.PathFinder(new AStar.SearchParameters(alku, loppu, walkable), OviTarkistus);
        return finder.FindPath();
    }

    bool OviTarkistus(Point a, Point b)
    {
        Room ra = GetRoom(a);
        Room rb = GetRoom(b);
        Direction suunta = (new Vector(b.X, b.Y) - new Vector(a.X, a.Y)).Angle.MainDirection;
        if (ra != null && rb != null)
        {
            return ra.Walls[suunta].Image == reikaSeinaKuva && rb.Walls[Direction.Inverse(suunta)].Image == reikaSeinaKuva;
        }
        return false;
    }

    #endregion

    #region Extra Juttuja

    IEnumerable<Direction> Suunnat()
    {
        yield return Direction.Left;
        yield return Direction.Right;
        yield return Direction.Up;
        yield return Direction.Down;
    }

    IEnumerable<Point> RuutujenPaikat()
    {
        return from y in Enumerable.Range(0, huoneet.GetLength(1))
               from x in Enumerable.Range(0, huoneet.GetLength(0))
               select new Point(x, y);
    }

    Room GetRoom(Point paikka)
    {
        if (paikka.X >= 0 && paikka.X < huoneet.GetLength(0) && paikka.Y >= 0 && paikka.Y < huoneet.GetLength(1))
        {
            return huoneet[paikka.X, paikka.Y];
        }
        return null;
    }

    /// <summary>
    /// Muuntaa Jypeli-koordinaatin peliruudukon koordinaatiksi.
    /// </summary>
    Point MuunnaJypelista(Vector paikka)
    {
        Vector siirrettyOrigo = paikka + RUUDUN_KOKO * (0.5 * new Vector(huoneet.GetLength(0), huoneet.GetLength(1)) + new Vector(0.5, 0.5));
        Vector wtf = new Vector(siirrettyOrigo.X < 0 ? -1 : 0, siirrettyOrigo.Y < 0 ? -1 : 0);
        Vector valmis = wtf + siirrettyOrigo / RUUDUN_KOKO;
        return new Point((int)valmis.X, (int)valmis.Y);
    }

    #endregion
}