source: 2010/24/anlakane/Muistipeli/Muistipeli.cs @ 1033

using System;
using System.IO;
using System.Collections.Generic;
using Jypeli;
using Jypeli.Widgets;
using Jypeli.ScreenObjects;
using Jypeli.Assets;
using Jypeli.Effects;

namespace Muistipeli
{
    public struct Paikka
    {
        public int Rivi;
        public int Sarake;

        public Paikka(int rivi, int sarake)
        {
            Rivi = rivi;
            Sarake = sarake;
        }
    }

    public struct Pelaaja
    {
        public int Numero;
        public String Nimi;
        public int Pisteet;
        public Color Vari;

        public Pelaaja(String nimi, int numero, Color vari)
        {
            Numero = numero;
            Nimi = nimi;
            Pisteet = 0;
            Vari = vari;
        }
    }


    public class Muistipeli : Game
    {
        List<GameObject> valikonKohdat;

        int montakoRivia;
        int montakoSaraketta;

        double korttienVali = 20.0;
        double kortinLeveys = 50;
        double kortinKorkeus = 70;

        Kortti[,] kortit; // rivit, sarakkeet
        Paikka korostettuKortti;
        int montakoKorttia;
        int[] montakoKutakinKorttitunnusta;

        public enum Suunta { Vasen, Oikea, Ylos, Alas }
        Suunta mihinSuuntaanMenossa;

        GameObject highlighter;
        List<Kortti> kaannetyt; // Yhdellä vuorolla käännetyt kortit. Tyhjennetään vuoron päätteeksi. Listassa voi olla siis 0, 1 tai 2 alkiota.
        Timer piilotusAjastin;
        const double aikaaEnnenPiilottamista = 2;

        String korttisarja;

        Pelaaja pelaaja1;
        Pelaaja pelaaja2;
        Pelaaja vuorossaOlevaPelaaja;
        Label vuoronaytto;

        IntMeter pelaajan1Pisteet;
        IntMeter pelaajan2Pisteet;
        IntMeter korttejaLoydetty;

        protected override void Begin()
        {
            //montakoKorttia = 16; // Pitää olla ennen laskureiden lisäämistä
            Valikko();
        }

        public void Valikko()
        {
            valikonKohdat = new List<GameObject>();
            Level.BackgroundColor = Color.White;

            GameObject elaimet = new GameObject(538, 256);
            elaimet.Image = LoadImage("elaimet");
            elaimet.Tag = "elaimet";
            elaimet.Y = elaimet.Height / 2 + 10;
            valikonKohdat.Add(elaimet);

            GameObject ihmiset = new GameObject(538, 256);
            ihmiset.Image = LoadImage("ihmiset");
            ihmiset.Tag = "ihmiset";
            ihmiset.Y = -ihmiset.Height / 2 - 10;
            valikonKohdat.Add(ihmiset);

            foreach (var valikonKohta in valikonKohdat)
            {
                Add(valikonKohta);
                Mouse.ListenOn(valikonKohta, MouseButton.Left, ButtonState.Pressed, ValikonValinta, null, valikonKohta);
            }

            Mouse.IsCursorVisible = true;
            Mouse.ListenMovement(1.0, ValikossaLiikkuminen, null);
            Keyboard.Listen(Key.Escape, ButtonState.Pressed, Lopeta, "");
            
        }

        public void ValikonValinta(GameObject mitaPainettiin)
        {
            AloitaUusiPeli(mitaPainettiin.Tag.ToString());
        }
        
        public void ValikossaLiikkuminen(AnalogState hiirenTila)
        {
            foreach (var kohta in valikonKohdat)
            {
                if (Mouse.IsCursorOn(kohta))
                {
                    kohta.Image = LoadImage(kohta.Tag.ToString() + "_");
                }
                else
                {
                    kohta.Image = LoadImage(kohta.Tag.ToString());
                }               
                
            }
        }



        public void AloitaUusiPeli(String korttisarja)
        {
            ClearAll();
            LisaaPelaajat(2);
            LisaaPiilotusajastin();
            this.korttisarja = korttisarja;
            int montakoKuvaa = LataaKuvat();
            montakoKorttia = montakoKuvaa * 2;

            // Laitetaan ensin rivejä ja sarakkeita yhtä paljon
            montakoSaraketta = (int)Math.Sqrt(montakoKorttia);
            // Kortit vähän mukavempaan muotoon, koska 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];

            // kortin tunnusNro indeksistä, alkiot tulkitaan siten että "montako tämän tunnuksen alkiota on lisätty peliin"
            // Tämä pitää olla ennen kuin kortit lisätään ruudulle
            montakoKutakinKorttitunnusta = new int[montakoKorttia / 2];

            KortitRuudulle();
            //LisaaKuvat();  // Pitää olla ennen laskureiden lisäämistä

            LisaaLaskurit();
            LisaaVuoronaytto();
            LisaaHighLighter();

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

            PeliKayntiin();
            AsetaNappaimet();
        }

