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

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

namespace JyTris
{
    /// <summary>
    /// JyTris 0.4
    /// 
    /// Peli on tetrisklooni, joka on tarkoituksena toteuttaa JyPelillä
    /// mahdollisimman yksinkertaisesti.
    /// 
    /// Seuraavana tulossa:
    /// - Kuvat palikoille
    /// - Efektit palikkojen tuhoutumiseen
    /// </summary>
    public class Peli : Game
    {
        #region Muuttujat
        private const string versio = "0.5";
        private const string file = "state.xml";

        private const int leveys = 10;
        private const int korkeus = 26;
        private const int palikkojenSivu = 30;

        //Pelikenttä
        private GameObject[][] pelikentta;
        private GameObject[][] ennustuskentta;

        private TetrisPalikka aktiivinenPalikka;
        private TetrisPalikka ennustusPalikka;

        private GameObject pausenappula;

        //Liikutusvektorit
        private Vector vasemmalle = new Vector(-1, 0);
        private Vector oikealle = new Vector(1, 0);
        private Vector alas = new Vector(0, 1);

        private Timer tiputusajastin;

        //Statistiikka
        private double vaikeusaste = 0.9;
        private IntMeter pisteet = new IntMeter(0);
        private IntMeter taso = new IntMeter(0);

        private int tuhotutRivit = 0;
        private int pelinTila = 0;

        //HighScoreList topLista;

        private Label tasonaytto;
        private Label pistenaytto;
        private Label status;

        /*
         * Introon tarvittavat muuttujat
         */
        private Timer introajastin;

        private int indeksi = 0;
        private int suunta = 1;
        private int vaihtoCounter = 0;
        #endregion
        #region Talletettavat
        /// <summary>
        /// Pelaajan pisteet
        /// </summary>
        public IntMeter Pisteet
        {
            get { return pisteet; }
            set { pisteet = value; }
        }

        /// <summary>
        /// Menossa oleva taso
        /// </summary>
        public IntMeter Taso
        {
            get { return taso; }
            set { taso = value; }
        }

        /// <summary>
        /// Tuhottujen rivien määrä
        /// </summary>
        public int TuhotutRivit
        {
            get { return tuhotutRivit; }
            set { tuhotutRivit = value; }
        }

        /// <summary>
        /// Pelikenttä
        /// </summary>
        public GameObject[][] Pelikentta
        {
            get { return pelikentta; }
            set { pelikentta = value; }
        }

        /// <summary>
        /// Palikka, joka tulee seuraavaksi
        /// </summary>
        public TetrisPalikka EnnustusPalikka
        {
            get { return ennustusPalikka; }
            set { ennustusPalikka = value; }
        }

        /// <summary>
        /// Ennustuskenttä, näyttää seuraavan palikan
        /// </summary>
        public GameObject[][] Ennustuskentta
        {
            get {
                return ennustuskentta; 
            }
            set { ennustuskentta = value; }
        }

        /// <summary>
        /// Aktiivinen palikka tällä hetkellä
        /// </summary>
        public TetrisPalikka AktiivinenPalikka
        {
            get { return aktiivinenPalikka; }
            set { aktiivinenPalikka = value; }
        }

        /// <summary>
        /// Pelin vaikeusaste tällä hetkellä
        /// </summary>
        public double Vaikeusaste
        {
            get { return vaikeusaste; }
            set { vaikeusaste = value; }
        }
        #endregion

        /// <summary>
        /// Tekee pelin alkuvalmistelut
        /// </summary>
        public override void Begin()
        {
            LuoPelikentta();
            AlkuIntro();
            AsetaMenuNappaimet();
            AsetaPistelista();
            LuoHud();
#if WINDOWS_PHONE
            Puhelinasetukset();
#endif
        }



        public void AsetaPistelista()
        {
            //topLista = HighScoreList.LoadOrCreate("topten.dat",10);
        }

        #region WP7-Metodit

