source: 2010/24/anlakane/Muistipeli/Peli2.cs @ 923

using System;
using System.Collections.Generic;
using Jypeli;
using Jypeli.ScreenObjects;
using Jypeli.Assets;

namespace Muistipeli
{
    public class Peli2 : Game
    {
        int montakoRivia;
        int montakoSaraketta;
        bool voikoKaantaa;

        double korttienVali = 20.0;

        double kortinLeveys = 50;
        double kortinKorkeus = 70;
        Kortti[,] kortit; // rivit, sarakkeet
        int[,] korostettuKortti;
        int montakoKorttia;
        public enum Suunta { Vasen, Oikea, Ylos, Alas }
        Suunta mihinSuuntaanMenossa;

        GameObject highlighter;
        List<Kortti> kaannetyt;
        Timer piilotusAjastin;
        double aikaaEnnenPiilottamista = 2;
        protected override void Begin()
        {
            piilotusAjastin = new Timer();
            piilotusAjastin.Interval = aikaaEnnenPiilottamista;
            piilotusAjastin.Trigger += PiilotaKaannetyt;
            Add(piilotusAjastin);

            montakoKorttia = 52;
            kaannetyt = new List<Kortti>();

            // Laitetaan ensin rivejä ja sarakkeita yhtä paljon
            montakoSaraketta = (int)Math.Sqrt(montakoKorttia);
            // Sitte laitetaan kortit vähän mukavempaan muotoon kun näytöt on yleensä leveämpiä kuin korkeita
            montakoSaraketta = (int)Math.Floor((3.0 / 2.0) * montakoSaraketta);
            // Tarvittavien rivien määrä saadaan korttien määrän ja saadun sarakkeiden määrän suhteesta
            montakoRivia = (int)Math.Ceiling((double)montakoKorttia / (double)montakoSaraketta);
            kortit = new Kortti[montakoRivia, montakoSaraketta];
            KortitRuudulle(montakoKorttia);
            LisaaHighLighter();
            AsetaNappaimet();

            // Laitetaan kenttä sopivan kokoiseksi että kortit täyttävät aina mahollisimman paljon ruutukapasiteetista
            Level.Width = montakoSaraketta * (korttienVali + kortinLeveys) + kortinLeveys;
            Level.Height = montakoRivia * (korttienVali + kortinKorkeus) + kortinKorkeus;
            Camera.ZoomToLevel();
            AloitaPeli();
        }

        /// <summary>
        /// Korostetaan ensimmäinen kortti.
        /// </summary>
        public void AloitaPeli()
        {
            korostettuKortti = new int[2, 1];
            KorostaKortti(new int[2, 1] { { 0 }, { 0 } });
            voikoKaantaa = true;
        }

        private void LisaaHighLighter()
        {
            highlighter = new GameObject(kortinLeveys, kortinKorkeus);
            highlighter.Image = LoadImage("highlight");
            Add(highlighter);
        }

        void AsetaNappaimet()
        {
            Keyboard.Listen(Key.Left, ButtonState.Pressed, KortinValinta, null, Suunta.Vasen);
            Keyboard.Listen(Key.Right, ButtonState.Pressed, KortinValinta, null, Suunta.Oikea);
            Keyboard.Listen(Key.Up, ButtonState.Pressed, KortinValinta, null, Suunta.Ylos);
            Keyboard.Listen(Key.Down, ButtonState.Pressed, KortinValinta, null, Suunta.Alas);
            Keyboard.Listen(Key.Space, ButtonState.Pressed, KaannaKortti, null);
            Keyboard.Listen(Key.Escape, ButtonState.Pressed, Lopeta, null);
        }

        void Lopeta()
        {
            Exit();
        }

        void KaannaKortti()
        {
            if (voikoKaantaa)
            {
                // Ei käännetä kahta kertaa samaa korttia
                if (kaannetyt.Count == 0 || kortit[korostettuKortti[0, 0], korostettuKortti[1, 0]] != kaannetyt[0])
                {
                    kortit[korostettuKortti[0, 0], korostettuKortti[1, 0]].Kaanna();
                    kaannetyt.Add(kortit[korostettuKortti[0, 0], korostettuKortti[1, 0]]);

                    if (kaannetyt.Count == 2)
                    {
                        // Jos kaksi korttia on käännetty niin ajastin lähtee käyntiin eikä sinä aikana voi kääntää kortteja
                        voikoKaantaa = false; 
                        piilotusAjastin.Start();
                    }
                }
            }
        }

        void PiilotaKaannetyt(Timer t)
        {
            foreach (var item in kaannetyt)
            {
                item.Kaanna();
            }
            kaannetyt.Clear();
            piilotusAjastin.Stop();
            voikoKaantaa = true;
        }