        public void LisaaPiilotusajastin()
        {
            piilotusAjastin = new Timer();
            piilotusAjastin.Interval = aikaaEnnenPiilottamista;
            piilotusAjastin.Trigger += PiilotaKaannetyt;
            Add(piilotusAjastin);
        }

        public void LisaaLaskurit()
        {
            pelaajan1Pisteet = new IntMeter(0);
            Label p1teksti = new Label("Pelaaja 1 pisteet: ");
            Label pisteNaytto1 = new Label();
            Label p1VoitotTeksti = new Label("Pelaaja 1 voitot: ");
            Label p1Voitot = new Label(pelaaja1.Pisteet.ToString());

            p1teksti.TextColor = Color.Black;
            p1teksti.Position = new Vector(Screen.Left + 140, Screen.Bottom + 70);
            pisteNaytto1.Position = new Vector(p1teksti.X + (p1teksti.Width / 2) + 10, p1teksti.Y);
            pisteNaytto1.TextColor = Color.Blue;
            pisteNaytto1.BindTo(pelaajan1Pisteet);
            p1VoitotTeksti.Position = new Vector(Screen.Left + 140 - ((p1teksti.Width - p1VoitotTeksti.Width) / 2), p1teksti.Y - 30);
            p1Voitot.Position = new Vector(p1VoitotTeksti.X + (p1VoitotTeksti.Width / 2) + 10, p1VoitotTeksti.Y);

            Add(p1teksti);
            Add(pisteNaytto1);
            Add(p1VoitotTeksti);
            Add(p1Voitot);

            pelaajan2Pisteet = new IntMeter(0);
            Label p2teksti = new Label("Pelaaja 2 pisteet: ");
            Label pisteNaytto2 = new Label();
            Label p2VoitotTeksti = new Label("Pelaaja 1 voitot: ");
            Label p2Voitot = new Label(pelaaja2.Pisteet.ToString());

            p2teksti.TextColor = Color.Black;
            p2teksti.X = Screen.Right - 140;
            p2teksti.Y = Screen.Bottom + 70;
            pisteNaytto2.X = p2teksti.X + (p2teksti.Width / 2) + 10;
            pisteNaytto2.Y = p2teksti.Y;
            pisteNaytto2.TextColor = Color.Red;
            pisteNaytto2.BindTo(pelaajan2Pisteet);
            p2VoitotTeksti.X = Screen.Right - 140 + ((p2teksti.Width - p2VoitotTeksti.Width) / 2);
            p2VoitotTeksti.Y = p2teksti.Y - 30;
            p2Voitot.Position = new Vector(p2VoitotTeksti.X + (p2VoitotTeksti.Width / 2) + 10, p2VoitotTeksti.Y);

            Add(p2teksti);
            Add(pisteNaytto2);
            Add(p2VoitotTeksti);
            Add(p2Voitot);

            korttejaLoydetty = new IntMeter(0);
            korttejaLoydetty.MaxValue = montakoKorttia;
            korttejaLoydetty.UpperLimit += KaikkiLoydetty;
        }

        /// <summary>
        /// Korostetaan ensimmäinen kortti.
        /// </summary>
        public void PeliKayntiin()
        {
            kaannetyt = new List<Kortti>();
            korostettuKortti = new Paikka(0, 0);
            KorostaKortti(new Paikka(0, 0));
            vuorossaOlevaPelaaja = pelaaja1;
            Level.BackgroundColor = pelaaja1.Vari;
            vuoronaytto.Text = "Pelaaja 1";
            MessageDisplay.Add("Pelaaja 1 aloittaa pelin!");
        }


        public void KaikkiLoydetty(int arvo)
        {
            Mouse.IsCursorVisible = true;
            String voittoteksti;
            if (pelaajan1Pisteet > pelaajan2Pisteet)
            {
                voittoteksti = "Pelaaja 1 voitti! ";
                pelaaja1.Pisteet++;
            }
            else if (pelaajan2Pisteet > pelaajan1Pisteet)
            {
                voittoteksti = "Pelaaja 2 voitti! ";
                pelaaja2.Pisteet++;
            }
            else
            {
                voittoteksti = "Tasapeli! ";
            }

            MessageBox m = new MessageBox(
                "Peli päättyi",
                "" + voittoteksti + "Aloita uusi peli painamalla OK.");
            m.OkButton.Clicked += OKPainettu;
            Add(m);
        }

        public void OKPainettu()
        {
            AloitaUusiPeli(korttisarja);
        }

