source: 2010/23/hniemi/JyTris/JyTris/Peli.cs @ 1480

using System;
using Jypeli;
using Jypeli.Widgets;
using Jypeli.Assets;

namespace JyTris
{

    /// <summary>
    /// JyTris
    /// 
    /// Peli on tetrisklooni, joka on tarkoituksena toteuttaa JyPelillä
    /// mahdollisimman yksinkertaisesti.
    /// 
    /// Seuraavana tulossa:
    /// - Lisääntyvät pisteet
    /// - Loput palikat
    /// </summary>
    public class Peli : Game
    {
        const int leveys = 10;
        const int korkeus = 26;
        const int palikkojenSivu = 30;

        GameObject[][] pelikentta;
        ITetrispalikka aktiivinenPalikka;

        Timer tiputusajastin;
        double vaikeusaste = 0.2;

        IntMeter pisteet = new IntMeter(0);
        Label pistenaytto;

        protected override void Begin()
        {
            LuoPelikentta();
            //LuoHud();
            AsetaNappaimet();
            KaynnistaPeli();
        }

        /// <summary>
        /// Käynnistää pelin
        /// 
        /// Luo ensimmäisen palikan ja tekee ajastimen.
        /// </summary>
        void KaynnistaPeli()
        {
            LuoPalikka();

            tiputusajastin = new Timer();
            tiputusajastin.Interval = vaikeusaste;
            tiputusajastin.Trigger += Laske;
            tiputusajastin.Start();
        }

        /// <summary>
        /// Tuhoaa täydet rivit kentältä
        /// </summary>
        void TuhoaTaydet()
        {
            bool tyhjia;

            for (int i = 0; i < pelikentta.Length; i++)
            {
                tyhjia = false;
                for (int j = 0; j < pelikentta[i].Length; j++)
                {
                    if (pelikentta[i][j].Color == Color.TransparentWhite) tyhjia = true;
                }

                if (!tyhjia)
                {
                    TuhoaRivi(i);
                }
            }
        }

        /// <summary>
        /// Tuhoaa kaikki palikat kentältä.
        /// </summary>
        void TuhoaKaikki()
        {
            //Tässä käydään lävitse kaikki laatikot ja asetetaan ne läpinäkyviksi.
            for (int i = 0; i < pelikentta.Length; i++)
            {
                for (int j = 0; j < pelikentta[i].Length; j++)
                {
                    pelikentta[i][j].Color = Color.TransparentWhite;
                }
            }
        }

        /// <summary>
        /// Tuhoaa indeksiä vastaavan rivin ja tiputtaa sen päällä olevia rivejä.
        /// </summary>
        /// <param name="rivinIndeksi">Tiputettavan rivin indeksi</param>
        void TuhoaRivi(int rivinIndeksi)
        {
            if (rivinIndeksi > pelikentta.Length || rivinIndeksi < 0) return;

            for (int i = rivinIndeksi; i > 0; i--)
            {
                for (int j = 0; j < pelikentta[i].Length; j++)
                {
                    pelikentta[i][j].Color = pelikentta[i - 1][j].Color;
                }
            }

            for (int i = 0; i < pelikentta[0].Length; i++)
            {
                pelikentta[0][i].Color = Color.TransparentWhite;
            }
        }

        void LuoHud()
        {
            pistenaytto = new Label(80, 20);
            pistenaytto.BindTo(pisteet);
            Add(pistenaytto);

            //pistenaytto.Position.X = Screen.RightSafe - 40;
        }

        /// <summary>
        /// Luo pelikentän ylhäällä määrätyistä vakioista
        /// </summary>
        void LuoPelikentta()
        {
            //Tässä säädetään pelialueen koko, jotta seinät tulevat oikeille kohdille
            Level.Width = leveys * palikkojenSivu;// + leveys;
            Level.Height = korkeus * palikkojenSivu;// + korkeus;
            Level.CreateBorders(true);

            /*
             * Koska pelikenttä on kaksiulotteinen taulukko, joudumme luomaan
             * ensiksi taulukon sarakkeet, jotta voimme luoda rivit.
             */
            pelikentta = new GameObject[korkeus][];
            for (int i = 0; i < pelikentta.Length; i++)
            {
                pelikentta[i] = new GameObject[leveys];
            }

            //Tässä luodaan pelikentän "laatiko" ja sijoitetaan ne oikeille kohdilleen.
            for (int i = 0; i < pelikentta.Length; i++)
            {
                for (int j = 0; j < pelikentta[i].Length; j++)
                {
                    pelikentta[i][j] = new GameObject(palikkojenSivu, palikkojenSivu, Shapes.Rectangle);
                    pelikentta[i][j].Color = Color.TransparentWhite;
                    pelikentta[i][j].X = Level.Left + (palikkojenSivu / 2) + j * (palikkojenSivu);
                    pelikentta[i][j].Y = Level.Top - (palikkojenSivu / 2) - i * (palikkojenSivu);
                    Add(pelikentta[i][j]);
                }
            }
        }