        void KorostaKortti(int[,] kortinNro)
        {
            kortinNro = TarkistaKortinNro(kortinNro);
            highlighter.Position = new Vector(KortinX(kortinNro[1, 0]), KortinY(kortinNro[0, 0]));
            Kortti.PuoliEsilla puoliesilla = kortit[kortinNro[0, 0], kortinNro[1, 0]].KumpiPuoliEsilla();
            korostettuKortti = kortinNro;
        }

        private int[,] TarkistaKortinNro(int[,] kortinNro)
        {
            if (kortinNro[0, 0] >= montakoRivia)
            {
                kortinNro[0, 0] = 0;
            }

            if (kortinNro[1, 0] >= montakoSaraketta)
            {
                kortinNro[1, 0] = 0;
            }

            if (kortinNro[0, 0] < 0)
            {
                kortinNro[0, 0] = montakoRivia - 1;
            }

            if (kortinNro[1, 0] < 0)
            {
                kortinNro[1, 0] = montakoSaraketta - 1;
            }

            if (kortit[kortinNro[0, 0], kortinNro[1, 0]] == null) // Mentiin pelipakan "tyhjälle alueelle"
            {
                kortinNro = TultiinNullViitteeseen(kortinNro);
            }

            return kortinNro;
        }

        private int[,] TultiinNullViitteeseen(int[,] kortinNro)
        {
            if (mihinSuuntaanMenossa == Suunta.Vasen)
            {
                return new int[2, 1] { { korostettuKortti[0, 0] }, { (montakoKorttia % montakoSaraketta) - 1 } };
            }
            if (mihinSuuntaanMenossa == Suunta.Oikea)
            {
                return new int[2, 1] { { korostettuKortti[0, 0] }, { 0 } };
            }
            if (mihinSuuntaanMenossa == Suunta.Ylos)
            {
                return new int[2, 1] { { montakoRivia - 2 }, { korostettuKortti[1, 0] } };

            }

            // alas
            return new int[2, 1] { { 0 }, { korostettuKortti[1, 0] } };

        }

        void KortinValinta(Suunta suunta)
        {
            mihinSuuntaanMenossa = suunta;
            if (mihinSuuntaanMenossa == Suunta.Vasen)
            {
                KorostaKortti(new int[2, 1] { { korostettuKortti[0, 0] }, { korostettuKortti[1, 0] - 1 } });
            }
            if (mihinSuuntaanMenossa == Suunta.Oikea)
            {
                KorostaKortti(new int[2, 1] { { korostettuKortti[0, 0] }, { korostettuKortti[1, 0] + 1 } });
            }
            if (mihinSuuntaanMenossa == Suunta.Ylos)
            {
                KorostaKortti(new int[2, 1] { { korostettuKortti[0, 0] - 1 }, { korostettuKortti[1, 0] } });
            }
            if (mihinSuuntaanMenossa == Suunta.Alas)
            {
                KorostaKortti(new int[2, 1] { { korostettuKortti[0, 0] + 1 }, { korostettuKortti[1, 0] } });

            }

        }

        /// <summary>
        /// Aliohjelma lisää halutun määrän kortteja
        /// taulukkoon ja edelleen ruudulle.
        /// </summary>
        /// <param name="montakoKorttiaLisataan">Kuinka monta korttia taulukkoon (attribuutti) lisätään.</param>
        void KortitRuudulle(int montakoKorttiaLisataan)
        {
            int montakoKorttiaLisatty = 0;

            for (int r = 0; r < kortit.GetLength(0); r++) // Rivit
            {
                for (int s = 0; s < kortit.GetLength(1); s++) // Sarakkeet
                {
                    // Jos tarvittava määrä kortteja on lisätty, 
                    // laitetaan loppuihin taulukon alkioihin null-viite
                    if (montakoKorttiaLisataan == montakoKorttiaLisatty)
                    {
                        kortit[r, s] = null;
                        continue;
                    }

                    kortit[r, s] = TeeKortti();
                    Add(kortit[r, s]);

                    kortit[r, s].X = KortinX(s);
                    kortit[r, s].Y = KortinY(r);

                    montakoKorttiaLisatty++;
                }
            }
        }

        public double KortinX(int sarake)
        {
            return (-(montakoSaraketta * (kortinLeveys + korttienVali)) / 2) + (sarake * (kortinLeveys + korttienVali)) + korttienVali;
        }

        public double KortinY(int rivi)
        {
            // Viimeinen termi tulee siitä että viimeisen kortin perässä ei tarvita välistystä
            return ((montakoRivia) * (kortinKorkeus + korttienVali)) / 2 - rivi * (kortinKorkeus + korttienVali) - korttienVali;
        }

        public Kortti TeeKortti()
        {
            Image kuvaTekstuuri = LoadImage("kortti1");
            Image takaTekstuuri = LoadImage("taka");
            return new Kortti(kortinLeveys, kortinKorkeus, false, kuvaTekstuuri, takaTekstuuri);
        }
    }
}