        public void LisaaVuoronaytto()
        {
            Label vuorossaNyt = new Label("Vuorossa nyt");
            vuorossaNyt.X = 0;
            vuorossaNyt.Y = Screen.Bottom + 70;
            vuoronaytto = new Label();
            vuoronaytto.X = 0;
            vuoronaytto.Y = vuorossaNyt.Y - 30;
            Add(vuorossaNyt);
            Add(vuoronaytto);
        }

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

        private int LataaKuvat()
        {
            List<String> kuvat = new List<string>();
            String[] kuvatiedostot = Directory.GetFiles(korttisarja);
            return kuvatiedostot.Length;
        }

        void LisaaPelaajat(int montakoPelaajaa)
        {
            // Toistaiseksi tehdään "manuaalisesti" kaksi pelaajaa
            pelaaja1 = new Pelaaja("", 1, Color.Cyan);
            pelaaja2 = new Pelaaja("", 2, Color.MediumPurple);
        }

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

        #region Liikkuminen
        void KorostaKortti(Paikka korostettavaKortti)
        {
            korostettavaKortti = TarkistaKortinNro(korostettavaKortti);
            highlighter.Position = new Vector(KortinX(korostettavaKortti.Sarake), KortinY(korostettavaKortti.Rivi));
            Kortti.PuoliEsilla puoliesilla = kortit[korostettavaKortti.Rivi, korostettavaKortti.Sarake].KumpiPuoliEsilla();
            korostettuKortti = korostettavaKortti;
        }

        /// <summary>
        /// Aliohjelma pitää huolen, että valittu kortti on aina
        /// rivi- ja sarakeindeksien sisäpuolella. Toisin sanoen 
        /// rivistä/sarakkeesta "yli" hypättäessä kursori palautuu 
        /// oikeaan paikkaan.
        /// </summary>
        /// <param name="kortinNro">Kortin rivi, sarake</param>
        /// <returns>"Korjatut" koordinaatit</returns>
        private Paikka TarkistaKortinNro(Paikka paikka)
        {
            // Viimeisen rivin jälkeen palataan ensimmäiselle riville
            if (paikka.Rivi >= montakoRivia)
                paikka.Rivi = 0;

            // Viimeisen sarakkeen jälkeen palataan ensimmäiseen sarakkeeseen
            if (paikka.Sarake >= montakoSaraketta)
                paikka.Sarake = 0;

            // Ensimmäisestä rivistä "taaksepäin" liikuttaessa
            // hypätään viimeiselle riville
            if (paikka.Rivi < 0)
                paikka.Rivi = montakoRivia - 1;

            // Ensimmäisestä sarakkeesta "taaksepäin" liikuttaessa
            // hypätään viimeiseen sarakkeeseen
            if (paikka.Sarake < 0)
                paikka.Sarake = montakoSaraketta - 1;

            // Mentiin pelipakan "tyhjälle alueelle"
            if (kortit[paikka.Rivi, paikka.Sarake] == null)
                paikka = TultiinNullViitteeseen(paikka);

            return paikka;
        }

        private Paikka TultiinNullViitteeseen(Paikka kortinPaikka)
        {
            if (mihinSuuntaanMenossa == Suunta.Vasen)
                return new Paikka(kortinPaikka.Rivi, (montakoKorttia % montakoSaraketta) - 1);
            if (mihinSuuntaanMenossa == Suunta.Oikea)
                return new Paikka(kortinPaikka.Rivi, 0);
            if (mihinSuuntaanMenossa == Suunta.Ylos)
                return new Paikka(montakoRivia - 2, kortinPaikka.Sarake);

            // alas
            return new Paikka(0, kortinPaikka.Sarake);
        }

        void KortinValinta(Suunta suunta)
        {
            mihinSuuntaanMenossa = suunta;
            if (mihinSuuntaanMenossa == Suunta.Vasen)
                KorostaKortti(new Paikka(korostettuKortti.Rivi, korostettuKortti.Sarake - 1));

            if (mihinSuuntaanMenossa == Suunta.Oikea)
                KorostaKortti(new Paikka(korostettuKortti.Rivi, korostettuKortti.Sarake + 1));

            if (mihinSuuntaanMenossa == Suunta.Ylos)
                KorostaKortti(new Paikka(korostettuKortti.Rivi - 1, korostettuKortti.Sarake));

            if (mihinSuuntaanMenossa == Suunta.Alas)
                KorostaKortti(new Paikka(korostettuKortti.Rivi + 1, korostettuKortti.Sarake));
        }
        #endregion

        #region Kääntäminen ja parin löytyminen

