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

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

/* Tässä on jotain dokumentaation tapaista:
 * 
 * Layerit
 *   3 - Kaivuunuoli ja partikkeliefektit
 *   2 - Partikkelien varjot
 *   1 - Huoneiden katto
 *   0 - Huoneiden seinät ja barbaarit
 *  -1 - Päivitykset
 *  -2 - Huone (eli lattiat siis)
 *  
 * Ideoita:
 *  - Pahempia vihollisia, joihin ei tehoa piikkiansat
 *    vaan pitää ostaa kalliimpia ansoja niitä varten.
 *  - Kultuurihuoneita, jotka tuottavat eriäviä määriä
 *    kultuuria tai kestävät yhden barbaarin iskun.
*/

/// <summary>
/// Päivitys joka voi olla huoneessa.
/// </summary>
public abstract class Upgrade : GameObject
{
    public int Price { get; set; }

    public SoundEffect HajotusAani { get; set; }

    protected Upgrade()
        : base(Dungeon.RUUDUN_KOKO, Dungeon.RUUDUN_KOKO)
    {
    }

    /// <summary>
    /// Tätä kutsutaan kun päivitys on rakennettu huoneeseen.
    /// </summary>
    public virtual void Built(Dungeon peli) { }

    /// <summary>
    /// Tätä kutsutaan kun barbaari tulee kylään.
    /// </summary>
    public virtual void Invasion(Dungeon peli, Barbaari barbaari, Room huone) { }

    /// <summary>
    /// Kutsutaan joka syklin alussa.
    /// </summary>
    public virtual void SykliPaivitys() { }
}

class TrapUpgrade : Upgrade
{
    public int Damage { get; set; }

    public bool Active
    {
        get { return LatausMittari.Value == LatausMittari.MaxValue; }
    }

    // Jos täynnä, niin ansa on aktiivinen.
    public IntMeter LatausMittari { get; set; }

    public TrapUpgrade()
    {
        LatausMittari = new IntMeter(4, 0, 4);
        LatausMittari.UpperLimit += delegate
        {
            // Askelletaan vikasta framesta ekaan.
            Animation.Step();
        };
    }

    public override void Invasion(Dungeon peli, Barbaari barbaari, Room huone)
    {
        if (!Active) return;

        barbaari.Tenacity.Value -= ((TrapUpgrade)(huone.Upgrade)).Damage;

        peli.Splatter(huone.Position);

        // Barbaarin tappo pudottaa latausmittarin nollaan.
        LatausMittari.Value = LatausMittari.MinValue;

        Animation.StopOnLastFrame = true;
        Animation.Start(1);
    }

    public override void SykliPaivitys()
    {
        base.SykliPaivitys();
        if (LatausMittari.Value < LatausMittari.MaxValue)
        {
            LatausMittari.Value++;
        }
    }
}

class CultureUpgrade : Upgrade
{
    // Tämän päivityksen antama kultuurin määrä.
    public IntMeter Culture { get; set; }
    public int Max { get; set; } //Kultuurimittarin maksimiarvo

    // Label joka näyttää päivityksen antaman kultuurin määrän.
    public Label KultuuriNaytto { get; set; }

    public override void Built(Dungeon peli)
    {
        base.Built(peli);

        Culture = new IntMeter(0, 0, Max);

        // Luodaan kultuurin ilmaisin.
        KultuuriNaytto = new Label("asd");
        KultuuriNaytto.TextColor = Color.HotPink;
        KultuuriNaytto.Color = Color.Black;
        KultuuriNaytto.Position = peli.Camera.WorldToScreen(this.Position + new Vector(0, Dungeon.RUUDUN_KOKO * 0.5));
        KultuuriNaytto.BindTo(Culture);
        peli.Add(KultuuriNaytto);

        // Näytetään kultuurin määrä kun hiiri on päivityksen päällä.
        var kuuntelija = peli.Mouse.ListenMovement(0.1, _ => KultuuriNaytto.IsVisible = peli.Mouse.IsCursorOn(this), null);

        this.Destroyed += delegate
        {
            KultuuriNaytto.Destroy();
            kuuntelija.Destroy();
        };
    }