        /// <summary>
        /// Palauttaa ohjelman tilan
        /// </summary>
        public override void Continue()
        {
            base.Continue();
            Puhelinasetukset();
            LoadState lataus = DataStorage.BeginLoad(file);
            pelinTila = lataus.Load<int>(pelinTila, "pelinTila");

            LuoPelikentta();
            AsetaPistelista();
            LuoHud();
            //Jos peli ei ollut käynnissä
            if (pelinTila == 0) 
            {
                AlkuIntro();
            }

            //Jos peli oli käynnissä
            if (pelinTila == 1)
            {
                pelikentta = lataus.Load<GameObject[][]>(pelikentta, "pelikentta");
                aktiivinenPalikka = new TetrisPalikka(4);
                aktiivinenPalikka = lataus.Load<TetrisPalikka>(aktiivinenPalikka,"aktiivinenPalikka");

                LuoHud();
                ennustuskentta = lataus.Load<GameObject[][]>(ennustuskentta,"ennustuskentta" );

                ennustusPalikka = new TetrisPalikka(4);
                ennustusPalikka = lataus.Load<TetrisPalikka>(ennustusPalikka,"ennustusPalikka" );

                taso = lataus.Load<IntMeter>(taso,"taso" );
                pisteet = lataus.Load<IntMeter>(pisteet, "pisteet");
                tuhotutRivit = lataus.Load<int>(tuhotutRivit, "tuhotutRivit");
                vaikeusaste = lataus.Load<double>(vaikeusaste, "vaikeusaste");

                LuoTiputusajastin();
                tiputusajastin.Start();
            }
            lataus.EndLoad();
            
        }

        /// <summary>
        /// Asettaa näytön asennon ja zoomin kohilleen.
        /// </summary>
        public void Puhelinasetukset()
        {
            Phone.DisplayOrientation = Jypeli.WP7.DisplayOrientation.Portrait;
            Camera.ZoomToLevel();
            Camera.Zoom(0.9);
            Camera.Move(new Vector(40, 0));
            TouchPanel.Listen(ButtonState.Pressed, KasitteleKosketus, null);

            Phone.Deactivated += TilaTalletus;
        }

        /// <summary>
        /// Toimenpiteet, mitä tehdään, kun poistutaan pelistä
        /// </summary>
        public void TilaTalletus()
        {
            SaveState tallennus = DataStorage.BeginSave(file);

            tallennus.Save<int>(pelinTila, "pelinTila");
            if (pelinTila == 1) 
            {
                tallennus.Save<GameObject[][]>(pelikentta, "pelikentta");
                tallennus.Save<GameObject[][]>(ennustuskentta, "ennustuskentta");
                tallennus.Save<TetrisPalikka>(aktiivinenPalikka, "aktiivinenPalikka");
                tallennus.Save<TetrisPalikka>(ennustusPalikka, "ennustusPalikka");
                tallennus.Save<IntMeter>(taso, "taso");
                tallennus.Save<IntMeter>(pisteet, "pisteet");
                tallennus.Save<int>(tuhotutRivit, "tuhotutRivit");
                tallennus.Save<double>(vaikeusaste, "vaikeusaste");
            }
            tallennus.EndSave();
        }

        /// <summary>
        /// Käsittelee pelaamiseen liittyvät kosketukset (Palikan liikuttaminen)
        /// </summary>
        /// <param name="b">Käsiteltävä kosketus</param>
        public void KasitteleLiikuntaKosketukset(Touch b)
        {

            if (b.PositionOnWorld.X < AnnaKoordinaateista(aktiivinenPalikka.Sijainti()[0]).Position.X - 30)
            {
                Liikuta(vasemmalle);
                return;
            }
            if (b.PositionOnWorld.X > AnnaKoordinaateista(aktiivinenPalikka.Sijainti()[0]).Position.X + 30)
            {
                Liikuta(oikealle);
                return;
            }

            if (b.PositionOnWorld.Y < AnnaKoordinaateista(aktiivinenPalikka.Sijainti()[0]).Position.Y - 20)
            {
                Liikuta(alas);
                return;
            }
            else if (b.PositionOnWorld.Y > AnnaKoordinaateista(aktiivinenPalikka.Sijainti()[0]).Position.Y + 10)
            {
                Kaanna();
                return;
            }
        }

        public void PysaytaPhone(Touch b)
        {
            Pysayta(true);
        }

        /// <summary>
        /// Käsittelee kosketuksen menussa
        /// </summary>
        /// <param name="b"></param>
        public void KasitteleKosketus(Touch b)
        {
            if (tiputusajastin == null)
            {
                KaynnistaPeli();
                return;
            }
        }

        /// <summary>
        /// Käsittelee pause-nappia painaneen kosketuksen
        /// </summary>
        /// <param name="b"></param>
        public void KasittelePauseKosketus(Touch b)
        {
            Pysayta(false);
        }
        #endregion

        #region Intro
        /// <summary>
        /// Luo introajastimen
        /// </summary>
        private void LuoIntroAjastin()
        {
            introajastin = new Timer();
            introajastin.Interval = 0.05;
            introajastin.Timeout += IntroPyoritys;
        }

        /// <summary>
        /// Käynnistää alkuintron
        /// </summary>
        private void AlkuIntro()
        {
            LuoIntroAjastin();
            introajastin.Start();
        }