        public bool VoikoKorttiaKaantaa(Kortti kortti)
        {
            // Ei käännetä kahta kertaa samaa korttia
            if (kaannetyt.Count == 0 || kortit[korostettuKortti.Rivi, korostettuKortti.Sarake] != kaannetyt[0])
            {
                // Jos kortti "on jo löydetty", niin sitä ei voi missään tapauksessa kääntää
                bool onkoPoistettuPelista = kortit[korostettuKortti.Rivi, korostettuKortti.Sarake].PoistettuPelista;

                if (!onkoPoistettuPelista)
                {
                    return true;
                }
            }
            return false;
        }

        void KaannaKortti()
        {
            if (VoikoKorttiaKaantaa(kortit[korostettuKortti.Rivi, korostettuKortti.Sarake]))
            {
                kortit[korostettuKortti.Rivi, korostettuKortti.Sarake].Kaanna();
                kaannetyt.Add(kortit[korostettuKortti.Rivi, korostettuKortti.Sarake]);

                if (kaannetyt.Count == 2) // Tasan kaksi korttia käännetään yhdellä vuorolla
                {
                    if (kaannetyt[0].Tunniste == kaannetyt[1].Tunniste) // Käännetyt kortit muodostavat parin
                    {
                        foreach (Kortti kaannetty in kaannetyt)
                        {
                            RajaytaKortti(kaannetty);
                            kaannetty.PoistettuPelista = true;
                        }
                        PariLoytyi();
                    }
                    else
                    {
                        // Jos kaksi korttia on käännetty niin ajastin lähtee käyntiin eikä sinä aikana voi kääntää kortteja
                        Keyboard.Disable(Key.Space);
                        piilotusAjastin.Start();
                    }
                }
            }
        }

        void PiilotaKaannetyt(Timer t)
        {
            foreach (var item in kaannetyt)
            {
                item.Kaanna();
            }
            kaannetyt.Clear();
            piilotusAjastin.Stop();
            Keyboard.Enable(Key.Space);
            VuoroVaihtuu();
        }

        public void PariLoytyi()
        {
            MediaPlayer.Play("tada");
            kaannetyt.Clear();

            if (vuorossaOlevaPelaaja.Equals(pelaaja1))
            {
                pelaajan1Pisteet.Value++;
            }
            else if (vuorossaOlevaPelaaja.Equals(pelaaja2))
            {
                pelaajan2Pisteet.Value++;
            }

            korttejaLoydetty.Value += 2;
        }

        /// <summary>
        /// Näpsäkkä korttiin kohdistettu "räjähdys" tai mikä efekti lie.
        /// </summary>
        /// <param name="kaannetty">Kortti jonka päälle räjähdys tulee.</param>
        public void RajaytaKortti(Kortti kortti)
        {
            Image i = kortti.KuvaPuoliTekstuuri;
            ExplosionSystem e = new ExplosionSystem(i, 10);
            e.MinLifetime = 0.3;
            e.MaxLifetime = 1.5;
            e.MinVelocity = 1;
            e.MaxVelocity = 300;
            e.MinScale = 0.01;
            e.MaxScale = 0.05;
            Add(e);
            e.AddEffect(kortti.Position.X, kortti.Position.Y, 10);
        }

        public void VuoroVaihtuu()
        {
            if (vuorossaOlevaPelaaja.Equals(pelaaja1))
            {
                vuorossaOlevaPelaaja = pelaaja2;
                highlighter.Image = LoadImage("highlight2");
                vuoronaytto.Text = "Pelaaja 2";
                Level.BackgroundColor = pelaaja2.Vari;
                return;
            }

            if (vuorossaOlevaPelaaja.Equals(pelaaja2))
            {
                vuorossaOlevaPelaaja = pelaaja1;
                highlighter.Image = LoadImage("highlight1");
                vuoronaytto.Text = "Pelaaja 1";
                Level.BackgroundColor = pelaaja1.Vari;
                return;
            }
        }

        #endregion

        #region Kortit ruudulle

        /// <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 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 (montakoKorttia == montakoKorttiaLisatty)
                    {
                        kortit[r, s] = null;
                        continue;
                    }

                    kortit[r, s] = TeeKortti();
                    kortit[r, s].KuvaPuoliTekstuuri = Image.FromFile(korttisarja + "/" + kortit[r, s].Tunniste.ToString() + ".jpg");
                    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 takaTekstuuri = LoadImage("taka");
            int tunniste = AnnaTunniste();
            return new Kortti(kortinLeveys, kortinKorkeus, false, takaTekstuuri, tunniste);
        }

        private int AnnaTunniste()
        {
            int tunniste;
            while (true)
            {
                tunniste = RandomGen.NextInt(0, montakoKutakinKorttitunnusta.Length - 1);
                if (montakoKutakinKorttitunnusta[tunniste] < 2)
                {
                    montakoKutakinKorttitunnusta[tunniste]++;
                    break;
                }
            }
            return tunniste;
        }
        #endregion
    }
}