    public override void Invasion(Dungeon peli, Barbaari barbaari, Room huone)
    {
        this.Destroy();
        huone.Upgrade = null;
        if (HajotusAani != null)
        {
            HajotusAani.Play();
        }
        if (peli.KultuuriHuoneidenPaikat().Count < 1)
        {
            peli.LopetaPeli();
        }
    }
}

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

    // Huoneen sisältämä päivitys.
    public Upgrade Upgrade { 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 class Barbaari : GameObject
{
    public List<Point> Reitti { get; set; }

    public Point Kohde { get; set; }

    public Point Location { get; set; }

    public IntMeter Tenacity { get; set; }

    public Barbaari(double width, double height)
        : this(width, height, 0, new Image[1])
    {
        Reitti = new List<Point>();
    }

    public Barbaari(double width, double height, int tenacity, Image[] animaatio)
        : base(width, height)
    {
        this.Animation = new Animation(animaatio) { FPS = 8 };
        this.Tenacity = new IntMeter(tenacity, 0, 2);

    }
}

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

    public static Func<int, int, string, Image[]> LoadImages2 = (a, b, fmt) =>
        LoadImages((from i in Enumerable.Range(a, b) select string.Format(fmt, i)).ToArray());

    #region Kuvat
    Image lattiaKuva = LoadImage("floor");
    Image seinaKuva = LoadImage("wall");
    Image reikaSeinaKuva = LoadImage("wallhole");
    Image kiviKuva = LoadImage("rock");
    private Image[][] kultuuriKuvat = {LoadImages2(1, 6, "fountain/f{0:0000}"), LoadImages("patsas"), LoadImages("piano")};
    private Image[] piikkiAnsaKuvat = LoadImages2(1, 7, "piikit/piikit{0:0000}");
    private Image[] murskausAnsaKuvat = LoadImages2(1, 9, "smash/smash{0:0000}");
    public Image[] vihuKuvat = LoadImages2(1, 10, "vihu/v{0:0000}");
    public Image[] kirvesVihuKuvat = LoadImages2(1, 10, "kirvesvihu/kv{0:0000}");
    Image[] ansaKuvat;
    List<Animation> ansaAnimaatiot = new List<Animation>();
    Image partikkeliKuva = LoadImage("partikkeli");
    Image taideVeri = LoadImage("taideveri");
    private Image[] loppuKuvat = LoadImages2(1, 35, "break/b{0:0000}");
    #endregion

    private SoundEffect[] hajotusAanet = { LoadSoundEffect("fountainbreak"), LoadSoundEffect("boom"), LoadSoundEffect("piano2") };

    int[] hinnat = { 75, 200, 300, 100 };
    int[] vahingot = { 1, 2 };
    int[] ansaHinnat = { 300, 600 };
    int[] kultuuriTuotot = { 100, 200, 400 };
    private int barbaariMaara = 2;

    private Label kaivuuHintaLabel;
    private Label kierrosIlmaisin;
    //private bool kierrosKaynnissa;
    private int kierros;

    public int KierrosKaynnissa
    {
        get
        {
            return kierros;
        }
        set
        {
            kierros = value;
            kierrosIlmaisin.Text = "Vaihe: " + (kierros % 2 == 0 ? "Barbaari-invaasio" : "Rakennusvaihe");
        }
    }

    Room[,] huoneet;
    //public List<Room> kohteet = new List<Room>();
    public List<Barbaari> barbaarit;
    Room spawn;
    Timer barbaariAjastin;
    Timer sykliAjastin;
    Upgrade ostamassa;
    Point digStart; // Huoneen sijainti, josta kaivuu aloitetaan.

    private bool digging = false;

    public bool Digging
    {
        get
        {
            return digging;
        }
        set
        {
            digging = value;
            kaivuuHintaLabel.IsVisible = Digging;
        }
    }

    GameObject digArrow;
    GameObject digArrowHead;

    IntMeter kultuuri = new IntMeter(0, 0, 2000);

    const int MASSI = 2000;
    const int VAAKA_HUONEET = 12;
    const int PYSTY_HUONEET = 8;
    const int HUONE_KAIVUU_HINTA = 50;

    // Paljonko peliruudukko on siirtynyt origosta.
    Vector huoneSiirtyma = new Vector(-200, 0);

    private MainMenu menu;

    public override void Begin()
    {
        ClearAll();

        kultuuri.Value = MASSI;
        kierros = 0;
        barbaariAjastin = new Timer();
        barbaarit = new List<Barbaari>();

        SmoothTextures = false;
        IsMouseVisible = true;

        //SetWindowSize(1024, 768); // Riippuu Jypelin versiosta.
        Window.Width = 1024;
        Window.Height = 768;

        ansaKuvat = new Image[] { piikkiAnsaKuvat[0], murskausAnsaKuvat[0] };
        ansaAnimaatiot.Add(new Animation(piikkiAnsaKuvat));
        ansaAnimaatiot.Add(new Animation(murskausAnsaKuvat));
        menu = new MainMenu(this, "New game", "Highscores", "Help", "Quit");
        menu.Painikkeet[0].Clicked += delegate
        {
            AloitaPeli();
            menu = null;
        };
        menu.Painikkeet[3].Clicked += Exit;
    }

    void AloitaPeli()
    {
        ClearAll();
        MediaPlayer.Play("In_The_Dark_Flashes");
        Kontrollit();
        UlkoAsuRoskaa();
        Kauppa();
        Nuoli();

        // Luodaan huoneet ruutuihin.
        huoneet = new Room[VAAKA_HUONEET, PYSTY_HUONEET];
        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);
            Mouse.ListenOn(huone, MouseButton.Left, ButtonState.Pressed, AsetaPaivitys, "Asetetaan ostettu päivitys paikoilleen", huone);
            Mouse.Listen(MouseButton.Right, ButtonState.Pressed, delegate { ostamassa = null; }, "Perutaan ostos");
            Mouse.ListenOn(huone, MouseButton.Right, ButtonState.Pressed, PoistaPaivitys, "Poistetaan asetettu päivitys", huone);
            huoneet[paikka.X, paikka.Y] = huone;
        }

        LuoSpawn();

        sykliAjastin = new Timer { Interval = 1.0 };
        sykliAjastin.Timeout += Sykli;
        sykliAjastin.Start();

        barbaariAjastin.Timeout += LuoBarbaareja;
        barbaariAjastin.Interval = sykliAjastin.Interval;   //TODO: säätöjä tähän, barbaarien määrään ja superbarbaarien todennäköisyyteen, kunnes peli tuntuu mielekkäältä

        Level.Width = 1300;
        Camera.ZoomToLevel();
    }

    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;

        kierrosIlmaisin = new Label("asd");
        kierrosIlmaisin.TextColor = Color.White;
        kierrosIlmaisin.Y = Screen.Top - 150;
        Add(kierrosIlmaisin);
        KierrosKaynnissa = KierrosKaynnissa; // Aiheuttaa labelin päivittymisen.

        kaivuuHintaLabel = new Label("0");
        kaivuuHintaLabel.IsVisible = false;
        kaivuuHintaLabel.TextColor = Color.HotPink;
        kaivuuHintaLabel.Color = Color.Black;
        Add(kaivuuHintaLabel);

        Label rahat = new Label();
        rahat.BindTo(kultuuri);
        rahat.Position = new Vector(Screen.Right - 200, Screen.Bottom + 50);
        //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);
    }

    public void LopetaPeli()
    {
        ClearAll();
        Level.Background.Color = Color.Black;
        var patsas = new GameObject(400, 300);
        patsas.Image = loppuKuvat[0];
        patsas.Animation = new Animation(loppuKuvat) { FPS = 20, StopOnLastFrame = true };
        Add(patsas);

        Timer.SingleShot(3.0, delegate
        {
            patsas.Animation.Start(1);
            hajotusAanet[1].Play();
        });

        Label havisit = new Label("Hävisit muuten belin");
        havisit.TextColor = Color.Black;
        havisit.TextScale *= 3;
        havisit.Top = Screen.Top - 30.0;
        Add(havisit, 2);

        const double fadeAika = 5.0;
        var fadeAjastin = new Timer();
        fadeAjastin.Interval = 0.02;
        fadeAjastin.Timeout += delegate
        {
            havisit.TextColor = Color.Lerp(Color.Black, Color.White, fadeAjastin.SecondCounter.Value / fadeAika);
            if (fadeAjastin.SecondCounter.Value > fadeAika)
            {
                fadeAjastin.Stop();
            }
        };
        fadeAjastin.Start();

        Keyboard.Listen(Key.Escape, ButtonState.Pressed, delegate { ClearAll(); Begin(); }, null);
    }

    void Kauppa()
    {
        for (int i = 0; i < kultuuriKuvat.Length; i++)
        {
            PushButton kuva = new PushButton(kultuuriKuvat[i][0]);
            kuva.Size = new Vector(1, 1) * RUUDUN_KOKO;
            kuva.X = Window.ClientBounds.Width / 2 - 200;
            kuva.Y = Window.ClientBounds.Height / 2 - (100 + RUUDUN_KOKO * i);
            //kuva.Position = new Vector((Level.Right + Level.Width * 0.05), (Level.Top - Level.Height * 0.25 - (i * RUUDUN_KOKO)));
            //kuva.Position = new Vector(Window.ClientBounds.Right, 0);
            Add(kuva);

            int indeksi = i; // Alla oleva delegaatti vaatii uuden indeksi muuttujan toimiakseen.
            kuva.Clicked += delegate
            {
                ostamassa = LuoKultuuriPaivitys(kultuuriKuvat[indeksi], hinnat[indeksi], kultuuriTuotot[indeksi], hajotusAanet[indeksi]);   // TODO: tuotto[indeksi]
            };

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

        for (int i = 0; i < ansaKuvat.Length; i++)
        {
            PushButton kuva = new PushButton(ansaKuvat[i]);
            kuva.Size = new Vector(1, 1) * RUUDUN_KOKO;
            kuva.Color = Color.Gray;
            kuva.X = Window.ClientBounds.Width / 2 - 200;
            kuva.Y = Window.ClientBounds.Height / 2 - (100 + RUUDUN_KOKO * (kultuuriKuvat.Count() + i));
            //kuva.Position = new Vector((Level.Right + Level.Width * 0.05), (Level.Top - Level.Height * 0.25 - ((kultuuriKuvat.Count() + i) * RUUDUN_KOKO)));
            Add(kuva);

            int indeksi = i;
            kuva.Clicked += delegate
            {
                ostamassa = LuoAnsaPaivitys(ansaKuvat[indeksi], ansaHinnat[indeksi], ansaAnimaatiot[indeksi], vahingot[indeksi]);
            };

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

    private void LuoAnsaHuoneenPainike(Image image, int hinta, Animation animation, int paikka, int vahinko)
    {
        PushButton kuva = new PushButton(image);
        kuva.Size = new Vector(1, 1) * RUUDUN_KOKO;
        kuva.Color = Color.Gray;
        kuva.X = Window.ClientBounds.Width / 2 - 200;
        kuva.Y = Window.ClientBounds.Height / 2 - (100 + RUUDUN_KOKO * (kultuuriKuvat.Count() + paikka));
        //kuva.Position = new Vector((Level.Right + Level.Width * 0.05), (Level.Top - Level.Height * 0.25 - ((kultuuriKuvat.Count() + i) * RUUDUN_KOKO)));
        Add(kuva);

        kuva.Clicked += delegate
        {
            ostamassa = LuoAnsaPaivitys(image, hinta, animation, vahinko);
        };

        Add(new Label
        {
            Position = kuva.Position + new Vector((RUUDUN_KOKO * 1.2), 0),
            TextColor = Color.White,
            Text = hinta.ToString()
        });
    }



    Upgrade LuoAnsaPaivitys(Image kuva, int hinta, Animation animaatio, int vahinko)
    {
        return new TrapUpgrade
        {
            Image = kuva,
            Size = new Vector(0.5, 0.5) * RUUDUN_KOKO,
            Price = hinta,
            Damage = vahinko,
            Animation = new Animation(animaatio)
        };
    }

    Upgrade LuoKultuuriPaivitys(Image[] kuvat, int hinta, int kultuuriMaara, SoundEffect hajotusAani)
    {
        var upg = new CultureUpgrade();
        upg.HajotusAani = hajotusAani;
        upg.Image = kuvat[0];
        upg.Size = new Vector(0.7, 0.7)*RUUDUN_KOKO;
        upg.Price = hinta;
        upg.Max = kultuuriMaara;
        upg.Animation = new Animation(kuvat) { FPS = 10 };
        upg.Animation.Start();
        return upg;
    }

    void LuoBarbaareja()
    {
        Barbaari barbaari = ((RandomGen.NextInt((int)(kierros * 0.90)) + 3 > kierros) ? new Barbaari(RUUDUN_KOKO * 0.4, RUUDUN_KOKO * 0.4, 1, vihuKuvat) : new Barbaari(RUUDUN_KOKO * 0.4, RUUDUN_KOKO * 0.4, 2, kirvesVihuKuvat));
        barbaari.Tenacity.LowerLimit += delegate
        {
            barbaarit.Remove(barbaari);
            barbaari.Destroy();
        };
        //Barbaari barbaari = new Barbaari(RUUDUN_KOKO * 0.4, RUUDUN_KOKO * 0.4, 0);
        barbaari.Color = Color.Red;
        barbaari.Position = spawn.Position;
        barbaari.Location = spawn.Location;
        //barbaari.Animation = new Animation(vihuKuvat) { FPS = 10 };
        barbaari.Animation.Start();
        Add(barbaari);
        barbaarit.Add(barbaari);

        EtsiBarbaarinReitti(barbaari);
    }

    void EtsiBarbaarinReitti(Barbaari barbaari)
    {
        var kohteet = KultuuriHuoneidenPaikat();
        barbaari.Kohde = kohteet[RandomGen.NextInt(kohteet.Count)];
        barbaari.Reitti = FindPath(barbaari.Kohde, (barbaari.Location.Equals(spawn.Location)) ? spawn.Location : barbaari.Location);
    }

    public List<Point> KultuuriHuoneidenPaikat()
    {
        return RuutujenPaikat().Select(GetRoom).Where(r => r.Upgrade != null && r.Upgrade is CultureUpgrade).Select(r => r.Location).ToList();
    }

    void Sykli()
    {
        // Päivitetään huoneiden päivityksiä.
        RuutujenPaikat().Select(GetRoom).Where(r => r.Upgrade != null).ToList().ForEach(r => r.Upgrade.SykliPaivitys());

        // Päivitetään barbaareja.
        foreach (var barbaari in barbaarit)
        {
            if (barbaari.Reitti.Count == 0)
            {
                EtsiBarbaarinReitti(barbaari);  //Etsitään uusi reitti poiston sijaan.
                continue;
            }

            Point seuraavaPaikka = barbaari.Reitti[0];
            barbaari.Reitti.RemoveAt(0);
            Barbaari b = barbaari;
            barbaari.MoveTo(huoneet[seuraavaPaikka.X, seuraavaPaikka.Y].Position, 100, () => SyklinPaatteeksi(b, seuraavaPaikka));
        }

        // Tarkistetaan onko barbaariaalto jo ohi.
        if (KierrosKaynnissa % 2 == 0 && barbaarit.Count == 0 && barbaariAjastin.Times == barbaariAjastin.Times.MinValue)
        {
            KierrosKaynnissa++;

            // Annetaan pelaajalle kultuuripisteet.
            foreach (var huone in KultuuriHuoneidenPaikat().Select(GetRoom))
            {
                CultureUpgrade upg = huone.Upgrade as CultureUpgrade;
                if (upg == null)
                    continue;

                kultuuri.Value += upg.Culture;
                Label ilmoitus = new Label("+" + upg.Culture);
                ilmoitus.TextColor = Color.HotPink;
                ilmoitus.Color = Color.Black;
                ilmoitus.Position = Camera.WorldToScreen(huone.Position);
                Add(ilmoitus);

                double kohdeY = ilmoitus.Y + 50;
                var liikutusAjastin = new Timer();
                liikutusAjastin.Interval = 0.02;
                liikutusAjastin.Timeout += delegate
                {
                    ilmoitus.Y += (kohdeY - ilmoitus.Y) * 0.05;
                };
                liikutusAjastin.Start();

                ilmoitus.LifetimeLeft = TimeSpan.FromSeconds(2.0);
                ilmoitus.Destroyed += liikutusAjastin.Stop;
            }
        }
    }

    void SyklinPaatteeksi(Barbaari barbaari, Point uusiPaikka)
    {
        // Barbaari saapui juuri uusiPaikka kohdassa olevaan huoneeseen.
        // Tässä pitäisi katsoa mitä huoneessa tapahtuu.
        barbaari.Location = uusiPaikka;

        Room huone = huoneet[uusiPaikka.X, uusiPaikka.Y];

        if (huone.Upgrade != null)
        {
            huone.Upgrade.Invasion(this, barbaari, huone);
        }
    }

    void Kontrollit()
    {
        IsMouseVisible = true;
        //Keyboard.Listen(Key.Escape, ButtonState.Pressed, ConfirmExit, "Näytä valikko");
        //Keyboard.Listen(Key.F1, ButtonState.Pressed, Begin, null);
        Keyboard.Listen(Key.Escape, ButtonState.Pressed, delegate { ClearAll(); Begin(); }, "Aloita uudestaan");    //Ei toimi vielä

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

    void SeuraavaAalto()
    {
        if (KultuuriHuoneidenPaikat().Count == 0 || KierrosKaynnissa % 2 == 0) return;

        barbaariAjastin.Interval = RandomGen.NextInt((int)sykliAjastin.Interval, 3);
        barbaariAjastin.Start(barbaariMaara);
        barbaariMaara = RandomGen.NextInt((int)(1 + kierros * 0.20), kierros);
        KierrosKaynnissa++;
    }

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

        Direction oviSuunta = Direction.Down;
        spawn.Walls[oviSuunta].Image = reikaSeinaKuva;

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

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

        int dx = kohdeHuone.Location.X - digStart.X;
        int dy = kohdeHuone.Location.Y - digStart.Y;
        Point[] kaivettavatPaikat = RuudutSuoralta(digStart, dx, dy).ToArray();
        for (int i = 0; i < kaivettavatPaikat.Length - 1; i++)
        {
            Dig(GetRoom(kaivettavatPaikat[i]), GetRoom(kaivettavatPaikat[i + 1]));
        }

        // Päivitetään huoneiden kultuuri-infot.
        PaivitaHuoneidenKultuurit();
    }

    void Dig(Room alku, Room kohde)
    {
        // Hienot partikkeliefektit.
        if (!alku.Dug)
            LuoKiviPartikkelit(alku.Position);
        if (!kohde.Dug)
            LuoKiviPartikkelit(kohde.Position);

        // Merkataan huoneet kaivetuksi ja maksetaan siitä kivasti.
        alku.Dug = kohde.Dug = true;
        kultuuri.Value -= HUONE_KAIVUU_HINTA;

        // Reiät seinään.
        Direction oviSuunta = (kohde.Position - alku.Position).Angle.MainDirection;
        Direction toinenOviSuunta = Direction.Inverse(oviSuunta);
        alku.Walls[oviSuunta].Image = reikaSeinaKuva;
        kohde.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;
        huone.Position += huoneSiirtyma;
        foreach (var suunta in Suunnat())
            huone.Walls[suunta] = CreateWall(huone.Position, suunta);
        Add(huone, -2);
        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, AsetaPaivitys, "Asetetaan ostettu päivitys paikoilleen", huone);
        //Mouse.Listen(MouseButton.Right, ButtonState.Pressed, delegate { ostamassa = null; }, "Perutaan ostos");
        //Mouse.ListenOn(huone, MouseButton.Right, ButtonState.Pressed, PoistaPaivitys, "Poistetaan asetettu päivitys", huone);

        return huone;
    }

    private void PoistaPaivitys(Room huone)
    {
        if (huone.Upgrade != null)
        {
            kultuuri.Value += (int)(huone.Upgrade.Price * 0.5);
            huone.Upgrade.Destroy();
            huone.Upgrade = null;
        }
    }

    void AsetaPaivitys(Room huone)
    {
        if (ostamassa != null && huone.Dug && kultuuri.Value >= ostamassa.Price && huone.Upgrade == null && huone != spawn)
        {
            // Kultuuripäivityksistä pitää olla reitti spawniin.
            if (ostamassa is CultureUpgrade && FindPath(huone.Location, spawn.Location).Count == 0)
                return;

            kultuuri.Value -= ostamassa.Price;

            // Lisätään päivitys huoneeseen.
            huone.Upgrade = ostamassa;
            Add(huone.Upgrade, -1);
            huone.Upgrade.Position = huone.Position;
            huone.Upgrade.Built(this);

            ostamassa = null;
            PaivitaHuoneenKultuuri(huone);
        }
    }

    void PaivitaHuoneidenKultuurit()
    {
        RuutujenPaikat().Select(GetRoom).ToList().ForEach(PaivitaHuoneenKultuuri); // :D ;___;; MIKSI <- koska pystyn
    }

    void PaivitaHuoneenKultuuri(Room room)  //TODO: muokkauksia tuohon kultuurinarvonvaihtoon polun pituuden perusteella kunnes peli tuntuu oikeasti miellyttäviltä. 
    {
        if (room != null && room.Upgrade != null && room.Upgrade is CultureUpgrade)
        {
            var upg = room.Upgrade as CultureUpgrade;

            List<Point> polku = FindPath(room.Location, spawn.Location);
            upg.Culture.Value = Math.Max(0, upg.Culture.MaxValue - (int)(upg.Culture.MaxValue * 0.10 * polku.Count));
        }
    }

    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 || KierrosKaynnissa % 2 == 0)
        {
            return false;
        }

        int dx = Math.Abs(kohdeHuone.Location.X - digStart.X);
        int dy = Math.Abs(kohdeHuone.Location.Y - digStart.Y);
        int hinta = (dx + dy) * HUONE_KAIVUU_HINTA;
        kaivuuHintaLabel.Text = "" + hinta;
        return ((dx > 0 && dy == 0) || (dy > 0 && dx == 0)) && kultuuri.Value >= hinta;
    }

    #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(loppu, alku, 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);
    }

    /// <summary>
    /// Palauttaa ruutuja suoralta pätkältä dx ja dy verran alkaen pisteestä "alku".
    /// dx tai dy pitää olla nolla.
    /// </summary>
    IEnumerable<Point> RuudutSuoralta(Point alku, int dx, int dy)
    {
        if (dx != 0)
        {
            for (int i = 0; i < Math.Abs(dx) + 1; i++)
            {
                yield return new Point(alku.X + i * Math.Sign(dx), alku.Y);
            }
            yield break;
        }
        if (dy != 0)
        {
            for (int i = 0; i < Math.Abs(dy) + 1; i++)
            {
                yield return new Point(alku.X, alku.Y + i * Math.Sign(dy));
            }
        }
    }

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

    public void LuoLentavaPartikkeli(Vector alkupaikka, Image kuva, double koko, int maara, bool veri = false)
    {
        // Feikki 3D partikkeli juttu.
        // Heittää ilmaan GameObjekteja joiden alla on varjo.

        // VAROITUS: SISÄLTÄÄ JÄRKYTTÄVÄÄ KOODIA

        for (int i = 0; i < maara; i++)
        {
            GameObject partikkeli = new GameObject(koko, koko);
            partikkeli.Image = kuva;
            partikkeli.Position = alkupaikka + RandomGen.NextVector(0.0, RUUDUN_KOKO * 0.4);
            Add(partikkeli, 3);

            GameObject varjo = new GameObject(koko, koko / 2.0);
            varjo.Position = partikkeli.Position;
            varjo.Shape = Shape.Circle;
            varjo.Color = Color.Lerp(Color.Black, Color.Transparent, 0.5);
            Add(varjo, 2);

            Vector paikka = partikkeli.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;

            var verenLuontiAjastin = veri ? new Timer() : null;

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

                if (z < 0.0)
                {
                    ajastin.Stop();
                    partikkeli.Destroy();
                    varjo.Destroy();
                    if (verenLuontiAjastin != null)
                        verenLuontiAjastin.Stop();
                }
            };
            ajastin.Start();

            if (verenLuontiAjastin != null)
            {
                verenLuontiAjastin.Interval = 0.1;
                verenLuontiAjastin.Timeout += delegate
                {
                    GameObject veriPartikkeli = new GameObject(3, 3);
                    veriPartikkeli.Color = Color.DarkRed;
                    Add(veriPartikkeli, 2);

                    Vector veriPaikka = paikka;
                    double veriZ = z;
                    double veriVz = 0.0;

                    var veriPaivitysAjastin = new Timer();
                    veriPaivitysAjastin.Interval = 0.02;
                    veriPaivitysAjastin.Timeout += delegate
                    {
                        veriVz += g;
                        veriZ += veriVz;
                        veriPartikkeli.Position = veriPaikka + new Vector(0.0, 1.0) * veriZ;

                        if (veriZ < 0.0)
                        {
                            veriPaivitysAjastin.Stop();
                            veriPartikkeli.Destroy();
                        }
                    };
                    veriPaivitysAjastin.Start();
                };
                verenLuontiAjastin.Start();
            }
        }
    }

    void LuoKiviPartikkelit(Vector alkupaikka)
    {
        LuoLentavaPartikkeli(alkupaikka, partikkeliKuva, 25, 6);
    }

    public void Splatter(Vector alkupaikka)
    {
        LuoLentavaPartikkeli(alkupaikka, taideVeri, 8, 10, true);
    }

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

            kaivuuHintaLabel.Position = Camera.WorldToScreen(alku + suunta * 0.5 + new Vector(0, 30));
        }

        if (menu != null)
            menu.Update(time);
        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 = huoneSiirtyma + new Vector(points[i].X - huoneet.GetLength(0) / 2, points[i].Y - huoneet.GetLength(1) / 2) * RUUDUN_KOKO;
            Vector v2 = huoneSiirtyma + 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);
    }
    */

    #endregion
}