        /// <summary>
        /// Pyörittää introa
        /// </summary>
        /// <param name="ajastin">Ei käytössä</param>
        private void IntroPyoritys()
        {
            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;
            }
        }


        #endregion
        #region Pelialueen ja Hudin luominen
        /// <summary>
        /// Luo näyttöön pistenäytöt ja muut elementit.
        /// </summary>
        private void LuoHud()
        {
            Widget statistiikka = new Widget(120, 100);
            statistiikka.Layout = new VerticalLayout();
            Add(statistiikka);

            Label pisteteksti = new Label("Pisteet:");
            statistiikka.Add(pisteteksti);

            pistenaytto = new Label();
            pistenaytto.BindTo(pisteet);
            statistiikka.Add(pistenaytto);

            statistiikka.Position = new Vector(Level.Right + 120, Level.Top - 100);

            Label tasoteksti = new Label("Taso:");
            statistiikka.Add(tasoteksti);

            tasonaytto = new Label(20, 20);
            tasonaytto.BindTo(taso);
            statistiikka.Add(tasonaytto);

            status = new Label("JyTris " + versio);
            Add(status);

            pausenappula = new GameObject(50, 50);
            pausenappula.Position = new Vector(Level.Right + 75, Level.Top - 25);
            Add(pausenappula);

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

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

        /// <summary>
        /// Asettaa ennustusnäytön näyttämään annettua palikkaa
        /// </summary>
        /// <param name="palikka">Näytettävä palikka</param>
        private void AsetaEnnustusnaytto(TetrisPalikka palikka)
        {
            for (int i = 0; i < ennustuskentta.Length; i++)
            {
                for (int j = 0; j < ennustuskentta[i].Length; j++)
                {
                    ennustuskentta[i][j].Color = Color.Transparent;
                }
            }

            Vector[] sijainnit = palikka.Sijainti();
            int offset = -(leveys / 2) + 1;

            foreach (Vector paikka in sijainnit)
            {
                ennustuskentta[(int)paikka.Y][(int)paikka.X + offset].Color = palikka.Vari();
            }
        }

        /// <summary>
        /// Luo pelikentän ylhäällä määrätyistä vakioista
        /// </summary>
        private 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, Shape.Rectangle);
                    pelikentta[i][j].Color = Color.Transparent;
                    pelikentta[i][j].X = Level.Left + (palikkojenSivu / 2) + j * (palikkojenSivu);
                    pelikentta[i][j].Y = Level.Top - (palikkojenSivu / 2) - i * (palikkojenSivu);
                    Add(pelikentta[i][j]);
                }
            }
        }
        #endregion
        #region Kontrollit
        /// <summary>
        /// Asettaa pelin aikana tarvittavat näppäimet.
        /// </summary>
        private 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");
            Keyboard.Listen(Key.Up, ButtonState.Pressed, Kaanna, "Kääntää palikkaa");
            Keyboard.Listen(Key.Space, ButtonState.Pressed, Tiputa, "Tiputtaa palikan");
            Keyboard.Listen(Key.P, ButtonState.Pressed, Pysayta, "Pysayttaa pelin", true);
            TouchPanel.Listen(ButtonState.Pressed, KasitteleLiikuntaKosketukset, null);
            TouchPanel.ListenOn(pausenappula, ButtonState.Down, PysaytaPhone ,null);

        }

        private void AsetaTaukoNappaimet()
        {
            Keyboard.Listen(Key.P, ButtonState.Pressed, Pysayta, "Jatkaa peliä", false);
            TouchPanel.Listen(ButtonState.Pressed, KasittelePauseKosketus, null);
        }

        /// <summary>
        /// Asettaa menuissa käytettävät näppäimet
        /// </summary>
        private void AsetaMenuNappaimet()
        {
            Keyboard.Listen(Key.Escape, ButtonState.Pressed, Exit, "Poistuu pelistä");
            Keyboard.Listen(Key.F2, ButtonState.Pressed, KaynnistaPeli, "Aloittaa uuden pelin");
            TouchPanel.Listen(ButtonState.Pressed, KasitteleKosketus, null);
        }
        #endregion
        #region Palikan siirtämiseen liittyvät
        /// <summary>
        /// Liikuttaa palikkaa halutun verran.
        /// </summary>
        /// <param name="suunta">X ja Y oltava kokonaislukuja.</param>
        private void Liikuta(Vector suunta)
        {
            PaivitaPalikka(aktiivinenPalikka, Color.Transparent);

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

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

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

            //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>
        private void Laske()
        {
            PaivitaPalikka(aktiivinenPalikka, Color.Transparent);

            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>
        private void Tiputa()
        {
            //Lasketaan, kunnes ei ole sama palikka ohjattavana.
            TetrisPalikka palikka = aktiivinenPalikka;
            while (aktiivinenPalikka == palikka) Laske();
        }

        /// <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>
        private 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>
        private 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.Transparent
        /// </summary>
        /// <param name="paikka">X ja Y oltava kokonaislukuja</param>
        /// <returns>true, jos paikka on tyhjä</returns>
        private 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.Transparent) 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>
        private 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>
        /// Antaa gameobjectin, joka vastaa taulukon koordinaatteja (0,1,2...)
        /// 
        /// Ei vastaa näytön koordinaatteja!
        /// </summary>
        /// <param name="koordinaatit">Haluttu koordinaatti</param>
        /// <returns>Gameobject, joka vastaa koordinaatteja</returns>
        private GameObject AnnaKoordinaateista(Vector koordinaatit)
        {
            return pelikentta[(int)Math.Round(koordinaatit.Y)][(int)Math.Round(koordinaatit.X)];
        }
        #endregion
        #region Pelilogiikka
        /// <summary>
        /// Luo palikan keskelle ylälaitaa
        /// 
        /// Tulee antamaan satunnaisen palikan
        /// </summary>
        private void LuoPalikka()
        {
            //Luo uuden palikan ja siirtää ennustuspalikan aktiiviseksi
            //ennustusPalikka = new TetrisPalikka(leveys / 2);
            if (aktiivinenPalikka != null)
            {
                aktiivinenPalikka = ennustusPalikka;
            }
            else
            {
                aktiivinenPalikka = new TetrisPalikka(leveys / 2);
            }

            ennustusPalikka = new TetrisPalikka(leveys / 2);

            AsetaEnnustusnaytto(ennustusPalikka);

            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>
        /// 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>
        private void KaynnistaPeli()
        {
            status.Color = Color.Transparent;
            status.TextColor = Color.Transparent;
            pelinTila = 1;
            pisteet.Value = 0;
            taso.Value = 1;
            tuhotutRivit = 0;
            introajastin.Stop();
            TuhoaKaikki();
            ClearControls();
            AsetaPeliNappaimet();


            /*
            if (purkkabool)
            {
                topLista.Hide();
                purkkabool = false;
            }
            */
            vaikeusaste = 0.9;
            LuoTiputusajastin();
            tiputusajastin.Start();
            LuoPalikka();
        }

        /// <summary>
        /// Luo ajastimen, joka tiputtaa palikoita
        /// </summary>
        private void LuoTiputusajastin() 
        {
            tiputusajastin = new Timer();
            tiputusajastin.Interval = vaikeusaste;
            tiputusajastin.Timeout += Laske;
        }

        /// <summary>
        /// Tauottaa pelin
        /// 
        /// false-arvolla jatkaa peliä
        /// </summary>
        /// <param name="pysaytetaan">true, jos peli halutaan pysäyttää</param>
        private void Pysayta(bool pysaytetaan)
        {
            if (pysaytetaan)
            {
                tiputusajastin.Stop();
                ClearControls();
                AsetaTaukoNappaimet();
                status.Text = "Peli pysaytetty";
                status.TextColor = Color.Beige;
                return;
            }
            status.TextColor = Color.Transparent;
            tiputusajastin.Start();
            ClearControls();
            AsetaPeliNappaimet();
        }


        /// <summary>
        /// Tuhoaa täydet rivit kentältä
        /// </summary>
        private void TuhoaTaydet()
        {
            bool tyhjia;
            int potti = 0;


            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.Transparent) tyhjia = true;
                }

                if (!tyhjia)
                {
                    potti += 10;
                    TuhoaRivi(i);
                }
            }

            pisteet.Value += (potti / 10) * taso * potti;

            if (tuhotutRivit > 10)
            {
                tuhotutRivit -= 10;
                tiputusajastin.Interval -= 0.1;
                taso.Value++;
            }
        }

        /// <summary>
        /// Tuhoaa kaikki palikat kentältä.
        /// </summary>
        private 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.Transparent;
                }
            }
        }

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

            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.Transparent;
            }
        }

        /// <summary>
        /// Lopettaa pelin.
        /// - Palikkoja ei tipu
        /// - Poistaa vanhat kontrollit
        /// - Asettaa menunapit toimintaan
        /// </summary>
        private void PeliLoppui()
        {
            tiputusajastin.Stop();
            status.Text = "Hävisit pelin!";
            //status.Image = LoadImage("peliloppu");
            status.TextColor = Color.Beige;
            //topLista.Show(pisteet.Value);
            //purkkabool = true;
            ClearControls();
            AsetaMenuNappaimet();
        }
        #endregion

        
    }
}