Changeset 1515 for 2010/23


Ignore:
Timestamp:
2010-08-02 14:43:51 (9 years ago)
Author:
hniemi
Message:

Lisätty viimeinen puuttuva palikka ja tekstejä

Location:
2010/23/hniemi/JyTris/JyTris
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • 2010/23/hniemi/JyTris/JyTris/Content/obj/x86/Debug/Content.contentproj.FileListAbsolute.txt

    r1489 r1515  
    22D:\Opiskelu\kurssit\NPO2010\Jytris\Content\obj\x86\Debug\ResolveAssemblyReference.cache 
    33C:\MyTemp\npo_pelit\2010\23\hniemi\JyTris\JyTris\Content\obj\x86\Debug\ResolveAssemblyReference.cache 
     4C:\MyTemp\hniemi\JyTris\JyTris\Content\obj\x86\Debug\ResolveAssemblyReference.cache 
  • 2010/23/hniemi/JyTris/JyTris/Content/obj/x86/Debug/ContentPipeline.xml

    r1489 r1515  
    77      <BuildConfiguration>Debug</BuildConfiguration> 
    88      <CompressContent>false</CompressContent> 
    9       <RootDirectory>C:\MyTemp\npo_pelit\2010\23\hniemi\JyTris\JyTris\Content\</RootDirectory> 
    10       <LoggerRootDirectory>C:\MyTemp\npo_pelit\2010\23\hniemi\JyTris\JyTris\</LoggerRootDirectory> 
    11       <IntermediateDirectory>C:\MyTemp\npo_pelit\2010\23\hniemi\JyTris\JyTris\Content\obj\x86\Debug\</IntermediateDirectory> 
    12       <OutputDirectory>C:\MyTemp\npo_pelit\2010\23\hniemi\JyTris\JyTris\bin\x86\Debug\Content\</OutputDirectory> 
     9      <RootDirectory>C:\MyTemp\hniemi\JyTris\JyTris\Content\</RootDirectory> 
     10      <LoggerRootDirectory>C:\MyTemp\hniemi\JyTris\JyTris\</LoggerRootDirectory> 
     11      <IntermediateDirectory>C:\MyTemp\hniemi\JyTris\JyTris\Content\obj\x86\Debug\</IntermediateDirectory> 
     12      <OutputDirectory>C:\MyTemp\hniemi\JyTris\JyTris\bin\x86\Debug\Content\</OutputDirectory> 
    1313    </Settings> 
    1414    <Assemblies> 
    1515      <Assembly> 
    1616        <Key>C:\WINNT\assembly\GAC_32\Microsoft.Xna.Framework.Content.Pipeline\3.1.0.0__6d5c3888ef60e27d\Microsoft.Xna.Framework.Content.Pipeline.dll</Key> 
    17         <Value>2009-06-23T14:25:04.7477463+03:00</Value> 
     17        <Value>2010-06-02T21:12:43.8331254+03:00</Value> 
    1818      </Assembly> 
    1919    </Assemblies> 
  • 2010/23/hniemi/JyTris/JyTris/Peli.cs

    r1489 r1515  
    77{ 
    88    /// <summary> 
    9     /// JyTris 0.2 
     9    /// JyTris 0.3 
    1010    ///  
    1111    /// Peli on tetrisklooni, joka on tarkoituksena toteuttaa JyPelillä 
     
    2020    public class Peli : Game 
    2121    { 
     22        #region Muuttujat 
     23        private string versio = "0.3"; 
     24 
    2225        const int leveys = 10; 
    2326        const int korkeus = 26; 
     
    3942        Label tasonaytto; 
    4043        Label pistenaytto; 
     44        Label status; 
    4145 
    4246        /* 
     
    4852        private int vaihtoCounter = 0; 
    4953 
     54        #endregion 
     55 
    5056        /// <summary> 
    5157        /// Tekee pelin alkuvalmistelut 
     
    6167        } 
    6268 
     69        #region Intro 
    6370        /// <summary> 
    6471        /// Käynnistää alkuintron 
     
    104111        } 
    105112 
     113 
     114        #endregion 
     115        #region Pelialueen ja Hudin luominen 
     116        /// <summary> 
     117        /// Luo näyttöön pistenäytöt ja muut elementit. 
     118        /// </summary> 
     119        void LuoHud() 
     120        { 
     121            pistenaytto = new Label(80, 20); 
     122            pistenaytto.BindTo(pisteet); 
     123            pistenaytto.Position = new Vector(Screen.RightSafe - 200, Screen.TopSafe - 100); 
     124            //pistenaytto.Text = "Pisteet: "; 
     125            Add(pistenaytto); 
     126 
     127            tasonaytto = new Label(20, 20); 
     128            tasonaytto.BindTo(taso); 
     129            tasonaytto.Position = new Vector(Screen.RightSafe - 200, Screen.TopSafe - 125); 
     130            //tasonaytto.Text = "Taso: "; 
     131            //tasonaytto. 
     132            Add(tasonaytto); 
     133 
     134            status = new Label("JyTris " + versio); 
     135            Add(status); 
     136 
     137            /* 
     138             * Koska ennustuskenttä on kaksiulotteinen taulukko, joudumme luomaan 
     139             * ensiksi taulukon sarakkeet, jotta voimme luoda rivit. 
     140             */ 
     141            ennustuskentta = new GameObject[4][]; 
     142            for (int i = 0; i < ennustuskentta.Length; i++) 
     143            { 
     144                ennustuskentta[i] = new GameObject[4]; 
     145            } 
     146 
     147            //Tässä luodaan pelikentän "laatiko" ja sijoitetaan ne oikeille kohdilleen. 
     148            for (int i = 0; i < ennustuskentta.Length; i++) 
     149            { 
     150                for (int j = 0; j < ennustuskentta[i].Length; j++) 
     151                { 
     152                    ennustuskentta[i][j] = new GameObject(palikkojenSivu, palikkojenSivu, Shapes.Rectangle); 
     153                    ennustuskentta[i][j].Color = Color.TransparentWhite; 
     154                    ennustuskentta[i][j].X = Level.Right + 100 + (palikkojenSivu / 2) + j * (palikkojenSivu); 
     155                    ennustuskentta[i][j].Y = Screen.TopSafe -200 - (palikkojenSivu / 2) - i * (palikkojenSivu); 
     156                    Add(ennustuskentta[i][j]); 
     157                } 
     158            } 
     159        } 
     160 
     161        /// <summary> 
     162        /// Asettaa ennustusnäytön näyttämään annettua palikkaa 
     163        /// </summary> 
     164        /// <param name="palikka">Näytettävä palikka</param> 
     165        void AsetaEnnustusnaytto(TetrisPalikka palikka) 
     166        { 
     167            for (int i = 0; i < ennustuskentta.Length; i++) 
     168            { 
     169                for (int j = 0; j < ennustuskentta[i].Length; j++) 
     170                { 
     171                    ennustuskentta[i][j].Color = Color.TransparentWhite; 
     172                } 
     173            } 
     174 
     175            Vector[] sijainnit = palikka.Sijainti(); 
     176            int offset = -(leveys / 2) + 1; 
     177 
     178            foreach (Vector paikka in sijainnit) 
     179            { 
     180                ennustuskentta[(int)paikka.Y][(int)paikka.X + offset].Color = palikka.Vari(); 
     181            } 
     182        } 
     183 
     184        /// <summary> 
     185        /// Luo pelikentän ylhäällä määrätyistä vakioista 
     186        /// </summary> 
     187        void LuoPelikentta() 
     188        { 
     189            //Tässä säädetään pelialueen koko, jotta seinät tulevat oikeille kohdille 
     190            Level.Width = leveys * palikkojenSivu;// + leveys; 
     191            Level.Height = korkeus * palikkojenSivu;// + korkeus; 
     192            Level.CreateBorders(true); 
     193 
     194            /* 
     195             * Koska pelikenttä on kaksiulotteinen taulukko, joudumme luomaan 
     196             * ensiksi taulukon sarakkeet, jotta voimme luoda rivit. 
     197             */ 
     198            pelikentta = new GameObject[korkeus][]; 
     199            for (int i = 0; i < pelikentta.Length; i++) 
     200            { 
     201                pelikentta[i] = new GameObject[leveys]; 
     202            } 
     203 
     204            //Tässä luodaan pelikentän "laatiko" ja sijoitetaan ne oikeille kohdilleen. 
     205            for (int i = 0; i < pelikentta.Length; i++) 
     206            { 
     207                for (int j = 0; j < pelikentta[i].Length; j++) 
     208                { 
     209                    pelikentta[i][j] = new GameObject(palikkojenSivu, palikkojenSivu, Shapes.Rectangle); 
     210                    pelikentta[i][j].Color = Color.TransparentWhite; 
     211                    pelikentta[i][j].X = Level.Left + (palikkojenSivu / 2) + j * (palikkojenSivu); 
     212                    pelikentta[i][j].Y = Level.Top - (palikkojenSivu / 2) - i * (palikkojenSivu); 
     213                    Add(pelikentta[i][j]); 
     214                } 
     215            } 
     216        } 
     217        #endregion 
     218        #region Kontrollit 
     219        /// <summary> 
     220        /// Asettaa pelin aikana tarvittavat näppäimet. 
     221        /// </summary> 
     222        void AsetaPeliNappaimet() 
     223        { 
     224            Vector vasemmalle = new Vector(-1, 0); 
     225            Vector oikealle = new Vector(1, 0); 
     226            Vector alas = new Vector(0, 1); 
     227 
     228            Keyboard.Listen(Key.Escape, ButtonState.Pressed, PeliLoppui, "Keskeyttää pelin"); 
     229            Keyboard.Listen(Key.Left, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa vasemmalle", vasemmalle); 
     230            Keyboard.Listen(Key.Right, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa oikealle", oikealle); 
     231            Keyboard.Listen(Key.Down, ButtonState.Down, Laske, "Liikuttaa palikkaa alas", tiputusajastin); 
     232            Keyboard.Listen(Key.Up, ButtonState.Pressed, Kaanna, "Kääntää palikkaa"); 
     233            Keyboard.Listen(Key.Space, ButtonState.Pressed, Tiputa, "Tiputtaa palikan"); 
     234            Keyboard.Listen(Key.P, ButtonState.Pressed, Pysayta, "Pysayttaa pelin", true); 
     235        } 
     236 
     237        void AsetaTaukoNappaimet() 
     238        { 
     239            Keyboard.Listen(Key.P, ButtonState.Pressed, Pysayta, "Jatkaa peliä", false); 
     240        } 
     241 
     242        /// <summary> 
     243        /// Asettaa menuissa käytettävät näppäimet 
     244        /// </summary> 
     245        void AsetaMenuNappaimet() 
     246        { 
     247            Keyboard.Listen(Key.Escape, ButtonState.Pressed, Exit, "Poistuu pelistä"); 
     248            Keyboard.Listen(Key.F2, ButtonState.Pressed, KaynnistaPeli, "Aloittaa uuden pelin"); 
     249        } 
     250        #endregion 
     251        #region Palikan siirtämiseen liittyvät 
     252        /// <summary> 
     253        /// Liikuttaa palikkaa halutun verran. 
     254        /// </summary> 
     255        /// <param name="suunta">X ja Y oltava kokonaislukuja.</param> 
     256        void Liikuta(Vector suunta) 
     257        { 
     258            PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite); 
     259 
     260            if (VoikoSiirtaa(suunta, aktiivinenPalikka)) 
     261            { 
     262                aktiivinenPalikka.Liikuta(suunta); 
     263            } 
     264             
     265            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
     266        } 
     267 
     268        /// <summary> 
     269        /// Kääntää palikkaa 
     270        /// </summary> 
     271        void Kaanna() 
     272        { 
     273            PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite); 
     274 
     275            //Tämä kohta tarkistaa, voiko palikkaa kääntää 
     276            //Jos ei voi, niin poistutaan. 
     277            Vector[] tulevaSijainti = aktiivinenPalikka.TulevaKaanto(); 
     278            for (int i = 0; i < tulevaSijainti.Length; i++) 
     279            { 
     280                if (!OnkoTyhja(tulevaSijainti[i]))  
     281                { 
     282                    PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
     283                    return; 
     284                }  
     285            } 
     286 
     287            aktiivinenPalikka.Kaanna(); 
     288            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
     289        } 
     290 
     291        /// <summary> 
     292        /// Laskee palikkaa yhdellä. Jos palikkaa ei voi laskea, 
     293        /// lähettää uuden palikan. 
     294        /// </summary> 
     295        /// <param name="timer">Ei käytössä</param> 
     296        void Laske(Timer timer) 
     297        { 
     298            PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite); 
     299 
     300            tiputusajastin.Reset(); 
     301            if (!VoikoSiirtaa(new Vector(0,1), aktiivinenPalikka)) 
     302            { 
     303                PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
     304                TuhoaTaydet(); 
     305                LuoPalikka(); 
     306                return; 
     307            } 
     308            aktiivinenPalikka.Liikuta(new Vector(0, 1)); 
     309            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
     310 
     311        } 
     312 
     313        /// <summary> 
     314        /// Tiputtaa palikkan kokonaan alas. 
     315        /// </summary> 
     316        void Tiputa() 
     317        { 
     318            TetrisPalikka palikka = aktiivinenPalikka; 
     319            while (aktiivinenPalikka == palikka) Laske(tiputusajastin); 
     320        } 
     321 
     322        /// <summary> 
     323        /// Tarkistaa, voiko palikalle suorittaa annetut siirrot 
     324        ///  
     325        /// Annetut siirrot siis lisätään niitä vastaaviin palikan 
     326        /// sijainteihin. 
     327        /// </summary> 
     328        /// <param name="siirrot">X- ja Y-arvot oltava kokonaislukuja</param> 
     329        /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param> 
     330        /// <returns>true, jos palikan siirtäminen on mahdollista</returns> 
     331        bool VoikoSiirtaa(Vector[] siirrot, TetrisPalikka palikka) 
     332        { 
     333            Vector[] sijainnit = palikka.Sijainti(); 
     334 
     335            for (int i = 0; i < siirrot.Length; i++) 
     336            { 
     337                if (!OnkoTyhja(sijainnit[i] + siirrot[i])) return false; 
     338            } 
     339            return true; 
     340        } 
     341 
     342        /// <summary> 
     343        /// Tarkistaa voiko kaikkia palikan osia siirtää annetun 
     344        /// vektorin verran 
     345        /// </summary> 
     346        /// <param name="siirto">X- ja Y-arvo oltava kokonaislukuja</param> 
     347        /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param> 
     348        /// <returns>true, jos siirto on mahdollinen</returns> 
     349        bool VoikoSiirtaa(Vector siirto, TetrisPalikka palikka) 
     350        { 
     351            Vector[] siirrot = new Vector[4]; 
     352            for (int i = 0; i < siirrot.Length; i++) 
     353            { 
     354                siirrot[i] = siirto; 
     355            } 
     356            return VoikoSiirtaa(siirrot, palikka); 
     357        } 
     358 
     359        /// <summary> 
     360        /// Tarkistaa, onko annetut paikka tyhjä 
     361        ///  
     362        /// Paikka on tyhjä, jos sen väri on Color.TransparentWhite 
     363        /// </summary> 
     364        /// <param name="paikka">X ja Y oltava kokonaislukuja</param> 
     365        /// <returns>true, jos paikka on tyhjä</returns> 
     366        bool OnkoTyhja(Vector paikka) 
     367        { 
     368            if (paikka.X > leveys-1 || paikka.X < 0) return false; 
     369            if (paikka.Y > korkeus-1 || paikka.Y < 0) return false; 
     370 
     371            if (pelikentta[(int)paikka.Y][(int)paikka.X].Color == Color.TransparentWhite) return true; 
     372            return false; 
     373        } 
     374 
     375        /// <summary> 
     376        /// Värittää paikkaa vastaavat laatikot annetulla värillä 
     377        /// </summary> 
     378        /// <param name="palikka">Tämän sijainti väritetään</param> 
     379        /// <param name="vari">Väri, jolla väritetään</param> 
     380        void PaivitaPalikka(TetrisPalikka palikka, Color vari) 
     381        { 
     382            Vector[] sijainnit = palikka.Sijainti(); 
     383 
     384            for (int i = 0; i < sijainnit.Length; i++) 
     385            { 
     386                pelikentta[(int)sijainnit[i].Y][(int)sijainnit[i].X].Color = vari; 
     387            } 
     388        } 
     389        #endregion 
     390        #region Pelilogiikka 
     391        /// <summary> 
     392        /// Luo palikan keskelle ylälaitaa 
     393        ///  
     394        /// Tulee antamaan satunnaisen palikan 
     395        /// </summary> 
     396        void LuoPalikka() 
     397        { 
     398            //Luo uuden palikan ja siirtää ennustuspalikan aktiiviseksi 
     399            //ennustusPalikka = new TetrisPalikka(leveys / 2); 
     400            if (aktiivinenPalikka != null) 
     401            { 
     402                aktiivinenPalikka = ennustusPalikka; 
     403            } 
     404            else  
     405            {  
     406                aktiivinenPalikka = new TetrisPalikka(leveys / 2);  
     407            } 
     408 
     409            ennustusPalikka = new TetrisPalikka(leveys / 2); 
     410 
     411            AsetaEnnustusnaytto(ennustusPalikka); 
     412 
     413            tiputusajastin.Reset(); 
     414 
     415            Vector[] sijainnit = aktiivinenPalikka.Sijainti(); 
     416            for (int i = 0; i < sijainnit.Length; i++) 
     417            { 
     418                if (!OnkoTyhja(sijainnit[i])) 
     419                { 
     420                    PeliLoppui(); 
     421                    return; 
     422                } 
     423            } 
     424 
     425            PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
     426        } 
     427 
    106428        /// <summary> 
    107429        /// Käynnistää pelin 
     
    116438        void KaynnistaPeli() 
    117439        { 
     440            status.IsVisible = false; 
    118441            pisteet.Value = 0; 
    119442            taso.Value = 1; 
     
    133456 
    134457        /// <summary> 
     458        /// Tauottaa pelin 
     459        ///  
     460        /// false-arvolla jatkaa peliä 
     461        /// </summary> 
     462        /// <param name="pysaytetaan">true, jos peli halutaan pysäyttää</param> 
     463        void Pysayta(bool pysaytetaan) 
     464        { 
     465            if (pysaytetaan) 
     466            { 
     467                tiputusajastin.Stop(); 
     468                ClearControls(); 
     469                AsetaTaukoNappaimet(); 
     470                status.Text = "Peli pysaytetty"; 
     471                status.IsVisible = true; 
     472                return; 
     473            } 
     474            status.IsVisible = false; 
     475            tiputusajastin.Start(); 
     476            ClearControls(); 
     477            AsetaPeliNappaimet(); 
     478        } 
     479 
     480 
     481        /// <summary> 
    135482        /// Tuhoaa täydet rivit kentältä 
    136483        /// </summary> 
     
    156503            } 
    157504 
    158             pisteet.Value += (potti/10) * taso * potti; 
     505            pisteet.Value += (potti / 10) * taso * potti; 
    159506 
    160507            if (tuhotutRivit > 10) 
     
    201548            { 
    202549                pelikentta[0][i].Color = Color.TransparentWhite; 
    203             } 
    204         } 
    205  
    206         /// <summary> 
    207         /// Luo näyttöön pistenäytöt ja muut elementit. 
    208         /// </summary> 
    209         void LuoHud() 
    210         { 
    211             pistenaytto = new Label(80, 20); 
    212             pistenaytto.BindTo(pisteet); 
    213             pistenaytto.Position = new Vector(Screen.RightSafe - 200, Screen.TopSafe - 100); 
    214             //pistenaytto.Text = "Pisteet: "; 
    215             Add(pistenaytto); 
    216  
    217             tasonaytto = new Label(20, 20); 
    218             tasonaytto.BindTo(taso); 
    219             tasonaytto.Position = new Vector(Screen.RightSafe - 200, Screen.TopSafe - 125); 
    220             //tasonaytto.Text = "Taso: "; 
    221             //tasonaytto. 
    222             Add(tasonaytto); 
    223              
    224  
    225             /* 
    226              * Koska ennustuskenttä on kaksiulotteinen taulukko, joudumme luomaan 
    227              * ensiksi taulukon sarakkeet, jotta voimme luoda rivit. 
    228              */ 
    229             ennustuskentta = new GameObject[4][]; 
    230             for (int i = 0; i < ennustuskentta.Length; i++) 
    231             { 
    232                 ennustuskentta[i] = new GameObject[4]; 
    233             } 
    234  
    235             //Tässä luodaan pelikentän "laatiko" ja sijoitetaan ne oikeille kohdilleen. 
    236             for (int i = 0; i < ennustuskentta.Length; i++) 
    237             { 
    238                 for (int j = 0; j < ennustuskentta[i].Length; j++) 
    239                 { 
    240                     ennustuskentta[i][j] = new GameObject(palikkojenSivu, palikkojenSivu, Shapes.Rectangle); 
    241                     ennustuskentta[i][j].Color = Color.TransparentWhite; 
    242                     ennustuskentta[i][j].X = Level.Right + 100 + (palikkojenSivu / 2) + j * (palikkojenSivu); 
    243                     ennustuskentta[i][j].Y = Screen.TopSafe -200 - (palikkojenSivu / 2) - i * (palikkojenSivu); 
    244                     Add(ennustuskentta[i][j]); 
    245                 } 
    246             } 
    247         } 
    248  
    249         /// <summary> 
    250         /// Luo pelikentän ylhäällä määrätyistä vakioista 
    251         /// </summary> 
    252         void LuoPelikentta() 
    253         { 
    254             //Tässä säädetään pelialueen koko, jotta seinät tulevat oikeille kohdille 
    255             Level.Width = leveys * palikkojenSivu;// + leveys; 
    256             Level.Height = korkeus * palikkojenSivu;// + korkeus; 
    257             Level.CreateBorders(true); 
    258  
    259             /* 
    260              * Koska pelikenttä on kaksiulotteinen taulukko, joudumme luomaan 
    261              * ensiksi taulukon sarakkeet, jotta voimme luoda rivit. 
    262              */ 
    263             pelikentta = new GameObject[korkeus][]; 
    264             for (int i = 0; i < pelikentta.Length; i++) 
    265             { 
    266                 pelikentta[i] = new GameObject[leveys]; 
    267             } 
    268  
    269             //Tässä luodaan pelikentän "laatiko" ja sijoitetaan ne oikeille kohdilleen. 
    270             for (int i = 0; i < pelikentta.Length; i++) 
    271             { 
    272                 for (int j = 0; j < pelikentta[i].Length; j++) 
    273                 { 
    274                     pelikentta[i][j] = new GameObject(palikkojenSivu, palikkojenSivu, Shapes.Rectangle); 
    275                     pelikentta[i][j].Color = Color.TransparentWhite; 
    276                     pelikentta[i][j].X = Level.Left + (palikkojenSivu / 2) + j * (palikkojenSivu); 
    277                     pelikentta[i][j].Y = Level.Top - (palikkojenSivu / 2) - i * (palikkojenSivu); 
    278                     Add(pelikentta[i][j]); 
    279                 } 
    280             } 
    281         } 
    282  
    283          
    284  
    285         /// <summary> 
    286         /// Asettaa pelin aikana tarvittavat näppäimet. 
    287         /// </summary> 
    288         void AsetaPeliNappaimet() 
    289         { 
    290             Vector vasemmalle = new Vector(-1, 0); 
    291             Vector oikealle = new Vector(1, 0); 
    292             Vector alas = new Vector(0, 1); 
    293  
    294             Keyboard.Listen(Key.Escape, ButtonState.Pressed, PeliLoppui, "Keskeyttää pelin"); 
    295             Keyboard.Listen(Key.Left, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa vasemmalle", vasemmalle); 
    296             Keyboard.Listen(Key.Right, ButtonState.Pressed, Liikuta, "Liikuttaa palikkaa oikealle", oikealle); 
    297             Keyboard.Listen(Key.Down, ButtonState.Down, Laske, "Liikuttaa palikkaa alas", tiputusajastin); 
    298             Keyboard.Listen(Key.Up, ButtonState.Pressed, Kaanna, "Kääntää palikkaa"); 
    299             Keyboard.Listen(Key.Space, ButtonState.Pressed, Tiputa, "Tiputtaa palikan"); 
    300         } 
    301  
    302         /// <summary> 
    303         /// Asettaa menuissa käytettävät näppäimet 
    304         /// </summary> 
    305         void AsetaMenuNappaimet() 
    306         { 
    307             Keyboard.Listen(Key.Escape, ButtonState.Pressed, Exit, "Poistuu pelistä"); 
    308             Keyboard.Listen(Key.F2, ButtonState.Pressed, KaynnistaPeli, "Aloittaa uuden pelin"); 
    309         } 
    310  
    311         /// <summary> 
    312         /// Liikuttaa palikkaa halutun verran. 
    313         /// </summary> 
    314         /// <param name="suunta">X ja Y oltava kokonaislukuja.</param> 
    315         void Liikuta(Vector suunta) 
    316         { 
    317             PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite); 
    318  
    319             if (VoikoSiirtaa(suunta, aktiivinenPalikka)) 
    320             { 
    321                 aktiivinenPalikka.Liikuta(suunta); 
    322             } 
    323              
    324             PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
    325         } 
    326  
    327         /// <summary> 
    328         /// Kääntää palikkaa 
    329         /// </summary> 
    330         void Kaanna() 
    331         { 
    332             PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite); 
    333  
    334             //Tämä kohta tarkistaa, voiko palikkaa kääntää 
    335             //Jos ei voi, niin poistutaan. 
    336             Vector[] tulevaSijainti = aktiivinenPalikka.TulevaKaanto(); 
    337             for (int i = 0; i < tulevaSijainti.Length; i++) 
    338             { 
    339                 if (!OnkoTyhja(tulevaSijainti[i]))  
    340                 { 
    341                     PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
    342                     return; 
    343                 }  
    344             } 
    345  
    346             aktiivinenPalikka.Kaanna(); 
    347             PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
    348         } 
    349  
    350         /// <summary> 
    351         /// Laskee palikkaa yhdellä. Jos palikkaa ei voi laskea, 
    352         /// lähettää uuden palikan. 
    353         /// </summary> 
    354         /// <param name="timer">Ei käytössä</param> 
    355         void Laske(Timer timer) 
    356         { 
    357             PaivitaPalikka(aktiivinenPalikka, Color.TransparentWhite); 
    358  
    359             tiputusajastin.Reset(); 
    360             if (!VoikoSiirtaa(new Vector(0,1), aktiivinenPalikka)) 
    361             { 
    362                 PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
    363                 TuhoaTaydet(); 
    364                 LuoPalikka(); 
    365                 return; 
    366             } 
    367             aktiivinenPalikka.Liikuta(new Vector(0, 1)); 
    368             PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
    369  
    370         } 
    371  
    372         /// <summary> 
    373         /// Tiputtaa palikkan kokonaan alas. 
    374         /// </summary> 
    375         void Tiputa() 
    376         { 
    377             TetrisPalikka palikka = aktiivinenPalikka; 
    378             while (aktiivinenPalikka == palikka) Laske(tiputusajastin); 
    379         } 
    380  
    381         /// <summary> 
    382         /// Tarkistaa, voiko palikalle suorittaa annetut siirrot 
    383         ///  
    384         /// Annetut siirrot siis lisätään niitä vastaaviin palikan 
    385         /// sijainteihin. 
    386         /// </summary> 
    387         /// <param name="siirrot">X- ja Y-arvot oltava kokonaislukuja</param> 
    388         /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param> 
    389         /// <returns>true, jos palikan siirtäminen on mahdollista</returns> 
    390         bool VoikoSiirtaa(Vector[] siirrot, TetrisPalikka palikka) 
    391         { 
    392             Vector[] sijainnit = palikka.Sijainti(); 
    393  
    394             for (int i = 0; i < siirrot.Length; i++) 
    395             { 
    396                 if (!OnkoTyhja(sijainnit[i] + siirrot[i])) return false; 
    397             } 
    398             return true; 
    399         } 
    400  
    401         /// <summary> 
    402         /// Tarkistaa voiko kaikkia palikan osia siirtää annetun 
    403         /// vektorin verran 
    404         /// </summary> 
    405         /// <param name="siirto">X- ja Y-arvo oltava kokonaislukuja</param> 
    406         /// <param name="palikka">Palikka, jonka suhteen tarkistetaan</param> 
    407         /// <returns>true, jos siirto on mahdollinen</returns> 
    408         bool VoikoSiirtaa(Vector siirto, TetrisPalikka palikka) 
    409         { 
    410             Vector[] siirrot = new Vector[4]; 
    411             for (int i = 0; i < siirrot.Length; i++) 
    412             { 
    413                 siirrot[i] = siirto; 
    414             } 
    415             return VoikoSiirtaa(siirrot, palikka); 
    416         } 
    417  
    418         /// <summary> 
    419         /// Tarkistaa, onko annetut paikka tyhjä 
    420         ///  
    421         /// Paikka on tyhjä, jos sen väri on Color.TransparentWhite 
    422         /// </summary> 
    423         /// <param name="paikka">X ja Y oltava kokonaislukuja</param> 
    424         /// <returns>true, jos paikka on tyhjä</returns> 
    425         bool OnkoTyhja(Vector paikka) 
    426         { 
    427             if (paikka.X > leveys-1 || paikka.X < 0) return false; 
    428             if (paikka.Y > korkeus-1 || paikka.Y < 0) return false; 
    429  
    430             if (pelikentta[(int)paikka.Y][(int)paikka.X].Color == Color.TransparentWhite) return true; 
    431             return false; 
    432         } 
    433  
    434         /// <summary> 
    435         /// Värittää paikkaa vastaavat laatikot annetulla värillä 
    436         /// </summary> 
    437         /// <param name="palikka">Tämän sijainti väritetään</param> 
    438         /// <param name="vari">Väri, jolla väritetään</param> 
    439         void PaivitaPalikka(TetrisPalikka palikka, Color vari) 
    440         { 
    441             Vector[] sijainnit = palikka.Sijainti(); 
    442  
    443             for (int i = 0; i < sijainnit.Length; i++) 
    444             { 
    445                 pelikentta[(int)sijainnit[i].Y][(int)sijainnit[i].X].Color = vari; 
    446             } 
    447         } 
    448  
    449         /// <summary> 
    450         /// Luo palikan keskelle ylälaitaa 
    451         ///  
    452         /// Tulee antamaan satunnaisen palikan 
    453         /// </summary> 
    454         void LuoPalikka() 
    455         { 
    456             //Luo uuden palikan ja siirtää ennustuspalikan aktiiviseksi 
    457             //ennustusPalikka = new TetrisPalikka(leveys / 2); 
    458             if (aktiivinenPalikka != null) 
    459             { 
    460                 aktiivinenPalikka = ennustusPalikka; 
    461             } 
    462             else  
    463             {  
    464                 aktiivinenPalikka = new TetrisPalikka(leveys / 2);  
    465             } 
    466  
    467             ennustusPalikka = new TetrisPalikka(leveys / 2); 
    468  
    469             AsetaEnnustusnaytto(ennustusPalikka); 
    470  
    471             tiputusajastin.Reset(); 
    472  
    473             Vector[] sijainnit = aktiivinenPalikka.Sijainti(); 
    474             for (int i = 0; i < sijainnit.Length; i++) 
    475             { 
    476                 if (!OnkoTyhja(sijainnit[i])) 
    477                 { 
    478                     PeliLoppui(); 
    479                     return; 
    480                 } 
    481             } 
    482  
    483             PaivitaPalikka(aktiivinenPalikka, aktiivinenPalikka.Vari()); 
    484         } 
    485  
    486         void AsetaEnnustusnaytto(TetrisPalikka palikka) 
    487         { 
    488             for (int i = 0; i < ennustuskentta.Length; i++) 
    489             { 
    490                 for (int j = 0; j < ennustuskentta[i].Length; j++) 
    491                 { 
    492                     ennustuskentta[i][j].Color = Color.TransparentWhite; 
    493                 } 
    494             } 
    495  
    496             Vector[] sijainnit = palikka.Sijainti(); 
    497             int offset = -(leveys / 2) + 1; 
    498  
    499             foreach (Vector paikka in sijainnit) 
    500             { 
    501                 ennustuskentta[(int)paikka.Y ][(int)paikka.X + offset].Color = palikka.Vari(); 
    502550            } 
    503551        } 
     
    512560        { 
    513561            tiputusajastin.Stop(); 
     562            status.Text = "Hävisit pelin!"; 
     563            status.IsVisible = true; 
    514564            ClearControls(); 
    515565            AsetaMenuNappaimet(); 
    516566        } 
    517  
     567        #endregion 
    518568    } 
    519569} 
  • 2010/23/hniemi/JyTris/JyTris/TetrisPalikka.cs

    r1482 r1515  
    5757        public void LataaSatunnainen(int keskikohta) 
    5858        { 
    59             int satunnainen = RandomGen.NextInt(0, 5); 
     59            int satunnainen = RandomGen.NextInt(0, 6); 
    6060            switch (satunnainen) 
    6161            { 
     
    6666                case 4: LataaL(keskikohta); break; 
    6767                case 5: LataaJ(keskikohta); break; 
     68                case 6: LataaRisti(keskikohta); break; 
    6869                default: break; 
    6970            } 
     
    396397 
    397398        /// <summary> 
     399        /// Lataa J-palikan 
     400        ///  
     401        /// o = akseli 
     402        ///  
     403        ///  * 
     404        ///  o 
     405        /// ** 
     406        /// </summary> 
     407        /// <param name="keskikohta">Kentän yläreunan keskikohta</param> 
     408        public void LataaRisti(int keskikohta) 
     409        { 
     410            vari = Color.Magenta; 
     411            sijainnit[2].Y = 0; 
     412            sijainnit[1].Y = 0; 
     413            sijainnit[0].Y = 0; 
     414            sijainnit[3].Y = 1; 
     415 
     416            sijainnit[0].X = keskikohta; 
     417            sijainnit[1].X = keskikohta + 1; 
     418            sijainnit[2].X = keskikohta - 1; 
     419            sijainnit[3].X = keskikohta; 
     420 
     421            //Tämä luo siirrot, jotta palikkaa voidaan kääntää 
     422            siirrot = new Vector[4][]; 
     423            for (int i = 0; i < siirrot.Length; i++) 
     424            { 
     425                siirrot[i] = new Vector[4]; 
     426            } 
     427 
     428            /* 
     429             *        1 
     430             * 201 -> 03 
     431             *  3     2 
     432             *         
     433             */ 
     434            siirrot[0][0] = new Vector(0, 0); 
     435            siirrot[0][1] = new Vector(-1, -1); 
     436            siirrot[0][2] = new Vector(1, 1); 
     437            siirrot[0][3] = new Vector(1, -1); 
     438 
     439            /* 
     440             * 1   ->  3 
     441             * 03     102 
     442             * 2 
     443             */ 
     444            siirrot[1][0] = new Vector(0, 0); 
     445            siirrot[1][1] = new Vector(-1, 1); 
     446            siirrot[1][2] = new Vector(1,-1); 
     447            siirrot[1][3] = new Vector(-1, -1); 
     448 
     449            /* 
     450             *  3   -> 2 
     451             * 102    30 
     452             *         1 
     453             */ 
     454            siirrot[2][0] = new Vector(0, 0); 
     455            siirrot[2][1] = new Vector(1, 1); 
     456            siirrot[2][2] = new Vector(-1, -1); 
     457            siirrot[2][3] = new Vector(-1, 1); 
     458 
     459            /* 
     460             *  2 -> 201 
     461             * 30     3 
     462             *  1 
     463             */ 
     464            siirrot[3][0] = new Vector(0, 0); 
     465            siirrot[3][1] = new Vector(1, -1); 
     466            siirrot[3][2] = new Vector(-1, 1); 
     467            siirrot[3][3] = new Vector(1, 1); 
     468        } 
     469 
     470        /// <summary> 
    398471        /// Liikuttaa kaikkia palikoita annetun vektorin verran. 
    399472        /// </summary> 
     
    406479                sijainnit[i] += liike; 
    407480            } 
    408  
    409         } 
     481        } 
     482 
    410483 
    411484        /// <summary> 
  • 2010/23/hniemi/JyTris/JyTris/obj/x86/Debug/JyTris.csproj.FileListAbsolute.txt

    r1489 r1515  
    2121C:\MyTemp\npo_pelit\2010\23\hniemi\JyTris\JyTris\obj\x86\Debug\JyTris.exe 
    2222C:\MyTemp\npo_pelit\2010\23\hniemi\JyTris\JyTris\obj\x86\Debug\JyTris.pdb 
     23C:\MyTemp\hniemi\JyTris\JyTris\bin\x86\Debug\JyTris.exe 
     24C:\MyTemp\hniemi\JyTris\JyTris\bin\x86\Debug\JyTris.pdb 
     25C:\MyTemp\hniemi\JyTris\JyTris\bin\x86\Debug\Jypeli2.xml 
     26C:\MyTemp\hniemi\JyTris\JyTris\obj\x86\Debug\ResolveAssemblyReference.cache 
     27C:\MyTemp\hniemi\JyTris\JyTris\obj\x86\Debug\Microsoft.Xna.Framework.RuntimeProfile.txt 
     28C:\MyTemp\hniemi\JyTris\JyTris\obj\x86\Debug\JyTris.exe 
     29C:\MyTemp\hniemi\JyTris\JyTris\obj\x86\Debug\JyTris.pdb 
Note: See TracChangeset for help on using the changeset viewer.