        /// <summary>
        /// Asettaa näppäimet.
        /// </summary>
        void AsetaNappaimet()
        {
            Vector vasemmalle = new Vector(-1, 0);
            Vector oikealle = new Vector(1, 0);
            Vector alas = new Vector(0, 1);

            Keyboard.Listen(Key.Left, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa vasemmalle", vasemmalle);
            Keyboard.Listen(Key.Right, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa oikealle", oikealle);
            Keyboard.Listen(Key.Down, ButtonState.Down, Laske, "Liikuttaa palikkaa alas", tiputusajastin);
            Keyboard.Listen(Key.Up, ButtonState.Pressed, Kaanna, "Kääntää palikkaa");
            Keyboard.Listen(Key.Space, ButtonState.Pressed, Tiputa, "Tiputtaa palikan");
        }

        /// <summary>
        /// Liikuttaa palikkaa halutun verran.
        /// </summary>
        /// <param name="suunta">X ja Y oltava kokonaislukuja.</param>
        void Liikuta(Vector suunta)
        {
            PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite);

            if (VoikoSiirtaa(suunta, aktiivinenPalikka))
            {
                aktiivinenPalikka.Liikuta(suunta);
            }
            
            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
        }

        /// <summary>
        /// Kääntää palikkaa
        /// </summary>
        void Kaanna()
        {
            PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite);

            //Tämä kohta tarkistaa, voiko palikkaa kääntää
            //Jos ei voi, niin poistutaan.
            Vector[] tulevaSijainti = aktiivinenPalikka.TulevaKaanto();
            for (int i = 0; i < tulevaSijainti.Length; i++)
            {
                if (!OnkoTyhja(tulevaSijainti[i])) 
                {
                    PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
                    return;
                } 
            }

            aktiivinenPalikka.Kaanna();
            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
        }

        /// <summary>
        /// Laskee palikkaa yhdellä. Jos palikkaa ei voi laskea,
        /// lähettää uuden palikan.
        /// </summary>
        /// <param name="timer">Ei käytössä</param>
        void Laske(Timer timer)
        {
            PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite);

            if (!VoikoSiirtaa(new Vector(0,1), aktiivinenPalikka))
            {
                PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
                TuhoaTaydet();
                LuoPalikka();
                return;
            }
            aktiivinenPalikka.Liikuta(new Vector(0, 1));
            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());

        }

        /// <summary>
        /// Tiputtaa palikkan kokonaan alas.
        /// </summary>
        void Tiputa()
        {
            ITetrispalikka palikka = aktiivinenPalikka;
            while (aktiivinenPalikka == palikka) Laske(tiputusajastin);
        }

        bool VoikoSiirtaa(Vector[] siirrot, ITetrispalikka palikka)
        {
            Vector[] sijainnit = palikka.Sijainti();

            for (int i = 0; i < siirrot.Length; i++)
            {
                if (!OnkoTyhja(sijainnit[i] + siirrot[i])) return false;
            }
            return true;
        }

        bool VoikoSiirtaa(Vector siirto, ITetrispalikka palikka)
        {
            Vector[] siirrot = new Vector[4];
            for (int i = 0; i < siirrot.Length; i++)
            {
                siirrot[i] = siirto;
            }
            return VoikoSiirtaa(siirrot, palikka);
        }

        /// <summary>
        /// Tarkistaa, onko annetut paikka tyhjä
        /// 
        /// Paikka on tyhjä, jos sen väri on Color.TransparentWhite
        /// </summary>
        /// <param name="paikka">X ja Y oltava kokonaislukuja</param>
        /// <returns>true, jos paikka on tyhjä</returns>
        bool OnkoTyhja(Vector paikka)
        {
            if (paikka.X > leveys-1 || paikka.X < 0) return false;
            if (paikka.Y > korkeus-1 || paikka.Y < 0) return false;

            if (pelikentta[(int)paikka.Y][(int)paikka.X].Color == Color.TransparentWhite) return true;
            return false;
        }

        /// <summary>
        /// Värittää paikkaa vastaavat laatikot annetulla värillä
        /// </summary>
        /// <param name="palikka">Tämän sijainti väritetään</param>
        /// <param name="vari">Väri, jolla väritetään</param>
        void PaivitaPalikka(ITetrispalikka palikka, Color vari)
        {
            Vector[] sijainnit = palikka.Sijainti();

            for (int i = 0; i < sijainnit.Length; i++)
            {
                pelikentta[(int)sijainnit[i].Y][(int)sijainnit[i].X].Color = vari;
            }
        }

        /// <summary>
        /// Luo palikan keskelle ylälaitaa
        /// 
        /// Tulee antamaan satunnaisen palikan
        /// </summary>
        void LuoPalikka()
        {
            //aktiivinenPalikka = new Pitka(leveys / 2);
            //aktiivinenPalikka = new L(leveys / 2);
            aktiivinenPalikka = new J(leveys / 2);
            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
        }

    }
}