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

Revision 1482, 13.9 KB checked in by hniemi, 11 years ago (diff)

Tiedostoja karsittu, toteutusta yksinkertaistettu.
Lisätty intro, ja mahdollisuus lopettaa peli kesken ja aloittaa alusta. (Escape ja F2)

Line 
1using System;
2using Jypeli;
3using Jypeli.Widgets;
4using Jypeli.Assets;
5
6namespace JyTris
7{
8    /// <summary>
9    /// JyTris 0.1
10    ///
11    /// Peli on tetrisklooni, joka on tarkoituksena toteuttaa JyPelillä
12    /// mahdollisimman yksinkertaisesti.
13    ///
14    /// Seuraavana tulossa:
15    /// - Lisääntyvät pisteet
16    /// - Kuvat palikoille
17    /// </summary>
18    public class Peli : Game
19    {
20        const int leveys = 10;
21        const int korkeus = 26;
22        const int palikkojenSivu = 30;
23
24        GameObject[][] pelikentta;
25        TetrisPalikka aktiivinenPalikka;
26
27        Timer tiputusajastin;
28        double vaikeusaste = 0.9 ;
29
30        IntMeter pisteet = new IntMeter(0);
31        Label pistenaytto;
32
33        /*
34         * Introon tarvittavat muuttujat
35         */
36        Timer introajastin;
37        private int indeksi = 0;
38        private int suunta = 1;
39        private int vaihtoCounter = 0;
40
41        /// <summary>
42        /// Tekee pelin alkuvalmistelut
43        /// </summary>
44        protected override void Begin()
45        {
46            LuoPelikentta();
47            AlkuIntro();
48            AsetaMenuNappaimet();
49            //LuoHud();
50            //AsetaPeliNappaimet();
51            //KaynnistaPeli();
52        }
53
54        /// <summary>
55        /// Käynnistää alkuintron
56        /// </summary>
57        void AlkuIntro()
58        {
59            introajastin = new Timer();
60            introajastin.Interval = 0.05;
61            introajastin.Trigger += IntroPyoritys;
62            introajastin.Start();
63        }
64
65        /// <summary>
66        /// Pyörittää introa
67        /// </summary>
68        /// <param name="ajastin">Ei käytössä</param>
69        void IntroPyoritys(Timer ajastin)
70        {
71            TuhoaRivi(korkeus-1);
72
73            Color randomvari = RandomGen.NextColor();
74
75            for (int i = 0; i < pelikentta[0].Length; i++)
76            {
77                pelikentta[0][i].Color = randomvari;
78            }
79            pelikentta[0][indeksi].Color = Color.Brown;
80            indeksi += suunta;
81            vaihtoCounter++;
82            if (indeksi > leveys-1 && suunta > 0)
83            {
84                indeksi = 0;
85            }
86            if (indeksi < 0 && suunta < 0)
87            {
88                indeksi = leveys - 1;
89            }
90            if (vaihtoCounter > 50)
91            {
92                vaihtoCounter = 0;
93                suunta = -suunta;
94            }
95        }
96
97        /// <summary>
98        /// Käynnistää pelin
99        ///
100        /// Luo ensimmäisen palikan ja tekee ajastimen.
101        /// Tuhoaa myös kaikki valmiina olevat palikat.
102        ///
103        /// Poistaa asetetut kontrollit ja asettaa pelikontrollit.
104        ///
105        /// Resetoi vaikeusasteen!
106        /// </summary>
107        void KaynnistaPeli()
108        {
109            introajastin.Stop();
110            TuhoaKaikki();
111            ClearControls();
112            AsetaPeliNappaimet();
113
114            vaikeusaste = 0.9;
115            tiputusajastin = new Timer();
116            tiputusajastin.Interval = vaikeusaste;
117            tiputusajastin.Trigger += Laske;
118            tiputusajastin.Start();
119            LuoPalikka();
120        }
121
122        /// <summary>
123        /// Tuhoaa täydet rivit kentältä
124        /// </summary>
125        void TuhoaTaydet()
126        {
127            bool tyhjia;
128
129            for (int i = 0; i < pelikentta.Length; i++)
130            {
131                tyhjia = false;
132                for (int j = 0; j < pelikentta[i].Length; j++)
133                {
134                    if (pelikentta[i][j].Color == Color.TransparentWhite) tyhjia = true;
135                }
136
137                if (!tyhjia)
138                {
139                    TuhoaRivi(i);
140                }
141            }
142        }
143
144        /// <summary>
145        /// Tuhoaa kaikki palikat kentältä.
146        /// </summary>
147        void TuhoaKaikki()
148        {
149            //Tässä käydään lävitse kaikki laatikot ja asetetaan ne läpinäkyviksi.
150            for (int i = 0; i < pelikentta.Length; i++)
151            {
152                for (int j = 0; j < pelikentta[i].Length; j++)
153                {
154                    pelikentta[i][j].Color = Color.TransparentWhite;
155                }
156            }
157        }
158
159        /// <summary>
160        /// Tuhoaa indeksiä vastaavan rivin ja tiputtaa sen päällä olevia rivejä.
161        /// </summary>
162        /// <param name="rivinIndeksi">Tiputettavan rivin indeksi</param>
163        void TuhoaRivi(int rivinIndeksi)
164        {
165            if (rivinIndeksi > pelikentta.Length || rivinIndeksi < 0) return;
166
167            for (int i = rivinIndeksi; i > 0; i--)
168            {
169                for (int j = 0; j < pelikentta[i].Length; j++)
170                {
171                    pelikentta[i][j].Color = pelikentta[i - 1][j].Color;
172                }
173            }
174
175            for (int i = 0; i < pelikentta[0].Length; i++)
176            {
177                pelikentta[0][i].Color = Color.TransparentWhite;
178            }
179        }
180
181        void LuoHud()
182        {
183            pistenaytto = new Label(80, 20);
184            pistenaytto.BindTo(pisteet);
185            Add(pistenaytto);
186
187            //pistenaytto.Position.X = Screen.RightSafe - 40;
188        }
189
190        /// <summary>
191        /// Luo pelikentän ylhäällä määrätyistä vakioista
192        /// </summary>
193        void LuoPelikentta()
194        {
195            //Tässä säädetään pelialueen koko, jotta seinät tulevat oikeille kohdille
196            Level.Width = leveys * palikkojenSivu;// + leveys;
197            Level.Height = korkeus * palikkojenSivu;// + korkeus;
198            Level.CreateBorders(true);
199
200            /*
201             * Koska pelikenttä on kaksiulotteinen taulukko, joudumme luomaan
202             * ensiksi taulukon sarakkeet, jotta voimme luoda rivit.
203             */
204            pelikentta = new GameObject[korkeus][];
205            for (int i = 0; i < pelikentta.Length; i++)
206            {
207                pelikentta[i] = new GameObject[leveys];
208            }
209
210            //Tässä luodaan pelikentän "laatiko" ja sijoitetaan ne oikeille kohdilleen.
211            for (int i = 0; i < pelikentta.Length; i++)
212            {
213                for (int j = 0; j < pelikentta[i].Length; j++)
214                {
215                    pelikentta[i][j] = new GameObject(palikkojenSivu, palikkojenSivu, Shapes.Rectangle);
216                    pelikentta[i][j].Color = Color.TransparentWhite;
217                    pelikentta[i][j].X = Level.Left + (palikkojenSivu / 2) + j * (palikkojenSivu);
218                    pelikentta[i][j].Y = Level.Top - (palikkojenSivu / 2) - i * (palikkojenSivu);
219                    Add(pelikentta[i][j]);
220                }
221            }
222        }
223
224        /// <summary>
225        /// Asettaa pelin aikana tarvittavat näppäimet.
226        /// </summary>
227        void AsetaPeliNappaimet()
228        {
229            Vector vasemmalle = new Vector(-1, 0);
230            Vector oikealle = new Vector(1, 0);
231            Vector alas = new Vector(0, 1);
232
233            Keyboard.Listen(Key.Escape, ButtonState.Pressed, PeliLoppui, "Keskeyttää pelin");
234            Keyboard.Listen(Key.Left, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa vasemmalle", vasemmalle);
235            Keyboard.Listen(Key.Right, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa oikealle", oikealle);
236            Keyboard.Listen(Key.Down, ButtonState.Down, Laske, "Liikuttaa palikkaa alas", tiputusajastin);
237            Keyboard.Listen(Key.Up, ButtonState.Pressed, Kaanna, "Kääntää palikkaa");
238            Keyboard.Listen(Key.Space, ButtonState.Pressed, Tiputa, "Tiputtaa palikan");
239        }
240
241        /// <summary>
242        /// Asettaa menuissa käytettävät näppäimet
243        /// </summary>
244        void AsetaMenuNappaimet()
245        {
246            Keyboard.Listen(Key.Escape, ButtonState.Pressed, Exit, "Poistuu pelistä");
247            Keyboard.Listen(Key.F2, ButtonState.Pressed, KaynnistaPeli, "Aloittaa uuden pelin");
248        }
249
250        /// <summary>
251        /// Liikuttaa palikkaa halutun verran.
252        /// </summary>
253        /// <param name="suunta">X ja Y oltava kokonaislukuja.</param>
254        void Liikuta(Vector suunta)
255        {
256            PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite);
257
258            if (VoikoSiirtaa(suunta, aktiivinenPalikka))
259            {
260                aktiivinenPalikka.Liikuta(suunta);
261            }
262           
263            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
264        }
265
266        /// <summary>
267        /// Kääntää palikkaa
268        /// </summary>
269        void Kaanna()
270        {
271            PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite);
272
273            //Tämä kohta tarkistaa, voiko palikkaa kääntää
274            //Jos ei voi, niin poistutaan.
275            Vector[] tulevaSijainti = aktiivinenPalikka.TulevaKaanto();
276            for (int i = 0; i < tulevaSijainti.Length; i++)
277            {
278                if (!OnkoTyhja(tulevaSijainti[i])) 
279                {
280                    PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
281                    return;
282                } 
283            }
284
285            aktiivinenPalikka.Kaanna();
286            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
287        }
288
289        /// <summary>
290        /// Laskee palikkaa yhdellä. Jos palikkaa ei voi laskea,
291        /// lähettää uuden palikan.
292        /// </summary>
293        /// <param name="timer">Ei käytössä</param>
294        void Laske(Timer timer)
295        {
296            PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite);
297
298            tiputusajastin.Reset();
299            if (!VoikoSiirtaa(new Vector(0,1), aktiivinenPalikka))
300            {
301                PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
302                TuhoaTaydet();
303                LuoPalikka();
304                return;
305            }
306            aktiivinenPalikka.Liikuta(new Vector(0, 1));
307            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
308
309        }
310
311        /// <summary>
312        /// Tiputtaa palikkan kokonaan alas.
313        /// </summary>
314        void Tiputa()
315        {
316            TetrisPalikka palikka = aktiivinenPalikka;
317            while (aktiivinenPalikka == palikka) Laske(tiputusajastin);
318        }
319
320        /// <summary>
321        /// Tarkistaa, voiko palikalle suorittaa annetut siirrot
322        ///
323        /// Annetut siirrot siis lisätään niitä vastaaviin palikan
324        /// sijainteihin.
325        /// </summary>
326        /// <param name="siirrot">X- ja Y-arvot oltava kokonaislukuja</param>
327        /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param>
328        /// <returns>true, jos palikan siirtäminen on mahdollista</returns>
329        bool VoikoSiirtaa(Vector[] siirrot, TetrisPalikka palikka)
330        {
331            Vector[] sijainnit = palikka.Sijainti();
332
333            for (int i = 0; i < siirrot.Length; i++)
334            {
335                if (!OnkoTyhja(sijainnit[i] + siirrot[i])) return false;
336            }
337            return true;
338        }
339
340        /// <summary>
341        /// Tarkistaa voiko kaikkia palikan osia siirtää annetun
342        /// vektorin verran
343        /// </summary>
344        /// <param name="siirto">X- ja Y-arvo oltava kokonaislukuja</param>
345        /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param>
346        /// <returns>true, jos siirto on mahdollinen</returns>
347        bool VoikoSiirtaa(Vector siirto, TetrisPalikka palikka)
348        {
349            Vector[] siirrot = new Vector[4];
350            for (int i = 0; i < siirrot.Length; i++)
351            {
352                siirrot[i] = siirto;
353            }
354            return VoikoSiirtaa(siirrot, palikka);
355        }
356
357        /// <summary>
358        /// Tarkistaa, onko annetut paikka tyhjä
359        ///
360        /// Paikka on tyhjä, jos sen väri on Color.TransparentWhite
361        /// </summary>
362        /// <param name="paikka">X ja Y oltava kokonaislukuja</param>
363        /// <returns>true, jos paikka on tyhjä</returns>
364        bool OnkoTyhja(Vector paikka)
365        {
366            if (paikka.X > leveys-1 || paikka.X < 0) return false;
367            if (paikka.Y > korkeus-1 || paikka.Y < 0) return false;
368
369            if (pelikentta[(int)paikka.Y][(int)paikka.X].Color == Color.TransparentWhite) return true;
370            return false;
371        }
372
373        /// <summary>
374        /// Värittää paikkaa vastaavat laatikot annetulla värillä
375        /// </summary>
376        /// <param name="palikka">Tämän sijainti väritetään</param>
377        /// <param name="vari">Väri, jolla väritetään</param>
378        void PaivitaPalikka(TetrisPalikka palikka, Color vari)
379        {
380            Vector[] sijainnit = palikka.Sijainti();
381
382            for (int i = 0; i < sijainnit.Length; i++)
383            {
384                pelikentta[(int)sijainnit[i].Y][(int)sijainnit[i].X].Color = vari;
385            }
386        }
387
388        /// <summary>
389        /// Luo palikan keskelle ylälaitaa
390        ///
391        /// Tulee antamaan satunnaisen palikan
392        /// </summary>
393        void LuoPalikka()
394        {
395            aktiivinenPalikka = new TetrisPalikka(leveys / 2);
396            tiputusajastin.Reset();
397
398            Vector[] sijainnit = aktiivinenPalikka.Sijainti();
399            for (int i = 0; i < sijainnit.Length; i++)
400            {
401                if (!OnkoTyhja(sijainnit[i]))
402                {
403                    PeliLoppui();
404                    return;
405                }
406            }
407
408            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari());
409        }
410
411        /// <summary>
412        /// Lopettaa pelin.
413        /// - Palikkoja ei tipu
414        /// - Poistaa vanhat kontrollit
415        /// - Asettaa menunapit toimintaan
416        /// </summary>
417        void PeliLoppui()
418        {
419            tiputusajastin.Stop();
420            ClearControls();
421            AsetaMenuNappaimet();
422        }
423
424    }
425}
Note: See TracBrowser for help on using the repository browser.