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

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

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

        GameObject[][] pelikentta;
        TetrisPalikka aktiivinenPalikka;

        Timer tiputusajastin;
        double vaikeusaste = 0.9 ;

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

        /*
         * Introon tarvittavat muuttujat
         */
        Timer introajastin;
        private int indeksi = 0;
        private int suunta = 1;
        private int vaihtoCounter = 0;

        /// <summary>
        /// Tekee pelin alkuvalmistelut
        /// </summary>
        protected override void Begin()
        {
            LuoPelikentta();
            AlkuIntro();
            AsetaMenuNappaimet();
            //LuoHud();
            //AsetaPeliNappaimet();
            //KaynnistaPeli();
        }

        /// <summary>
        /// Käynnistää alkuintron
        /// </summary>
        void AlkuIntro()
        {
            introajastin = new Timer();
            introajastin.Interval = 0.05;
            introajastin.Trigger += IntroPyoritys;
            introajastin.Start();
        }

        /// <summary>
        /// Pyörittää introa
        /// </summary>
        /// <param name="ajastin">Ei käytössä</param>
        void IntroPyoritys(Timer ajastin)
        {
            TuhoaRivi(korkeus-1);

            Color randomvari = RandomGen.NextColor();

            for (int i = 0; i < pelikentta[0].Length; i++)
            {
                pelikentta[0][i].Color = randomvari;
            }
            pelikentta[0][indeksi].Color = Color.Brown;
            indeksi += suunta;
            vaihtoCounter++;
            if (indeksi > leveys-1 && suunta > 0)
            {
                indeksi = 0;
            }
            if (indeksi < 0 && suunta < 0)
            {
                indeksi = leveys - 1;
            }
            if (vaihtoCounter > 50)
            {
                vaihtoCounter = 0;
                suunta = -suunta;
            }
        }

        /// <summary>
        /// Käynnistää pelin
        /// 
        /// Luo ensimmäisen palikan ja tekee ajastimen.
        /// Tuhoaa myös kaikki valmiina olevat palikat.
        /// 
        /// Poistaa asetetut kontrollit ja asettaa pelikontrollit.
        /// 
        /// Resetoi vaikeusasteen!
        /// </summary>
        void KaynnistaPeli()
        {
            introajastin.Stop();
            TuhoaKaikki();
            ClearControls();
            AsetaPeliNappaimet();

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

        /// <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 pelin aikana tarvittavat näppäimet.
        /// </summary>
        void AsetaPeliNappaimet()
        {
            Vector vasemmalle = new Vector(-1, 0);
            Vector oikealle = new Vector(1, 0);
            Vector alas = new Vector(0, 1);

            Keyboard.Listen(Key.Escape, ButtonState.Pressed, PeliLoppui, "Keskeyttää pelin");
            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>
        /// Asettaa menuissa käytettävät näppäimet
        /// </summary>
        void AsetaMenuNappaimet()
        {
            Keyboard.Listen(Key.Escape, ButtonState.Pressed, Exit, "Poistuu pelistä");
            Keyboard.Listen(Key.F2, ButtonState.Pressed, KaynnistaPeli, "Aloittaa uuden pelin");
        }

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

            tiputusajastin.Reset();
            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()
        {
            TetrisPalikka palikka = aktiivinenPalikka;
            while (aktiivinenPalikka == palikka) Laske(tiputusajastin);
        }

        /// <summary>
        /// Tarkistaa, voiko palikalle suorittaa annetut siirrot
        /// 
        /// Annetut siirrot siis lisätään niitä vastaaviin palikan
        /// sijainteihin.
        /// </summary>
        /// <param name="siirrot">X- ja Y-arvot oltava kokonaislukuja</param>
        /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param>
        /// <returns>true, jos palikan siirtäminen on mahdollista</returns>
        bool VoikoSiirtaa(Vector[] siirrot, TetrisPalikka palikka)
        {
            Vector[] sijainnit = palikka.Sijainti();

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

        /// <summary>
        /// Tarkistaa voiko kaikkia palikan osia siirtää annetun
        /// vektorin verran
        /// </summary>
        /// <param name="siirto">X- ja Y-arvo oltava kokonaislukuja</param>
        /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param>
        /// <returns>true, jos siirto on mahdollinen</returns>
        bool VoikoSiirtaa(Vector siirto, TetrisPalikka 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(TetrisPalikka 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 TetrisPalikka(leveys / 2);
            tiputusajastin.Reset();

            Vector[] sijainnit = aktiivinenPalikka.Sijainti();
            for (int i = 0; i < sijainnit.Length; i++)
            {
                if (!OnkoTyhja(sijainnit[i]))
                {
                    PeliLoppui();
                    return;
                }
            }

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

        /// <summary>
        /// Lopettaa pelin.
        /// - Palikkoja ei tipu
        /// - Poistaa vanhat kontrollit
        /// - Asettaa menunapit toimintaan
        /// </summary>
        void PeliLoppui()
        {
            tiputusajastin.Stop();
            ClearControls();
            AsetaMenuNappaimet();
        }

    }
}