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

Revision 2626, 28.3 KB checked in by hniemi, 8 years ago (diff)

Lisäilty tombstoningia, ei toimi vielä.

Line 
1using System;
2using Jypeli;
3using Jypeli.Widgets;
4using Jypeli.Assets;
5using Jypeli.WP7;
6
7namespace JyTris
8{
9    /// <summary>
10    /// JyTris 0.4
11    ///
12    /// Peli on tetrisklooni, joka on tarkoituksena toteuttaa JyPelillä
13    /// mahdollisimman yksinkertaisesti.
14    ///
15    /// Seuraavana tulossa:
16    /// - Kuvat palikoille
17    /// - Efektit palikkojen tuhoutumiseen
18    /// </summary>
19    public class Peli : Game
20    {
21        #region Muuttujat
22        private const string versio = "0.5";
23        private const string file = "state.xml";
24
25        private const int leveys = 10;
26        private const int korkeus = 26;
27        private const int palikkojenSivu = 30;
28
29        //Pelikenttä
30        private GameObject[][] pelikentta;
31        private GameObject[][] ennustuskentta;
32
33        private TetrisPalikka aktiivinenPalikka;
34        private TetrisPalikka ennustusPalikka;
35
36        private GameObject pausenappula;
37
38        //Liikutusvektorit
39        private Vector vasemmalle = new Vector(-1, 0);
40        private Vector oikealle = new Vector(1, 0);
41        private Vector alas = new Vector(0, 1);
42
43        private Timer tiputusajastin;
44
45        //Statistiikka
46        private double vaikeusaste = 0.9;
47        private IntMeter pisteet = new IntMeter(0);
48        private IntMeter taso = new IntMeter(0);
49
50        private int tuhotutRivit = 0;
51        private int pelinTila = 0;
52
53        //HighScoreList topLista;
54
55        private Label tasonaytto;
56        private Label pistenaytto;
57        private Label status;
58
59        /*
60         * Introon tarvittavat muuttujat
61         */
62        private Timer introajastin;
63
64        private int indeksi = 0;
65        private int suunta = 1;
66        private int vaihtoCounter = 0;
67        #endregion
68        #region Talletettavat
69        /// <summary>
70        /// Pelaajan pisteet
71        /// </summary>
72        public IntMeter Pisteet
73        {
74            get { return pisteet; }
75            set { pisteet = value; }
76        }
77
78        /// <summary>
79        /// Menossa oleva taso
80        /// </summary>
81        public IntMeter Taso
82        {
83            get { return taso; }
84            set { taso = value; }
85        }
86
87        /// <summary>
88        /// Tuhottujen rivien määrä
89        /// </summary>
90        public int TuhotutRivit
91        {
92            get { return tuhotutRivit; }
93            set { tuhotutRivit = value; }
94        }
95
96        /// <summary>
97        /// Pelikenttä
98        /// </summary>
99        public GameObject[][] Pelikentta
100        {
101            get { return pelikentta; }
102            set { pelikentta = value; }
103        }
104
105        /// <summary>
106        /// Palikka, joka tulee seuraavaksi
107        /// </summary>
108        public TetrisPalikka EnnustusPalikka
109        {
110            get { return ennustusPalikka; }
111            set { ennustusPalikka = value; }
112        }
113
114        /// <summary>
115        /// Ennustuskenttä, näyttää seuraavan palikan
116        /// </summary>
117        public GameObject[][] Ennustuskentta
118        {
119            get {
120                return ennustuskentta; 
121            }
122            set { ennustuskentta = value; }
123        }
124
125        /// <summary>
126        /// Aktiivinen palikka tällä hetkellä
127        /// </summary>
128        public TetrisPalikka AktiivinenPalikka
129        {
130            get { return aktiivinenPalikka; }
131            set { aktiivinenPalikka = value; }
132        }
133
134        /// <summary>
135        /// Pelin vaikeusaste tällä hetkellä
136        /// </summary>
137        public double Vaikeusaste
138        {
139            get { return vaikeusaste; }
140            set { vaikeusaste = value; }
141        }
142        #endregion
143
144        /// <summary>
145        /// Tekee pelin alkuvalmistelut
146        /// </summary>
147        public override void Begin()
148        {
149            LuoPelikentta();
150            AlkuIntro();
151            AsetaMenuNappaimet();
152            AsetaPistelista();
153            LuoHud();
154#if WINDOWS_PHONE
155            Puhelinasetukset();
156#endif
157        }
158
159
160
161        public void AsetaPistelista()
162        {
163            //topLista = HighScoreList.LoadOrCreate("topten.dat",10);
164        }
165
166        #region WP7-Metodit
167
168        /// <summary>
169        /// Palauttaa ohjelman tilan
170        /// </summary>
171        public override void Continue()
172        {
173            base.Continue();
174            Puhelinasetukset();
175            LoadState lataus = DataStorage.BeginLoad(file);
176            pelinTila = lataus.Load<int>(pelinTila, "pelinTila");
177
178            LuoPelikentta();
179            AsetaPistelista();
180            LuoHud();
181            //Jos peli ei ollut käynnissä
182            if (pelinTila == 0) 
183            {
184                AlkuIntro();
185            }
186
187            //Jos peli oli käynnissä
188            if (pelinTila == 1)
189            {
190                pelikentta = lataus.Load<GameObject[][]>(pelikentta, "pelikentta");
191                aktiivinenPalikka = new TetrisPalikka(4);
192                aktiivinenPalikka = lataus.Load<TetrisPalikka>(aktiivinenPalikka,"aktiivinenPalikka");
193
194                LuoHud();
195                ennustuskentta = lataus.Load<GameObject[][]>(ennustuskentta,"ennustuskentta" );
196
197                ennustusPalikka = new TetrisPalikka(4);
198                ennustusPalikka = lataus.Load<TetrisPalikka>(ennustusPalikka,"ennustusPalikka" );
199
200                taso = lataus.Load<IntMeter>(taso,"taso" );
201                pisteet = lataus.Load<IntMeter>(pisteet, "pisteet");
202                tuhotutRivit = lataus.Load<int>(tuhotutRivit, "tuhotutRivit");
203                vaikeusaste = lataus.Load<double>(vaikeusaste, "vaikeusaste");
204
205                LuoTiputusajastin();
206                tiputusajastin.Start();
207            }
208            lataus.EndLoad();
209           
210        }
211
212        /// <summary>
213        /// Asettaa näytön asennon ja zoomin kohilleen.
214        /// </summary>
215        public void Puhelinasetukset()
216        {
217            Phone.DisplayOrientation = Jypeli.WP7.DisplayOrientation.Portrait;
218            Camera.ZoomToLevel();
219            Camera.Zoom(0.9);
220            Camera.Move(new Vector(40, 0));
221            TouchPanel.Listen(ButtonState.Pressed, KasitteleKosketus, null);
222
223            Phone.Deactivated += TilaTalletus;
224        }
225
226        /// <summary>
227        /// Toimenpiteet, mitä tehdään, kun poistutaan pelistä
228        /// </summary>
229        public void TilaTalletus()
230        {
231            SaveState tallennus = DataStorage.BeginSave(file);
232
233            tallennus.Save<int>(pelinTila, "pelinTila");
234            if (pelinTila == 1) 
235            {
236                tallennus.Save<GameObject[][]>(pelikentta, "pelikentta");
237                tallennus.Save<GameObject[][]>(ennustuskentta, "ennustuskentta");
238                tallennus.Save<TetrisPalikka>(aktiivinenPalikka, "aktiivinenPalikka");
239                tallennus.Save<TetrisPalikka>(ennustusPalikka, "ennustusPalikka");
240                tallennus.Save<IntMeter>(taso, "taso");
241                tallennus.Save<IntMeter>(pisteet, "pisteet");
242                tallennus.Save<int>(tuhotutRivit, "tuhotutRivit");
243                tallennus.Save<double>(vaikeusaste, "vaikeusaste");
244            }
245            tallennus.EndSave();
246        }
247
248        /// <summary>
249        /// Käsittelee pelaamiseen liittyvät kosketukset (Palikan liikuttaminen)
250        /// </summary>
251        /// <param name="b">Käsiteltävä kosketus</param>
252        public void KasitteleLiikuntaKosketukset(Touch b)
253        {
254
255            if (b.PositionOnWorld.X < AnnaKoordinaateista(aktiivinenPalikka.Sijainti()[0]).Position.X - 30)
256            {
257                Liikuta(vasemmalle);
258                return;
259            }
260            if (b.PositionOnWorld.X > AnnaKoordinaateista(aktiivinenPalikka.Sijainti()[0]).Position.X + 30)
261            {
262                Liikuta(oikealle);
263                return;
264            }
265
266            if (b.PositionOnWorld.Y < AnnaKoordinaateista(aktiivinenPalikka.Sijainti()[0]).Position.Y - 20)
267            {
268                Liikuta(alas);
269                return;
270            }
271            else if (b.PositionOnWorld.Y > AnnaKoordinaateista(aktiivinenPalikka.Sijainti()[0]).Position.Y + 10)
272            {
273                Kaanna();
274                return;
275            }
276        }
277
278        public void PysaytaPhone(Touch b)
279        {
280            Pysayta(true);
281        }
282
283        /// <summary>
284        /// Käsittelee kosketuksen menussa
285        /// </summary>
286        /// <param name="b"></param>
287        public void KasitteleKosketus(Touch b)
288        {
289            if (tiputusajastin == null)
290            {
291                KaynnistaPeli();
292                return;
293            }
294        }
295
296        /// <summary>
297        /// Käsittelee pause-nappia painaneen kosketuksen
298        /// </summary>
299        /// <param name="b"></param>
300        public void KasittelePauseKosketus(Touch b)
301        {
302            Pysayta(false);
303        }
304        #endregion
305
306        #region Intro
307        /// <summary>
308        /// Luo introajastimen
309        /// </summary>
310        private void LuoIntroAjastin()
311        {
312            introajastin = new Timer();
313            introajastin.Interval = 0.05;
314            introajastin.Timeout += IntroPyoritys;
315        }
316
317        /// <summary>
318        /// Käynnistää alkuintron
319        /// </summary>
320        private void AlkuIntro()
321        {
322            LuoIntroAjastin();
323            introajastin.Start();
324        }
325
326        /// <summary>
327        /// Pyörittää introa
328        /// </summary>
329        /// <param name="ajastin">Ei käytössä</param>
330        private void IntroPyoritys()
331        {
332            TuhoaRivi(korkeus - 1);
333
334            Color randomvari = RandomGen.NextColor();
335
336            for (int i = 0; i < pelikentta[0].Length; i++)
337            {
338                pelikentta[0][i].Color = randomvari;
339            }
340            pelikentta[0][indeksi].Color = Color.Brown;
341            indeksi += suunta;
342            vaihtoCounter++;
343            if (indeksi > leveys - 1 && suunta > 0)
344            {
345                indeksi = 0;
346            }
347            if (indeksi < 0 && suunta < 0)
348            {
349                indeksi = leveys - 1;
350            }
351            if (vaihtoCounter > 50)
352            {
353                vaihtoCounter = 0;
354                suunta = -suunta;
355            }
356        }
357
358
359        #endregion
360        #region Pelialueen ja Hudin luominen
361        /// <summary>
362        /// Luo näyttöön pistenäytöt ja muut elementit.
363        /// </summary>
364        private void LuoHud()
365        {
366            Widget statistiikka = new Widget(120, 100);
367            statistiikka.Layout = new VerticalLayout();
368            Add(statistiikka);
369
370            Label pisteteksti = new Label("Pisteet:");
371            statistiikka.Add(pisteteksti);
372
373            pistenaytto = new Label();
374            pistenaytto.BindTo(pisteet);
375            statistiikka.Add(pistenaytto);
376
377            statistiikka.Position = new Vector(Level.Right + 120, Level.Top - 100);
378
379            Label tasoteksti = new Label("Taso:");
380            statistiikka.Add(tasoteksti);
381
382            tasonaytto = new Label(20, 20);
383            tasonaytto.BindTo(taso);
384            statistiikka.Add(tasonaytto);
385
386            status = new Label("JyTris " + versio);
387            Add(status);
388
389            pausenappula = new GameObject(50, 50);
390            pausenappula.Position = new Vector(Level.Right + 75, Level.Top - 25);
391            Add(pausenappula);
392
393            /*
394             * Koska ennustuskenttä on kaksiulotteinen taulukko, joudumme luomaan
395             * ensiksi taulukon sarakkeet, jotta voimme luoda rivit.
396             */
397            ennustuskentta = new GameObject[4][];
398            for (int i = 0; i < ennustuskentta.Length; i++)
399            {
400                ennustuskentta[i] = new GameObject[4];
401            }
402
403            //Tässä luodaan pelikentän "laatiko" ja sijoitetaan ne oikeille kohdilleen.
404            for (int i = 0; i < ennustuskentta.Length; i++)
405            {
406                for (int j = 0; j < ennustuskentta[i].Length; j++)
407                {
408                    ennustuskentta[i][j] = new GameObject(palikkojenSivu, palikkojenSivu, Shape.Rectangle);
409                    ennustuskentta[i][j].Color = Color.Transparent;
410                    ennustuskentta[i][j].X = Level.Right + 90 + (palikkojenSivu / 2) + j * (palikkojenSivu);
411                    ennustuskentta[i][j].Y = Level.Top - 200 - (palikkojenSivu / 2) - i * (palikkojenSivu);
412                    Add(ennustuskentta[i][j]);
413                }
414            }
415        }
416
417        /// <summary>
418        /// Asettaa ennustusnäytön näyttämään annettua palikkaa
419        /// </summary>
420        /// <param name="palikka">Näytettävä palikka</param>
421        private void AsetaEnnustusnaytto(TetrisPalikka palikka)
422        {
423            for (int i = 0; i < ennustuskentta.Length; i++)
424            {
425                for (int j = 0; j < ennustuskentta[i].Length; j++)
426                {
427                    ennustuskentta[i][j].Color = Color.Transparent;
428                }
429            }
430
431            Vector[] sijainnit = palikka.Sijainti();
432            int offset = -(leveys / 2) + 1;
433
434            foreach (Vector paikka in sijainnit)
435            {
436                ennustuskentta[(int)paikka.Y][(int)paikka.X + offset].Color = palikka.Vari();
437            }
438        }
439
440        /// <summary>
441        /// Luo pelikentän ylhäällä määrätyistä vakioista
442        /// </summary>
443        private void LuoPelikentta()
444        {
445            //Tässä säädetään pelialueen koko, jotta seinät tulevat oikeille kohdille
446            Level.Width = leveys * palikkojenSivu;// + leveys;
447            Level.Height = korkeus * palikkojenSivu;// + korkeus;
448            Level.CreateBorders(true);
449
450            /*
451             * Koska pelikenttä on kaksiulotteinen taulukko, joudumme luomaan
452             * ensiksi taulukon sarakkeet, jotta voimme luoda rivit.
453             */
454            pelikentta = new GameObject[korkeus][];
455            for (int i = 0; i < pelikentta.Length; i++)
456            {
457                pelikentta[i] = new GameObject[leveys];
458            }
459
460            //Tässä luodaan pelikentän "laatiko" ja sijoitetaan ne oikeille kohdilleen.
461            for (int i = 0; i < pelikentta.Length; i++)
462            {
463                for (int j = 0; j < pelikentta[i].Length; j++)
464                {
465                    pelikentta[i][j] = new GameObject(palikkojenSivu, palikkojenSivu, Shape.Rectangle);
466                    pelikentta[i][j].Color = Color.Transparent;
467                    pelikentta[i][j].X = Level.Left + (palikkojenSivu / 2) + j * (palikkojenSivu);
468                    pelikentta[i][j].Y = Level.Top - (palikkojenSivu / 2) - i * (palikkojenSivu);
469                    Add(pelikentta[i][j]);
470                }
471            }
472        }
473        #endregion
474        #region Kontrollit
475        /// <summary>
476        /// Asettaa pelin aikana tarvittavat näppäimet.
477        /// </summary>
478        private void AsetaPeliNappaimet()
479        {
480            Vector vasemmalle = new Vector(-1, 0);
481            Vector oikealle = new Vector(1, 0);
482            Vector alas = new Vector(0, 1);
483
484            Keyboard.Listen(Key.Escape, ButtonState.Pressed, PeliLoppui, "Keskeyttää pelin");
485            Keyboard.Listen(Key.Left, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa vasemmalle", vasemmalle);
486            Keyboard.Listen(Key.Right, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa oikealle", oikealle);
487            Keyboard.Listen(Key.Down, ButtonState.Down, Laske, "Liikuttaa palikkaa alas");
488            Keyboard.Listen(Key.Up, ButtonState.Pressed, Kaanna, "Kääntää palikkaa");
489            Keyboard.Listen(Key.Space, ButtonState.Pressed, Tiputa, "Tiputtaa palikan");
490            Keyboard.Listen(Key.P, ButtonState.Pressed, Pysayta, "Pysayttaa pelin", true);
491            TouchPanel.Listen(ButtonState.Pressed, KasitteleLiikuntaKosketukset, null);
492            TouchPanel.ListenOn(pausenappula, ButtonState.Down, PysaytaPhone ,null);
493
494        }
495
496        private void AsetaTaukoNappaimet()
497        {
498            Keyboard.Listen(Key.P, ButtonState.Pressed, Pysayta, "Jatkaa peliä", false);
499            TouchPanel.Listen(ButtonState.Pressed, KasittelePauseKosketus, null);
500        }
501
502        /// <summary>
503        /// Asettaa menuissa käytettävät näppäimet
504        /// </summary>
505        private void AsetaMenuNappaimet()
506        {
507            Keyboard.Listen(Key.Escape, ButtonState.Pressed, Exit, "Poistuu pelistä");
508            Keyboard.Listen(Key.F2, ButtonState.Pressed, KaynnistaPeli, "Aloittaa uuden pelin");
509            TouchPanel.Listen(ButtonState.Pressed, KasitteleKosketus, null);
510        }
511        #endregion
512        #region Palikan siirtämiseen liittyvät
513        /// <summary>
514        /// Liikuttaa palikkaa halutun verran.
515        /// </summary>
516        /// <param name="suunta">X ja Y oltava kokonaislukuja.</param>
517        private void Liikuta(Vector suunta)
518        {
519            PaivitaPalikka(aktiivinenPalikka, Color.Transparent);
520
521            if (VoikoSiirtaa(suunta, aktiivinenPalikka))
522            {
523                aktiivinenPalikka.Liikuta(suunta);
524            }
525
526            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
527        }
528
529        /// <summary>
530        /// Kääntää palikkaa
531        /// </summary>
532        private void Kaanna()
533        {
534            PaivitaPalikka(aktiivinenPalikka, Color.Transparent);
535
536            //Tämä kohta tarkistaa, voiko palikkaa kääntää
537            //Jos ei voi, niin poistutaan.
538            Vector[] tulevaSijainti = aktiivinenPalikka.TulevaKaanto();
539            for (int i = 0; i < tulevaSijainti.Length; i++)
540            {
541                if (!OnkoTyhja(tulevaSijainti[i]))
542                {
543                    PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
544                    return;
545                }
546            }
547
548            aktiivinenPalikka.Kaanna();
549            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
550        }
551
552        /// <summary>
553        /// Laskee palikkaa yhdellä. Jos palikkaa ei voi laskea,
554        /// lähettää uuden palikan.
555        /// </summary>
556        /// <param name="timer">Ei käytössä</param>
557        private void Laske()
558        {
559            PaivitaPalikka(aktiivinenPalikka, Color.Transparent);
560
561            tiputusajastin.Reset();
562            if (!VoikoSiirtaa(new Vector(0, 1), aktiivinenPalikka))
563            {
564                PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
565                TuhoaTaydet();
566                LuoPalikka();
567                return;
568            }
569            aktiivinenPalikka.Liikuta(new Vector(0, 1));
570            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
571
572        }
573
574        /// <summary>
575        /// Tiputtaa palikkan kokonaan alas.
576        /// </summary>
577        private void Tiputa()
578        {
579            //Lasketaan, kunnes ei ole sama palikka ohjattavana.
580            TetrisPalikka palikka = aktiivinenPalikka;
581            while (aktiivinenPalikka == palikka) Laske();
582        }
583
584        /// <summary>
585        /// Tarkistaa, voiko palikalle suorittaa annetut siirrot
586        ///
587        /// Annetut siirrot siis lisätään niitä vastaaviin palikan
588        /// sijainteihin.
589        /// </summary>
590        /// <param name="siirrot">X- ja Y-arvot oltava kokonaislukuja</param>
591        /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param>
592        /// <returns>true, jos palikan siirtäminen on mahdollista</returns>
593        private bool VoikoSiirtaa(Vector[] siirrot, TetrisPalikka palikka)
594        {
595            Vector[] sijainnit = palikka.Sijainti();
596
597            for (int i = 0; i < siirrot.Length; i++)
598            {
599                if (!OnkoTyhja(sijainnit[i] + siirrot[i])) return false;
600            }
601            return true;
602        }
603
604        /// <summary>
605        /// Tarkistaa voiko kaikkia palikan osia siirtää annetun
606        /// vektorin verran
607        /// </summary>
608        /// <param name="siirto">X- ja Y-arvo oltava kokonaislukuja</param>
609        /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param>
610        /// <returns>true, jos siirto on mahdollinen</returns>
611        private bool VoikoSiirtaa(Vector siirto, TetrisPalikka palikka)
612        {
613            Vector[] siirrot = new Vector[4];
614            for (int i = 0; i < siirrot.Length; i++)
615            {
616                siirrot[i] = siirto;
617            }
618            return VoikoSiirtaa(siirrot, palikka);
619        }
620
621        /// <summary>
622        /// Tarkistaa, onko annetut paikka tyhjä
623        ///
624        /// Paikka on tyhjä, jos sen väri on Color.Transparent
625        /// </summary>
626        /// <param name="paikka">X ja Y oltava kokonaislukuja</param>
627        /// <returns>true, jos paikka on tyhjä</returns>
628        private bool OnkoTyhja(Vector paikka)
629        {
630            if (paikka.X > leveys - 1 || paikka.X < 0) return false;
631            if (paikka.Y > korkeus - 1 || paikka.Y < 0) return false;
632
633            if (pelikentta[(int)paikka.Y][(int)paikka.X].Color == Color.Transparent) return true;
634            return false;
635        }
636
637        /// <summary>
638        /// Värittää paikkaa vastaavat laatikot annetulla värillä
639        /// </summary>
640        /// <param name="palikka">Tämän sijainti väritetään</param>
641        /// <param name="vari">Väri, jolla väritetään</param>
642        private void PaivitaPalikka(TetrisPalikka palikka, Color vari)
643        {
644            Vector[] sijainnit = palikka.Sijainti();
645
646            for (int i = 0; i < sijainnit.Length; i++)
647            {
648                pelikentta[(int)sijainnit[i].Y][(int)sijainnit[i].X].Color = vari;
649            }
650        }
651
652        /// <summary>
653        /// Antaa gameobjectin, joka vastaa taulukon koordinaatteja (0,1,2...)
654        ///
655        /// Ei vastaa näytön koordinaatteja!
656        /// </summary>
657        /// <param name="koordinaatit">Haluttu koordinaatti</param>
658        /// <returns>Gameobject, joka vastaa koordinaatteja</returns>
659        private GameObject AnnaKoordinaateista(Vector koordinaatit)
660        {
661            return pelikentta[(int)Math.Round(koordinaatit.Y)][(int)Math.Round(koordinaatit.X)];
662        }
663        #endregion
664        #region Pelilogiikka
665        /// <summary>
666        /// Luo palikan keskelle ylälaitaa
667        ///
668        /// Tulee antamaan satunnaisen palikan
669        /// </summary>
670        private void LuoPalikka()
671        {
672            //Luo uuden palikan ja siirtää ennustuspalikan aktiiviseksi
673            //ennustusPalikka = new TetrisPalikka(leveys / 2);
674            if (aktiivinenPalikka != null)
675            {
676                aktiivinenPalikka = ennustusPalikka;
677            }
678            else
679            {
680                aktiivinenPalikka = new TetrisPalikka(leveys / 2);
681            }
682
683            ennustusPalikka = new TetrisPalikka(leveys / 2);
684
685            AsetaEnnustusnaytto(ennustusPalikka);
686
687            tiputusajastin.Reset();
688
689            Vector[] sijainnit = aktiivinenPalikka.Sijainti();
690            for (int i = 0; i < sijainnit.Length; i++)
691            {
692                if (!OnkoTyhja(sijainnit[i]))
693                {
694                    PeliLoppui();
695                    return;
696                }
697            }
698
699            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
700        }
701
702        /// <summary>
703        /// Käynnistää pelin
704        ///
705        /// Luo ensimmäisen palikan ja tekee ajastimen.
706        /// Tuhoaa myös kaikki valmiina olevat palikat.
707        ///
708        /// Poistaa asetetut kontrollit ja asettaa pelikontrollit.
709        ///
710        /// Resetoi vaikeusasteen!
711        /// </summary>
712        private void KaynnistaPeli()
713        {
714            status.Color = Color.Transparent;
715            status.TextColor = Color.Transparent;
716            pelinTila = 1;
717            pisteet.Value = 0;
718            taso.Value = 1;
719            tuhotutRivit = 0;
720            introajastin.Stop();
721            TuhoaKaikki();
722            ClearControls();
723            AsetaPeliNappaimet();
724
725
726            /*
727            if (purkkabool)
728            {
729                topLista.Hide();
730                purkkabool = false;
731            }
732            */
733            vaikeusaste = 0.9;
734            LuoTiputusajastin();
735            tiputusajastin.Start();
736            LuoPalikka();
737        }
738
739        /// <summary>
740        /// Luo ajastimen, joka tiputtaa palikoita
741        /// </summary>
742        private void LuoTiputusajastin() 
743        {
744            tiputusajastin = new Timer();
745            tiputusajastin.Interval = vaikeusaste;
746            tiputusajastin.Timeout += Laske;
747        }
748
749        /// <summary>
750        /// Tauottaa pelin
751        ///
752        /// false-arvolla jatkaa peliä
753        /// </summary>
754        /// <param name="pysaytetaan">true, jos peli halutaan pysäyttää</param>
755        private void Pysayta(bool pysaytetaan)
756        {
757            if (pysaytetaan)
758            {
759                tiputusajastin.Stop();
760                ClearControls();
761                AsetaTaukoNappaimet();
762                status.Text = "Peli pysaytetty";
763                status.TextColor = Color.Beige;
764                return;
765            }
766            status.TextColor = Color.Transparent;
767            tiputusajastin.Start();
768            ClearControls();
769            AsetaPeliNappaimet();
770        }
771
772
773        /// <summary>
774        /// Tuhoaa täydet rivit kentältä
775        /// </summary>
776        private void TuhoaTaydet()
777        {
778            bool tyhjia;
779            int potti = 0;
780
781
782            for (int i = 0; i < pelikentta.Length; i++)
783            {
784                tyhjia = false;
785                for (int j = 0; j < pelikentta[i].Length; j++)
786                {
787                    if (pelikentta[i][j].Color == Color.Transparent) tyhjia = true;
788                }
789
790                if (!tyhjia)
791                {
792                    potti += 10;
793                    TuhoaRivi(i);
794                }
795            }
796
797            pisteet.Value += (potti / 10) * taso * potti;
798
799            if (tuhotutRivit > 10)
800            {
801                tuhotutRivit -= 10;
802                tiputusajastin.Interval -= 0.1;
803                taso.Value++;
804            }
805        }
806
807        /// <summary>
808        /// Tuhoaa kaikki palikat kentältä.
809        /// </summary>
810        private void TuhoaKaikki()
811        {
812            //Tässä käydään lävitse kaikki laatikot ja asetetaan ne läpinäkyviksi.
813            for (int i = 0; i < pelikentta.Length; i++)
814            {
815                for (int j = 0; j < pelikentta[i].Length; j++)
816                {
817                    pelikentta[i][j].Color = Color.Transparent;
818                }
819            }
820        }
821
822        /// <summary>
823        /// Tuhoaa indeksiä vastaavan rivin ja tiputtaa sen päällä olevia rivejä.
824        /// </summary>
825        /// <param name="rivinIndeksi">Tiputettavan rivin indeksi</param>
826        private void TuhoaRivi(int rivinIndeksi)
827        {
828            if (rivinIndeksi > pelikentta.Length || rivinIndeksi < 0) return;
829            tuhotutRivit++;
830
831            for (int i = rivinIndeksi; i > 0; i--)
832            {
833                for (int j = 0; j < pelikentta[i].Length; j++)
834                {
835                    pelikentta[i][j].Color = pelikentta[i - 1][j].Color;
836                }
837            }
838
839            for (int i = 0; i < pelikentta[0].Length; i++)
840            {
841                pelikentta[0][i].Color = Color.Transparent;
842            }
843        }
844
845        /// <summary>
846        /// Lopettaa pelin.
847        /// - Palikkoja ei tipu
848        /// - Poistaa vanhat kontrollit
849        /// - Asettaa menunapit toimintaan
850        /// </summary>
851        private void PeliLoppui()
852        {
853            tiputusajastin.Stop();
854            status.Text = "Hävisit pelin!";
855            //status.Image = LoadImage("peliloppu");
856            status.TextColor = Color.Beige;
857            //topLista.Show(pisteet.Value);
858            //purkkabool = true;
859            ClearControls();
860            AsetaMenuNappaimet();
861        }
862        #endregion
863
864       
865    }
866}
Note: See TracBrowser for help on using the repository browser.