Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00151 005582 14269044 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Microsoft XNA Game Studio 4.0. Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i własnego PC - książka
Microsoft XNA Game Studio 4.0. Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i własnego PC - książka
Autor: Liczba stron: 528
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3410-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> gry >> programowanie gier
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Każdy pasjonat gier komputerowych zadawał sobie czasem pytania typu: 'Niesamowite, jak oni to zrobili?' albo 'Jak można uzyskać taki efekt?'. A co się dzieje, jeśli to pytanie przychodzi do głowy programiście? Jego następną myślą zwykle jest: 'Muszę spróbować sam to zrobić!'. Na co czekasz? Dziś już nic nie stoi na przeszkodzie! Odkąd Microsoft udostępnił framework XNA, każdy może wymyślić i stworzyć swoją własną profesjonalną grę komputerową, uruchomić ją na prawdziwej konsoli, a nawet wprowadzić na rynek dzięki usłudze Xbox Live lub Windows Phone Marketplace.

Jeśli zawsze marzyłeś o profesjonalnym programowaniu gier, ale nie do końca wiedziałeś, jak się za to zabrać, oto książka, która wszystko zmieni! Ten podręcznik będzie dla Ciebie doskonałym przewodnikiem, prowadzącym od opanowania podstaw frameworku XNA, przez zasady programowania w użytecznym języku C#, aż po tworzenie własnych gier. Przejdziesz niezwykłą drogę: na jej początku czeka Cię instalacja i przygotowanie środowiska programistycznego, potem projektowanie realistycznej grafiki gry i jej ciekawe udźwiękowienie, a uwieńczeniem Twoich działań będzie stworzenie profesjonalnych projektów dla konsoli Xbox 360®, telefonów z systemem Windows® Phone 7 czy komputerów PC. Co ważne, nie musisz być zaawansowanym i doświadczonym programistą. Wszystko, czego będziesz potrzebował do realizacji tej misji, znajdziesz w tej książce!

Nauczysz się m.in.:

Opanuj sztukę programowania gier i zmieniaj własne pomysły w ekscytującą rzeczywistość!

Rob Miles uczy programowania od ponad dwudziestu pięciu lat. Jest ekspertem w dziedzinie programowania w języku Visual C#, przy użyciu frameworku XNA oraz Microsoft MVP for Windows Phone Development. Oprócz pisania własnych gier i aplikacji oraz pracy dydaktycznej na uniwersytecie Rob brał udział w wielu różnych komercyjnych projektach informatycznych.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Microsoft® XNA® Game Studio 4.0: Learn Programming Now!: How to program for Windows Phone 7, Xbox 360, Zune devices, and more Tłumaczenie: Mikołaj Szczepaniak (wstęp, rozdz. 1 – 3, 10 – 16); Jacek Kowolik (rozdz. 4 – 9, 17 – 19) Projekt okładki: Studio Gravite / Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki ISBN: 978-83-246-3410-1 © 2012 Helion S.A. Authorized translation of the English edition of Microsoft® XNA® Game Studio 4.0: Learn Programming Now! ISBN 9780735651579, First Edition © 2011, Microsoft Corporation. This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls of all rights to publish and sell the same. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/games4 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĂci WstÚp .............................................................................................15 CzÚĂÊ I Wprowadzenie 1. Komputery, C#, XNA i Ty ...............................................................19 Wprowadzenie ..............................................................................................19 Nauka programowania ................................................................................19 Jak zostaÊ Ăwietnym programistÈ .................................................................20 Jak dziaïa ta ksiÈĝka .......................................................................................21 JÚzyk C# i framework XNA ............................................................................21 Do dzieïa .......................................................................................................22 Instalacja Ărodowiska programowania i frameworku XNA ...............................22 Konfiguracja komputera PC pod kÈtem uruchamiania gier XNA ....................23 Konfiguracja konsoli Xbox 360 pod kÈtem uruchamiania gier XNA ...............24 Konfiguracja systemu Windows Phone pod kÈtem uruchamiania gier XNA ....26 Pisanie pierwszego programu ........................................................................28 Tworzenie pierwszego projektu ....................................................................28 Uruchamianie pierwszego programu ...........................................................31 Zatrzymywanie programu ............................................................................33 Przechowywanie gier w konsoli Xbox 360 lub urzÈdzeniu z systemem Windows Phone .............................................34 Uruchamianie tej samej gry XNA na róĝnych urzÈdzeniach ...........................34 Podsumowanie ..............................................................................................37 PrzeglÈd rozdziaïu w pytaniach ......................................................................37 2. Programy, dane i ïadne kolory ........................................................39 Wprowadzenie ..............................................................................................39 Tworzenie programu gry ................................................................................40 Wyraĝenia w metodzie Draw .......................................................................41 Praca z kolorami ............................................................................................43 Przechowywanie wartoĂci kolorów ...............................................................43 Ustawianie wartoĂci koloru ..........................................................................44 Kontrolowanie koloru ....................................................................................45 Gry i klasy ....................................................................................................46 Klasy jako biura ...........................................................................................48 Dane Ăwiata gry ...........................................................................................49 Przechowywanie danych w pamiÚci komputera ............................................51 Rysowanie z wykorzystaniem zmiennych intensywnoĂci barw .......................52 6 Spis treĂci Aktualizowanie kolorów ..............................................................................53 Przepeïnienie pamiÚci i wartoĂci danych .......................................................55 PeïnowartoĂciowa wielokolorowa lampa ......................................................56 Podejmowanie decyzji w programie .............................................................57 Gotowa gra w wielokolorowÈ lampÚ ...........................................................61 Znajdowanie bïÚdów w programie ..............................................................63 Podsumowanie .............................................................................................. 65 PrzeglÈd rozdziaïu w pytaniach ..................................................................... 65 3. Pobieranie danych wejĂciowych od gracza .................................... 67 Wprowadzenie .............................................................................................. 67 Odczytywanie stanu pada .............................................................................. 68 Pady i klasy ..................................................................................................68 Znajdowanie pada .......................................................................................70 Testowanie statusu pada .............................................................................72 Stosowanie klawiatury ................................................................................... 73 Zatrzymywanie gry za pomocÈ klawisza Escape ............................................75 Jednoczesne uĝywanie pada i klawiatury ...................................................... 75 Dodawanie wibracji ....................................................................................... 77 Sterowanie wibracjami pada ........................................................................77 Testowanie wartoĂci intensywnoĂci ..............................................................78 BïÚdy w programie ........................................................................................ 83 Podsumowanie .............................................................................................. 85 PrzeglÈd rozdziaïu w pytaniach ..................................................................... 85 CzÚĂÊ II Obrazy, děwiÚk i tekst 4. WyĂwietlanie obrazów ................................................................... 89 Wprowadzenie .............................................................................................. 89 Zasoby i zawartoĂÊ ........................................................................................ 90 Dodawanie obrazów ................................................................................... 90 ZarzÈdzanie zawartoĂciÈ z uĝyciem XNA ......................................................92 Praca z zawartoĂciÈ za pomocÈ XNA Game Studio .......................................92 RozwiÈzania i projekty w XNA Game Studio .................................................92 Dodawanie zawartoĂci do projektu ..............................................................94 Korzystanie z zasobów w programie gry ........................................................ 97 ’adowanie tekstur w XNA ...........................................................................97 Pozycjonowanie sprajtu na ekranie ............................................................ 101 WyĂwietlanie sprajtu za pomocÈ klasy SpriteBatch ..................................... 103 Wypeïnianie ekranu ................................................................................... 105 Intellisense ................................................................................................106 Podsumowanie ............................................................................................ 108 PrzeglÈd rozdziaïu w pytaniach ................................................................... 108 Spis treĂci 7 5. WyĂwietlanie tekstu .....................................................................111 Wprowadzenie ............................................................................................111 Komputery i tekst .........................................................................................111 Tekst jako zasób ........................................................................................112 Tworzenie projektu zegara w XNA .............................................................112 Dodawanie czcionki do zasobów ...............................................................112 Format plików XML ...................................................................................115 ’adowanie czcionki ...................................................................................115 WyĂwietlanie z uĝyciem czcionki ................................................................116 Zmiana wïaĂciwoĂci czcionki ......................................................................118 Uzyskiwanie daty i czasu ..............................................................................119 Tworzenie ïadniejszego zegara z tekstem 3D ................................................122 Wielokrotne wyĂwietlanie ïañcuchów tekstu ..............................................122 Powtarzanie instrukcji z uĝyciem pÚtli for ...................................................124 Inne konstrukcje pÚtli .................................................................................126 Zabawa z pÚtlÈ for .....................................................................................126 Tworzenie iluzji trójwymiaru ........................................................................128 Tworzenie cieni z uĝyciem kolorów przezroczystych ...................................128 WyĂwietlanie obrazów z uĝyciem przezroczystoĂci .....................................130 Podsumowanie ............................................................................................131 PrzeglÈd rozdziaïu w pytaniach ....................................................................131 6. Tworzenie gry dla wielu graczy ....................................................133 Wprowadzenie ............................................................................................133 Tworzenie gry z wciskaniem przycisków .....................................................133 Dane w grze ButtonBash ...........................................................................134 Rozpoczynanie gry ButtonBash ..................................................................134 WyĂwietlanie wartoĂci licznika wciĂniÚÊ przycisku .......................................135 Zliczanie wciĂniÚÊ przycisku .......................................................................135 Wykrywanie zmian poïoĝenia przycisku ......................................................136 Wykrywanie poziomu i zbocza ...................................................................137 Konstruowanie kompletnej gry ..................................................................138 Projektowanie kodu ...................................................................................140 Dodawanie kodu testowego ......................................................................140 Podsumowanie ............................................................................................143 PrzeglÈd rozdziaïu w pytaniach ....................................................................143 7. Odtwarzanie děwiÚków ................................................................145 Dodawanie děwiÚku ....................................................................................145 Tworzenie projektu Drum Pad ....................................................................145 Nagrywanie děwiÚków w programie Audacity ............................................146 Przechowywanie děwiÚków w projekcie .....................................................147 Stosowanie děwiÚków w programie w XNA ...............................................149 8 Spis treĂci Odtwarzanie muzyki w tle .........................................................................151 CiÈgïe odtwarzanie děwiÚku ......................................................................151 Kontrola wartoĂci null w referencjach ........................................................155 XACT audio tool ........................................................................................156 Odtwarzanie muzyki za pomocÈ klasy MediaPlayer ....................................156 Podsumowanie ............................................................................................ 158 PrzeglÈd rozdziaïu w pytaniach ................................................................... 158 8. Pomiar czasu ................................................................................ 159 Tworzenie kolejnej gry ................................................................................. 159 BïÈd w pomiarze czasu reakcji ...................................................................162 Ustalanie zwyciÚzcy za pomocÈ tablic .......................................................... 164 Tworzenie tablicy .......................................................................................165 Korzystanie z danych w tablicy ...................................................................165 PrzeglÈdanie tablicy ...................................................................................167 Zastosowanie tablicy jako sïownika ............................................................168 WyĂwietlanie zwyciÚzcy .............................................................................170 Podsumowanie ............................................................................................ 172 PrzeglÈd rozdziaïu w pytaniach ................................................................... 172 9. Wczytywanie tekstu wejĂciowego ................................................ 173 Uĝywanie klawiatury w XNA ........................................................................ 173 Tworzenie projektu Tablica ogïoszeñ ......................................................... 173 Rejestrowanie wciĂniÚÊ klawiszy .................................................................174 Wykrywanie momentu wciĂniÚcia klawisza .................................................175 Typ Keys ....................................................................................................175 Typy wyliczeniowe .....................................................................................176 Praca z tablicami, obiektami i referencjami .................................................. 177 WartoĂci i referencje ..................................................................................177 Tablice jako biura ......................................................................................178 Przywitaj siÚ z procesem odzyskiwania pamiÚci ..........................................179 Uĝywanie referencji i wartoĂci ....................................................................180 Do czego sïuĝÈ referencje i wartoĂci? ......................................................... 181 Referencje i metoda GetPressedKeys ..........................................................182 WyĂwietlanie klawiszy .................................................................................. 182 Wykrywanie wciĂniÚÊ klawiszy ...................................................................183 Dekodowanie znaków na klawiszach .........................................................188 Uĝywanie klawiszy Shift .............................................................................189 A co z polskimi znakami? ..........................................................................190 Edycja tekstu .............................................................................................192 Podsumowanie ............................................................................................ 193 PrzeglÈd rozdziaïu w pytaniach ................................................................... 194 CzÚĂÊ III Pisanie poprawnych gier Spis treĂci 9 10. Uĝywanie metod jÚzyka C# do rozwiÈzywania problemów .........197 Wprowadzenie ............................................................................................197 Zabawa z obrazami .....................................................................................197 Przybliĝanie obrazu ....................................................................................198 Tworzenie efektu oddalania .........................................................................200 Aktualizowanie prostokÈta rysowania ........................................................200 Tworzenie metody obliczajÈcej wartoĂci procentowe ..................................203 Stosowanie sïowa void ..............................................................................206 Diagnozowanie programów jÚzyka C# ......................................................210 Trafianie w punkt zatrzymania ...................................................................212 Uĝywanie liczb zmiennoprzecinkowych w jÚzyku C# ..................................214 Kompilator i typy danych jÚzyka C# ...........................................................215 Kompilatory i rzutowanie ...........................................................................217 Typy wyraĝeñ ............................................................................................218 Zatrzymywanie oddalania ..........................................................................220 Oddalanie ze Ărodka zdjÚcia .......................................................................220 Podsumowanie ............................................................................................224 PrzeglÈd rozdziaïu w pytaniach ....................................................................224 11. Gra jako program jÚzyka C# .........................................................227 Wprowadzenie ............................................................................................227 Tworzenie grafiki gry ....................................................................................228 Projekty, zasoby i klasy .................................................................................229 RozwiÈzania i projekty Ărodowiska XNA Game Studio ................................229 Plik Program.cs ..........................................................................................232 Zmiana nazwy klasy Game1 .......................................................................238 Tworzenie obiektów gry ...............................................................................240 Sprajty w grze ...........................................................................................240 ZarzÈdzanie rozmiarem sprajtów gry ..........................................................240 Wprawianie sprajtów w ruch .....................................................................244 Odbijanie sera ...........................................................................................246 Obsïuga nadmiarowoĂci ekranu .................................................................246 Podsumowanie ............................................................................................248 PrzeglÈd rozdziaïu w pytaniach ....................................................................249 12. Gry, obiekty i stan ........................................................................251 Wprowadzenie ............................................................................................251 Dodanie chleba do gry .................................................................................251 Stosowanie struktury do przechowywania informacji o sprajcie ..................252 Sterowanie ruchem za pomocÈ gaïki pada .................................................254 10 Spis treĂci Doskonalenie programów za pomocÈ metod .............................................256 Obsïuga kolizji ...........................................................................................259 Odbijanie sera od chleba ........................................................................... 260 Dziwne zachowanie mechanizmu odbijania ............................................... 260 Dziwne zachowanie krawÚdzi ....................................................................261 Dodanie pomidorowych celów .................................................................... 264 Kolizje z pomidorami .................................................................................267 Podsumowanie ............................................................................................ 269 PrzeglÈd rozdziaïu w pytaniach ................................................................... 270 13. Tworzenie kompletnej gry ............................................................ 271 Wprowadzenie ............................................................................................ 271 Tworzenie skoñczonej gry ............................................................................ 271 Dodanie punktacji do gry ...........................................................................271 Dodanie elementu ryzyka ...........................................................................273 Dodanie postÚpu w grze ............................................................................275 Doskonalenie projektu kodu ........................................................................ 278 Refaktoryzacja poprzez tworzenie metod dla istniejÈcego kodu ..................279 Refaktoryzacja poprzez zmianÚ identyfikatorów .........................................280 Tworzenie obszarów kodu .........................................................................282 Tworzenie przydatnych komentarzy ...........................................................283 Dodanie tïa ................................................................................................. 285 Dodanie ekranu tytuïowego ........................................................................ 286 Gry i stan ..................................................................................................287 Stosowanie wartoĂci stanu ........................................................................287 Budowa maszyny stanów ..........................................................................288 Podsumowanie ............................................................................................ 291 PrzeglÈd rozdziaïu w pytaniach ................................................................... 291 14. Klasy, obiekty i gry ....................................................................... 293 Wprowadzenie ............................................................................................ 293 Projektowanie przy uĝyciu obiektów ............................................................ 293 Kurs odĂwieĝajÈcy wiedzÚ o obiektach .......................................................294 SpójnoĂÊ i obiekty .....................................................................................295 ZwiÈzki pomiÚdzy obiektami ......................................................................298 Projektowanie interakcji pomiÚdzy obiektami .............................................301 Obiekty kontenerów ..................................................................................303 Obiekty tïa i ekranu tytuïowego .................................................................305 Klasy i struktury ........................................................................................... 306 Tworzenie i stosowanie struktury ...............................................................306 Tworzenie i stosowanie egzemplarza klasy .................................................307 Spis treĂci 11 Referencje ....................................................................................................309 Wiele referencji do jednego egzemplarza ...................................................309 Brak referencji do egzemplarza ..................................................................310 Po co w ogóle stosowaÊ referencje? ...........................................................311 Typy wartoĂciowe i referencyjne ...................................................................311 Czy obiekty w naszej grze powinny mieÊ postaÊ klas, czy teĝ struktur? .......312 Tworzenie hierarchii klas sprajtów ................................................................314 Klasa BaseSprite .........................................................................................314 Rozszerzenie klasy BaseSprite w celu utworzenia klasy TitleSprite ................316 Budowa hierarchii klas ...............................................................................317 Dodanie morderczej papryki .........................................................................318 Tworzenie klasy DeadlySprite .....................................................................318 Podsumowanie ............................................................................................323 PrzeglÈd rozdziaïu w pytaniach ....................................................................323 15. Tworzenie komponentów gry .......................................................325 Wprowadzenie ............................................................................................325 Obiekty i abstrakcja ......................................................................................325 Tworzenie klasy abstrakcyjnej w jÚzyku C# .................................................326 Rozszerzanie klasy abstrakcyjnej .................................................................327 Projektowanie przy uĝyciu klas abstrakcyjnych ............................................328 Referencje do abstrakcyjnych klas macierzystych .........................................329 Konstruowanie egzemplarzy klas ..................................................................330 Konstruktory w strukturach ........................................................................332 Konstruktory w hierarchii klas ....................................................................333 Dodanie stu zabójczych mandarynek ............................................................335 Tworzenie klasy KillerSprite ........................................................................335 Ustawianie poïoĝenia sprajtów KillerSprite za pomocÈ liczb losowych .........336 Stosowanie list referencji ...........................................................................339 Dodanie sztucznej inteligencji ......................................................................342 ¥ciganie païki chlebowej ............................................................................343 Dodanie děwiÚków w grze ...........................................................................347 Od obiektów do komponentów ...................................................................350 Interfejsy jÚzyka C# ...................................................................................351 Tworzenie interfejsu ..................................................................................352 Implementowanie interfejsu ......................................................................353 Referencje do interfejsów ...........................................................................353 ’Èczenie chleba, sera i pomidorów ............................................................354 Projektowanie przy uĝyciu interfejsów ........................................................354 Podsumowanie ............................................................................................355 PrzeglÈd rozdziaïu w pytaniach ....................................................................355 12 Spis treĂci 16. Tworzenie gier sieciowych dla wielu graczy ................................. 357 Wprowadzenie ............................................................................................ 357 Sieci i komputery ......................................................................................... 357 Wszystko zaczyna siÚ od sygnaïu ...............................................................358 Konstruowanie pakietów ...........................................................................358 Adresowanie komunikatów .......................................................................358 Trasowanie ................................................................................................359 PoïÈczenia i datagramy ..............................................................................360 Sieci i protokoïy .........................................................................................361 Usïuga Xbox Live ......................................................................................... 362 Karty graczy i usïuga Xbox Live ..................................................................362 Technologia System Link i framework XNA .................................................363 Ping-pong chleba i sera ............................................................................... 363 ZarzÈdzanie profilami graczy we frameworku XNA .....................................364 Sprawdzanie logowania gracza na potrzeby gry sieciowej .......................... 368 Tworzenie lobby gry ..................................................................................369 Gry sieciowe i stan .....................................................................................369 Rozgrywka ................................................................................................377 Kompletna gra ..........................................................................................382 Podsumowanie ............................................................................................ 382 PrzeglÈd rozdziaïu w pytaniach ................................................................... 383 CzÚĂÊ IV Tworzenie mobilnych gier dla systemu Windows Phone 7 za pomocÈ XNA ....................... 385 17. Gry sterowane ruchem telefonu .................................................. 387 Wprowadzenie ............................................................................................ 387 Akcelerometr ............................................................................................... 387 Do czego tak naprawdÚ sïuĝy akcelerometr? .............................................. 387 Przyspieszenie z punktu widzenia fizyki ........................................................ 388 Interpretowanie odczytów z akcelerometru ................................................390 Tworzenie gry Cheese Lander sterowanej przechylaniem .............................. 391 Obiekty Ăwiata gry Cheese Lander ..............................................................391 DostÚp do klasy Accelerometer z programu w XNA ....................................392 Uĝywanie klasy Accelerometer w grze dla Ărodowiska XNA .............................395 Uruchamianie akcelerometru .....................................................................397 Wykorzystanie odczytów z akcelerometru w programie gry ........................398 Poprawianie przebiegu gry z wykorzystaniem praw fizyki ...........................398 Wyraĝanie ruchu za pomocÈ wektorów .....................................................400 Dodawanie tarcia ......................................................................................401 Sterowanie děwiÚkiem za pomocÈ wektorów .............................................402 Spis treĂci 13 Wykrywanie potrzÈsania ............................................................................403 Krótka dygresja na temat wÈtków i synchronizacji ......................................403 Podsumowanie ............................................................................................405 PrzeglÈd rozdziaïu w pytaniach ....................................................................406 18. Obsïuga sterowania dotykiem ......................................................407 Wprowadzenie ............................................................................................407 Ekran dotykowy w telefonach z systemem Windows Phone ..........................407 Pobieranie wejĂcia dotykowego .................................................................408 Tworzenie przycisku alarmowego .................................................................408 Odczytywanie zdarzeñ z wejĂcia dotykowego ............................................409 Typy obiektów TouchLocation ....................................................................409 Obsïuga miejsca dotkniÚcia ........................................................................411 Tworzenie dotykowej perkusji ......................................................................412 Tworzenie klasy SoundPad dla kaĝdego z děwiÚków perkusji ......................412 Przechowywanie w programie wartoĂci typu soundPad ..............................413 WyĂwietlanie przycisków ...........................................................................414 OdĂwieĝanie stanu przycisków ...................................................................415 PodĂwietlanie przycisków ...........................................................................416 Tworzenie „Ălizganej” gry planszowej ...........................................................418 Klasa PuckSprite ........................................................................................419 OdĂwieĝanie stanu nieruchomego krÈĝka ...................................................420 Przemieszczanie krÈĝka po ekranie .............................................................421 KrÈĝek poruszajÈcy siÚ po planszy ..............................................................422 Emulatory i prawdziwe urzÈdzenia .............................................................424 Podsumowanie ............................................................................................425 PrzeglÈd rozdziaïu w pytaniach ....................................................................425 19. Konstruowanie mobilnych gier .....................................................427 Wprowadzenie ............................................................................................427 Telefon z systemem Windows Phone ............................................................427 Windows Phone Marketplace .....................................................................428 Wydïuĝanie czasu ĝycia baterii telefonu podczas dziaïania gier w XNA .........428 Ustawianie czÚstotliwoĂci odĂwieĝania w grze ...........................................428 Obsïuga zmian orientacji telefonu ................................................................429 Wybór orientacji z programu gry w XNA ....................................................430 Otrzymywanie komunikatu o zmianie orientacji .........................................430 Uĝywanie okreĂlonego rozmiaru ekranu w grach dla systemu Windows Phone .....................................................................432 Ukrywanie paska stanu systemu Windows Phone .........................................432 WyïÈczanie blokowania ekranu podczas gry .................................................433 14 Spis treĂci Tworzenie maszyny stanów dla telefonu ...................................................... 434 Gry i stany .................................................................................................434 Tworzenie prostej maszyny stanów dla gry .................................................435 Tworzenie bardziej skomplikowanych maszyn stanów ................................437 Obsïuga przychodzÈcych poïÈczeñ telefonicznych ....................................... 439 Wykrywanie poïÈczeñ telefonicznych ......................................................... 441 Gra jako aplikacja w systemie Windows Phone ............................................ 442 Przyciski Back i Start systemu Windows Phone ...........................................443 Uruchamianie nowych programów za pomocÈ przycisku Start ................... 445 Korzystanie z izolowanych obszarów przechowywania do zapisywania stanu gry ........................................................................446 Dostarczanie naszych gier do usïugi Marketplace ......................................... 453 Usïuga Windows Phone Marketplace .........................................................453 Rejestracja w serwisie App Hub ..................................................................454 Uĝywane urzÈdzenia z systemem Windows Phone .....................................454 Tworzenie gier na sprzedaĝ .......................................................................454 Podsumowanie ............................................................................................ 455 PrzeglÈd rozdziaïu w pytaniach ................................................................... 455 Dodatki .................................................................. 457 Odpowiedzi na pytania do rozdziaïów ........................................ 459 Sïownik pojÚÊ ............................................................................... 483 Skorowidz .................................................................................... 511 O autorze ..................................................................................... 525 Rozdziaï 3. Pobieranie danych wejĂciowych od gracza W tym rozdziale: „ Dowiesz siÚ, jak we frameworku Microsoft XNA sÈ reprezentowane pady i klawiatury. „ Odkryjesz struktury jÚzyka programowania C#, które umoĝliwiajÈ uzyskiwanie danych wejĂciowych od gracza. „ Napiszesz kilka naprawdÚ niezbyt mÈdrych gier, które skutecznie przestraszÈ graczy. Wprowadzenie PoznaïeĂ juĝ podstawy programowania gier komputerowych. Wiesz, ĝe program jest w istocie sekwencjÈ wyraĝeñ, z których kaĝde wykonuje pojedynczÈ czynnoĂÊ. PrzekonaïeĂ siÚ, ĝe wyraĝenia umieszcza siÚ w metodach odpowiedzialnych za okreĂlone zadanie oraz ĝe metody (wraz z potrzebnymi danymi) naleĝÈ do klas. Sam program operuje na wartoĂciach danych, które sÈ przechowywane w zmiennych okreĂlonych typów. Program podejmuje teĝ decyzje na podstawie wartoĂci zawartych w tych zmiennych. (JeĂli uwaĝasz, ĝe ĝadne z powyĝszych zdañ nie ma sensu, czytaj tak dïugo rozdziaï 2., zatytuïowany „Programy, dane i ïadne kolory”, aĝ te stwierdzenia bÚdÈ dla Ciebie oczywiste). W tym rozdziale bÚdziesz miaï okazjÚ poszerzyÊ swojÈ wiedzÚ o techniki uzyskiwania danych wejĂciowych ze Ăwiata zewnÚtrznego, dziÚki którym gry mogÈ reagowaÊ na zachowania gracza. Szybko odkryjesz, ĝe po uzyskaniu tej wiedzy spektrum Twoich moĝliwoĂci w roli twórcy gier komputerowych bÚdzie nieporównanie szersze. BÚdziesz potrafiï napisaÊ kilka niezbyt jeszcze przemyĂlanych gier, w tym Color Nerve, Mind Reader, The Thing That Goes Bump in the Night oraz Gamepad Racer. Zanim jednak przystÈpimy do omawiania padów, musimy zdecydowaÊ, jak powinien dziaïaÊ Twój przyszïy program. Przeanalizuj nastÚpujÈce wyraĝenie jÚzyka C# zaczerpniÚte z metody Update w ramach poprzedniej wersji programu nastrojowej lampy: if (redCountingUp) redIntensity++; To jeden z testów umoĝliwiajÈcych kontrolÚ intensywnoĂci czerwonego skïadnika wyĂwietlanego koloru. Wyraĝenie w tej formie moĝna opisaÊ sïowami: „JeĂli zmienna logiczna redCountingUp ma wartoĂÊ true, zwiÚksz wartoĂÊ zmiennej redIntensity o 1”. 68 CzÚĂÊ I Wprowadzenie Projekt programu: kontroler wielokolorowej lampy W rozdziale 2. stworzyïeĂ prostÈ grÚ — swoiste Ăwiatïo, które zmieniaïo kolor w czasie. Wspomniaïem teĝ, ĝe podobne rozwiÈzania najpewniej bÚdÈ w przyszïoĂci stosowane na statkach kosmicznych. Lampa zmieniajÈca kolor byÊ moĝe nie nadaje siÚ do czytania ksiÈĝek, ale skutecznie poprawia nastrój. Przyjmijmy teraz, ĝe kapitan naszego statku kosmicznego potrzebuje lampy, której kolor sam bÚdzie mógï ustawiÊ. Oznacza to, ĝe tym razem przygotujesz lampÚ sterowanÈ za poĂrednictwem pada konsoli Xbox. Uĝytkownik bÚdzie naciskaï czerwony, niebieski, zielony i ĝóïty przycisk na padzie, aby zwiÚkszaÊ intensywnoĂÊ poszczególnych barw. Aby stworzyÊ opisane rozwiÈzanie, musisz dowiedzieÊ siÚ, jak odczytywaÊ stan pada. Przytoczone wyraĝenie jest przetwarzane dla kaĝdego wywoïania metody Update (obecnie ta czÚstotliwoĂÊ wynosi 60 razy na sekundÚ), zatem jeĂli zmienna redCountingUp ma wartoĂÊ true, intensywnoĂÊ czerwonej barwy bÚdzie stopniowo zwiÚkszana. Chcesz teraz napisaÊ kod, który bÚdzie wyraĝaï zdanie: „JeĂli na pierwszym padzie jest naciĂniÚty czerwony przycisk, zwiÚksz wartoĂÊ zmiennej redIntensity o 1”. JeĂli gracz bÚdzie przytrzymywaï czerwony przycisk, ekran bÚdzie stawaï siÚ coraz bardziej czerwony. Oznacza to, ĝe jedyna niezbÚdna zmiana bÚdzie polegaïa na takiej modyfikacji przytoczonego testu, aby odczytywaï on stan przycisku na padzie. Stworzenie lampy sterowanej przez uĝytkownika jest wiÚc zadziwiajÈco proste. Odczytywanie stanu pada Pady w rzeczywistoĂci sÈ bardzo skomplikowanymi urzÈdzeniami. SÈ poïÈczone z gïównym urzÈdzeniem albo za poĂrednictwem magistrali USB (od ang. universal serial bus), albo przez poïÈczenie bezprzewodowe. Sposób wspóïpracy programów z padami nie zaleĝy od sposobu ich poïÈczenia z konsolÈ czy komputerem. PoïÈczenie z padem moĝna wykorzystaÊ zarówno do odczytywania stanu przycisków i gaïek analogowych, jak i do wysyïania poleceñ do pada (na przykïad w celu wïÈczenia lub wyïÈczenia efektu wibracji). Konsola Xbox i framework XNA oferujÈ obsïugÚ maksymalnie czterech podïÈczonych jednoczeĂnie padów. Pady i klasy Informacje o stanie pada sÈ reprezentowane we frameworku XNA przez skïadowe klasy nazwanej GamePadState. Zadaniem tej klasy jest zapewnianie poïÈczenia pomiÚdzy programem a fizycznym padem w dïoniach gracza. Aby zrozumieÊ, jak naleĝy uĝywaÊ tej klasy, musisz pogïÚbiÊ swojÈ wiedzÚ na temat dziaïania wszystkich klas. Rozdziaï 3. Pobieranie danych wejĂciowych od gracza 69 Z lektury punktu „Gry i klasy” zamieszczonego w rozdziale 2. wiesz juĝ, czym jest klasa. Zawiera ona dane (zmienne, które mogÈ reprezentowaÊ rozmaite informacje) oraz metody (kod wykonujÈcy operacje). KlasÚ moĝesz traktowaÊ jako odpowiednik biura z centralnie ustawionym biurkiem, na którym leĝÈ zmienne, oraz pracownikami peïniÈcymi podobne funkcje jak metody. Na rysunku 3.1 pokazano plan biura dla klasy Game1, która — jak juĝ wiesz — jest podstawowym elementem gry opartej na frameworku XNA. RYSUNEK 3.1. Klasa Game1 jako plan biura Klasa zawiera pewne zmienne trzymane na biurku (w tym przypadku zmienne reprezentujÈ intensywnoĂÊ poszczególnych barw) oraz dwie metody, które nazwaliĂmy panem Draw i paniÈ Update. Kaĝda metoda dysponuje wïasnym telefonem. Programy mogÈ dzwoniÊ na te telefony, aby ĝÈdaÊ od poszczególnych metod wykonywania swoich zadañ. Wielka programistka mówi: w rzeczywistoĂci klasy to nie biura Nasza wielka programistka przeczytaïa ten tekst i stwierdziïa, ĝe jest Ămieszny. Mówi, ĝe klasy nie przypominajÈ biur, ale uznaïa, ĝe skoro to porównanie ma uïatwiÊ zrozumienie sposobu konstruowania programów, w takim postrzeganiu klas nie ma niczego zïego. Podczas uruchamiania gry system XNA tworzy eegzemplarz (ang. instance) klasy Game1, który bÚdzie bezpoĂrednim adresatem ĝÈdañ wykonania metod Draw i Update. Podczas tworzenia egzemplarza klasy instrukcje zawarte w metodach tej klasy sÈ ïadowane do pamiÚci, a na potrzeby zmiennych naleĝÈcych do tego egzemplarza jest przydzielana przestrzeñ w pamiÚci. Pliki klas stanowiÈ ěródïo swoistych planów klas, dziÚki czemu podczas dziaïania programu istnieje moĝliwoĂÊ tworzenia egzemplarzy poszczególnych klas. W otaczajÈcym nas Ăwiecie stworzenie biura gry wymaga budowy pomieszczenia, umieszczenia w nim biurka i kilku telefonów oraz zatrudnienia pana Draw i pani Update. Proces tworzenia egzemplarza klasy 70 CzÚĂÊ I Wprowadzenie jest doĂÊ podobny. Okazuje siÚ jednak, ĝe dla oszczÚdnoĂci pamiÚci dziaïajÈcy program posïuguje siÚ tylko jednÈ kopiÈ kodu metody — ta jedna kopia jest wspóïdzielona przez wszystkie egzemplarze tej samej klasy. Uwaga PamiÚtaj, ĝe opisane operacje sÈ realizowane w czasie wykonywania programu. Proces tworzenia egzemplarzy klas nie jest wykonywany przez kompilator. Zadaniem kompilatora jest konwersja kodu ěródïowego jÚzyka C# na instrukcje, które bÚdzie moĝna wykonaÊ na docelowym urzÈdzeniu. W momencie, w którym Twój program przejmuje kontrolÚ nad tym urzÈdzeniem, rola kompilatora siÚ koñczy, a komputer wykonuje wygenerowane przez ten kompilator rozkazy jÚzyka maszynowego. Znajdowanie pada Framework XNA przejmuje odpowiedzialnoĂÊ takĝe za wiele innych aspektów dziaïania gry. Jednym z dostÚpnych rozwiÈzañ jest klasa GamePad poïÈczona ze wszystkimi padami. Nie musisz wiedzieÊ, jak pad jest fizycznie poïÈczony z urzÈdzeniem. Moĝesz postrzegaÊ ten proces jako mikroskopijne chochliki wÚdrujÈce w przewodzie i przenoszÈce na jeszcze mniejszych karteczkach komunikaty, np: „Pierwszy gracz nacisnÈï czerwony przycisk”. Na rysunku 3.2 pokazano, jak wyglÈdaïaby klasa GamePad, gdyby byïa biurem. Klasa GamePad zawiera metodÚ, nazwanÈ GetState, która zwraca bieĝÈcy stan jednego z padów. Po wywoïaniu metody GetState jej kod lokalizuje jeden z padów, odczytuje jego ustawienia, po czym wysyïa uzyskane informacje z powrotem do wyraĝenia, które wywoïaïo tÚ metodÚ (i które moĝe teraz uĝyÊ tych danych). Metoda GetState otrzymuje na wejĂciu parametr identyfikujÈcy pad, którego stan ma byÊ odczytany. PParametr ten umoĝliwia przekazywanie informacji do metody z poziomu jej wywoïania. Z parametrami mieliĂmy do czynienia juĝ wczeĂniej — w Twoim pierwszym programie, gdzie przekazywaïeĂ parametry typu Color do metody Clear, aby wskazaÊ kolor, który miaï byÊ uĝyty do wypeïnienia ekranu. W przypadku metody GetState parametr identyfikuje pad, którego stan chcesz odczytaÊ. JeĂli porównujesz ten mechanizm z funkcjonowaniem biur, moĝesz traktowaÊ parametry jako fragmenty instrukcji przekazywanych wspóïpracownikom przez telefon. Kiedy pan GetState odbiera telefon, sïyszy w sïuchawce: „Podaj mi stan pierwszego pada”. Informacje na temat stanu tego pada sÈ nastÚpnie odsyïane do struktury GamePadState (patrz rysunek 3.3). JeĂli chcesz, moĝesz traktowaÊ parametry jako zbiór elementów wypeïnionego formularza, jednak w rzeczywistoĂci jest to struktura jÚzyka C# zawierajÈca zarówno skïadowe widoczne na rysunku 3.3, jak i pewne dane dodatkowe. Rozdziaï 3. Pobieranie danych wejĂciowych od gracza 71 RYSUNEK 3.2. Klasa GamePad jako biuro RYSUNEK 3.3. Struktura GamePadState reprezentujÈca stan pada z naciĂniÚtym zielonym przyciskiem (A) JeĂli wiÚc pani Update chce uzyskaÊ informacje na temat stanu jednego z padów konsoli Xbox, wywoïuje metodÚ GetState klasy GamePad i prosi: „Czy moĝesz mi przekazaÊ stan pada pierwszego gracza”? Pan GetState zrywa siÚ z fotela, wypeïnia formularz GamePadState i odsyïa go do pani Update. Na rysunku 3.4 pokazano wyraĝenie jÚzyka C# uzyskujÈce stan pada i przypisujÈce ten stan do zmiennej typu GamePadState. 72 CzÚĂÊ I Wprowadzenie RYSUNEK 3.4. Uzyskiwanie statusu pada Testowanie statusu pada Skoro dysponujesz juĝ statusem pada, moĝesz wykorzystaÊ ten status w swoim programie do sprawdzenia, czy gracz wcisnÈï jakiĂ przycisk. Na rysunku 3.5 pokazano kompletne wyraĝenie jÚzyka C#, które wykonuje odpowiedni test. RYSUNEK 3.5. Testowanie przycisku na padzie Wyraĝenie w tej formie porównuje stan czerwonego przycisku (B) z wartoĂciÈ ButtonState.Pressed. JeĂli obie wartoĂci sÈ równe, przycisk jest wciĂniÚty, zatem metoda Update powinna zwiÚkszyÊ intensywnoĂÊ barwy czerwonej. Tych samych zasad moĝesz uĝywaÊ do zarzÈdzania wartoĂciami reprezentujÈcymi intensywnoĂÊ barw niebieskiej i zielonej, co oznacza, ĝe w swojej grze moĝesz posïugiwaÊ siÚ metodÈ Update zawierajÈcÈ nastÚpujÈcy kod: protected override void Update(GameTime gameTime) { // UmoĪliwia wyjĞcie z gry. if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed) this.Exit(); GamePadState pad1 = GamePad.GetState(PlayerIndex.One); if (pad1.Buttons.B == ButtonState.Pressed) redIntensity++; if (pad1.Buttons.X == ButtonState.Pressed) blueIntensity++; if (pad1.Buttons.A == ButtonState.Pressed) greenIntensity++; base.Update(gameTime); } Rozdziaï 3. Pobieranie danych wejĂciowych od gracza 73 W opisanej metodzie Update brakuje juĝ tylko obsïugi ĝóïtego przycisku. Gdy gracz wciska ĝóïty przycisk, program powinien zwiÚkszyÊ intensywnoĂÊ barw zielonej i ĝóïtej, zatem w przypadku speïnienia odpowiedniego warunku musi wykonaÊ dwa wyraĝenia. Okazuje siÚ, ĝe realizacja tego zadania jest bardzo ïatwa — wystarczy umieĂciÊ te dwa wyraĝenia w bloku kontrolowanym przez odpowiedni warunek, tak jak w poniĝszym kodzie: if (pad1.Buttons.Y == ButtonState.Pressed) { redIntensity++; greenIntensity++; } Z blokami miaïeĂ do czynienia juĝ wczeĂniej. Blokiem jest na przykïad ciaïo metody (sekwencja wyraĝeñ skïadajÈcych siÚ na tÚ metodÚ). W jÚzyku programowania C# bblok ma postaÊ pewnej liczby wyraĝeñ otoczonych nawiasami klamrowymi. JeĂli warunek w wyraĝeniu if jest speïniony (ma wartoĂÊ if), powyĝszy kod wykonuje oba wyraĝenia, poniewaĝ znajdujÈ siÚ one w bloku kontrolowanym przez ten warunek. Wielka programistka mówi: bloki to podstawa Nasza wielka programistka stara siÚ stosowaÊ bloki za wyraĝeniami if, nawet jeĂli formalnie nie jest to konieczne. Mówi, ĝe takie rozwiÈzanie poprawia czytelnoĂÊ tekstu programu i ĝe znacznie uïatwia dodawanie ewentualnych wyraĝeñ w przyszïoĂci (jeĂli zajdzie taka potrzeba). JeĂli umieĂcisz powyĝsze wyraĝenia w metodzie Update w ramach jednej z wczeĂniejszych wersji programu Mood Light, otrzymasz komunikaty ostrzeĝeñ kompilatora, poniewaĝ nowa wersja metody Update nie bÚdzie uĝywaïa wszystkich zmiennych utworzonych w starszych wersjach programu. Aby wyeliminowaÊ te ostrzeĝenia, musisz usunÈÊ wyraĝenia tworzÈce nieuĝywane zmienne. Wielka programistka nie lubi, gdy programy zawierajÈ zmienne, które nigdzie nie sÈ uĝywane. Mówi, ĝe to wyglÈda nieprofesjonalnie, z czym trudno siÚ nie zgodziÊ. Przykïadowy kod: rÚczna, wielokolorowa lampa Wszystkie przykïadowe projekty sÈ dostÚpne pod adresem ftp://ftp.helion.pl/przyklady/games4.zip. Przykïadowy projekt z omówionÈ w tym punkcie metodÈ Update znajduje siÚ w katalogu 01 Manual MoodLight w zasobach kodu ěródïowego dla tego rozdziaïu. Moĝesz zwiÚkszaÊ jasnoĂÊ kolorów na ekranie, naciskajÈc przyciski na swoim padzie. Stosowanie klawiatury Framework XNA obsïuguje nie tylko pady, ale teĝ klawiatury. Wielu uĝytkowników ze zdziwieniem odkrywa moĝliwoĂÊ podïÈczenia klawiatury USB do konsoli Xbox 360 i uĝywania jej tak jak w przypadku komputerów PC. JeĂli chcesz napisaÊ program 74 CzÚĂÊ I Wprowadzenie Pomysï na grÚ: Color Nerve Od czasu do czasu bÚdziemy podejmowali próby tworzenia nowych koncepcji gier. PoczÈtkowo nasze gry bÚdÈ bardzo proste, ale z czasem tworzone programy stanÈ siÚ coraz bardziej skomplikowane i interesujÈce. Do utworzenia swojej pierwszej gry moĝesz uĝyÊ kodu zawartego w projekcie Manual MoodLight. Gra wykorzystuje teĝ pewien aspekt opisany w rozdziale 2. Jak zapewne pamiÚtasz, jeĂli stale zwiÚkszasz jakÈĂ wartoĂÊ, prÚdzej czy póěniej osiÈga ona punkt, w którym nie mieĂci siÚ w przydzielonym dla niej obszarze pamiÚci, powodujÈc tzw. przepeïnienie. WïaĂnie dlatego ekran wypeïniony jasnym, biaïym kolorem nagle stawaï siÚ czarny. Okazuje siÚ, ĝe ten sam efekt moĝesz wykorzystaÊ do utworzenia swojej pierwszej „bardzo niemÈdrej gry”. Color Nerve to gra dla co najmniej dwóch graczy. Kaĝdy gracz w swojej kolejce naciska na padzie jeden lub wiele przycisków. (Pozostali gracze muszÈ uwaĝnie obserwowaÊ ekran, aby mieÊ pewnoĂÊ, ĝe gracz, do którego naleĝy ruch, rzeczywiĂcie nacisnÈï przynajmniej jeden przycisk). Kaĝdy gracz moĝe nacisnÈÊ w swojej kolejce dowolnÈ liczbÚ przycisków. JeĂli jednak ekran nagle zmieni kolor (z powodu zmiany intensywnoĂci przynajmniej jednej z barw z 255 na 0), gracz przegrywa, a dalszÈ rozgrywkÚ prowadzÈ pozostali gracze. Ostatni gracz, który pozostaje w grze, jest zwyciÚzcÈ. Gra moĝe mieÊ przebieg taktyczny. Przyciski moĝna naciskaÊ bardzo krótko, ale niektórzy gracze na poczÈtku gry mogÈ wykazaÊ siÚ mocnymi nerwami i przytrzymywaÊ przyciski przez dïuĝszy czas, wpÚdzajÈc w tarapaty pozostaïych graczy. MogÈ oni teĝ podejmowaÊ próby odgadywania, która barwa „przekrÚciïa licznik”, tak aby nieco dïuĝej przytrzymaÊ odpowiedni przycisk w swoim ruchu. Gra sprawdza siÚ na imprezach, poniewaĝ moĝe w niej uczestniczyÊ wiele osób, a jej zasady sÈ wyjÈtkowo proste. W rozdziale 4., zatytuïowanym „WyĂwietlanie obrazów”, udoskonalisz tÚ grÚ, dodajÈc obrazy w miejsce pustego ekranu. wspóïpracujÈcy z klawiaturÈ, wystarczy, ĝe dodasz do swojego programu odpowiedni kod, na przykïad taki jak poniĝej: KeyboardState keys = Keyboard.GetState(); if (keys.IsKeyDown(Keys.R)) redIntensity++; if (keys.IsKeyDown(Keys.B)) blueIntensity++; if (keys.IsKeyDown(Keys.G)) greenIntensity++; if (keys.IsKeyDown(Keys.Y)) { redIntensity++; greenIntensity++; } ’atwo zauwaĝyÊ, ĝe prezentowany proces bardzo przypomina dziaïanie padów, ale istniejÈ teĝ nieznaczne róĝnice. Na potrzeby metody GetState nie musisz okreĂlaÊ klasy Keyboard, dla której klawiatury chcemy uzyskaÊ stan, poniewaĝ framework XNA obsïuguje tylko jednÈ klawiaturÚ. Egzemplarz klasy KeyboardState zwracany przez to wywoïanie Rozdziaï 3. Pobieranie danych wejĂciowych od gracza 75 w rzeczywistoĂci nie jest kartkÈ papieru — jest obiektem udostÚpniajÈcym metody, które moĝesz w swoim programie wykorzystaÊ do okreĂlenia, czy poszczególne klawisze sÈ wciĂniÚte. Zamiast sprawdzaÊ, czy stan przycisku ma przypisanÈ wartoĂÊ ButtonState.Pressed, program moĝe wykonaÊ metodÚ IsKeyDown. Na wejĂciu metody IsKeyDown przekazujesz parametr identyfikujÈcy klawisz, którego stan chcesz sprawdziÊ, jak w poniĝszym przykïadzie: if (keys.IsKeyDown(Keys.R)) redIntensity++; Kod jest wyraĝeniem warunkowym zwiÚkszajÈcym wartoĂÊ zmiennej redIntensity, w przypadku gdy klawisz R jest wciĂniÚty. JeĂli wskazany klawisz jest wciĂniÚty, metoda IsKeyDown zwraca wartoĂÊ true — w przeciwnym razie zwraca wartoĂÊ false. Oznacza to, ĝe moĝemy wykorzystaÊ to wyraĝenie do sterowania aktualizowaniem wartoĂci zmiennej redIntensity. Zatrzymywanie gry za pomocÈ klawisza Escape Metoda Update generowana w czasie tworzenia nowej gry na bazie frameworku XNA zawiera test, który sprawdza, czy na pierwszym padzie wciĂniÚto przycisk Back (wstecz), oraz wywoïuje metodÚ Exit (zatrzymujÈcÈ grÚ), jeĂli ten warunek jest speïniony. JeĂli uĝywasz klawiatury zamiast pada, nie bÚdziesz mógï nacisnÈÊ tego przycisku i — tym samym — zatrzymaÊ gry. Moĝesz jednak dodaÊ test sprawdzajÈcy, czy na klawiaturze nie wciĂniÚto klawisza Escape. Klawisz Escape naleĝy do tzw. klawiszy sterujÈcych (ang. control key). Nie reprezentujÈ one znaków drukowalnych, a jedynie majÈ sygnalizowaÊ dziaïania, których oczekujemy od programu. Innymi przykïadami klawiszy sterujÈcych sÈ Enter i Backspace. Do sprawdzania, czy naciĂniÚto klawisz Escape, sïuĝy ta sama metoda IsKeyDown. if (keys.IsKeyDown(Keys.Escape)) Exit(); Powyĝszy kod zatrzymuje grÚ w momencie naciĂniÚcia klawisza Escape. Jednoczesne uĝywanie pada i klawiatury JeĂli chcesz jednoczeĂnie uĝywaÊ pada i klawiatury, musisz testowaÊ stan obu tych urzÈdzeñ. Oznacza to, ĝe metoda Update powinna mieÊ teraz nastÚpujÈcÈ postaÊ: protected override void Update(GameTime gameTime) { GamePadState pad1 = GamePad.GetState(PlayerIndex.One); if (pad1.Buttons.Back == ButtonState.Pressed) Exit(); if (pad1.Buttons.B == ButtonState.Pressed) redIntensity++; if (pad1.Buttons.X == ButtonState.Pressed) blueIntensity++; if (pad1.Buttons.A == ButtonState.Pressed) greenIntensity++; 76 CzÚĂÊ I Wprowadzenie if (pad1.Buttons.Y == ButtonState.Pressed) { redIntensity++; greenIntensity++; } KeyboardState keys = Keyboard.GetState(); if (keys.IsKeyDown(Keys.Escape)) Exit(); if (keys.IsKeyDown(Keys.R)) redIntensity++; if (keys.IsKeyDown(Keys.B)) blueIntensity++; if (keys.IsKeyDown(Keys.G)) greenIntensity++; if (keys.IsKeyDown(Keys.Y)) { redIntensity++; greenIntensity++; } base.Update(gameTime); } Kod w tej formie jest niedoskonaïy, poniewaĝ wykonujemy tÚ samÈ czynnoĂÊ dwukrotnie, tyle ĝe w wyniku dwóch róĝnych testów. Gdyby wielka programistka miaïa kiedykolwiek okazjÚ zapoznaÊ siÚ z tym kodem, z pewnoĂciÈ nie byïaby zachwycona. Na szczÚĂcie jÚzyk C# oferuje moĝliwoĂÊ ïÈczenia w programie dwóch warunków i wykonywania kodu, jeĂli przynajmniej jeden z nich jest speïniony (ma wartoĂÊ true). Warunki moĝna ïÈczyÊ za pomocÈ logicznego operatora alternatywy (lub), którego wynik jest prawdziwy, jeĂli przynajmniej jeden z jego operandów ma wartoĂÊ true. W kodzie programu operator zapisywany jest w formie dwóch pionowych kresek (||): GamePadState pad1 = GamePad.GetState(PlayerIndex.One); KeyboardState keys = Keyboard.GetState(); if (pad1.Buttons.B == ButtonState.Pressed || keys.IsKeyDown(Keys.R)) redIntensity++; Operator logiczny lub (ang. or) umieszcza siÚ pomiÚdzy dwoma wyraĝeniami logicznymi, które mogÈ mieÊ albo wartoĂÊ true, albo wartoĂÊ false. JeĂli choÊ jedno z tych wyraĝeñ ma wartoĂÊ true, caïy warunek logiczny takĝe ma wartoĂÊ true. W powyĝszym kodzie wartoĂÊ zmiennej redIntensity jest zwiÚkszana, jeĂli wciĂniÚty jest czerwony przycisk na padzie lub przycisk R na klawiaturze (lub oba jednoczeĂnie). Dokïadnie o takie dziaïanie wïaĂnie nam chodziïo. Co wiÚcej, w grÚ Color Nerve moĝna teraz graÊ zarówno przy uĝyciu pada, jak i przy uĝyciu klawiatury (lub korzystajÈc z obu tych urzÈdzeñ jednoczeĂnie). W tym i innych przypadkach mówi siÚ o operatorach logicznych, poniewaĝ kaĝdy z nich zwraca wartoĂÊ logicznÈ, a nie wynik liczbowy. IstniejÈ jeszcze inne operatory logiczne, których bÚdziesz uĝywaï podczas tworzenia bardziej skomplikowanych programów. Rozdziaï 3. Pobieranie danych wejĂciowych od gracza 77 Uwaga JeĂli zrozumienie dziaïania tego operatora logicznego sprawia Ci kïopot, wróÊ do istoty problemu, który próbujesz rozwiÈzaÊ. Chcesz na przykïad, aby Twój program wykonaï pewne wyraĝenie (w tym przypadku redIntensity++), wtedy gdy wciĂniÚto czerwony przycisk na padzie lub gdy wciĂniÚto klawisz R na klawiaturze. JeĂli przynajmniej jeden z tych warunków jest speïniony, wówczas posïugujesz siÚ operatorem lub (||) do poïÈczenia obu testów i wykonania odpowiedniego wyraĝenia. Przykïadowy kod: Color Nerve Przykïadowy projekt implementujÈcy tÚ grÚ moĝna znaleěÊ w katalogu 02 Color Nerve w zasobach dla tego rozdziaïu. Moĝesz zmieniaÊ kolory na ekranie, naciskajÈc przyciski na padzie lub klawisze na klawiaturze. Dodawanie wibracji Komunikacja pomiÚdzy padem a grÈ odbywa siÚ w obu kierunkach. Twoje moĝliwoĂci nie ograniczajÈ siÚ tylko do odczytywania stanu przycisków pada — moĝesz dodatkowo wysyïaÊ do pada polecenia wïÈczajÈce lub wyïÈczajÈce mechanizm wibracji. Takĝe w tym przypadku nie musisz dysponowaÊ szczegóïowÈ wiedzÈ o sposobie dostarczania odpowiednich komunikatów. Wystarczy znajomoĂÊ funkcji frameworku XNA uĝywanych do sterowania efektami wibracji. Oznacza to, ĝe Twoja gra Color Nerve moĝe byÊ jeszcze bardziej wciÈgajÈca i atrakcyjna, jeĂli pad bÚdzie wibrowaï w czasie zbliĝania siÚ wartoĂci intensywnoĂci barw do ich górnych granic. To ciekawe, jak podobne rozwiÈzania mogÈ poprawiÊ oceny nawet najprostszych gier. W kolejnych kilku grach bÚdziesz bardzo czÚsto korzystaï z efektu wibracji. Sterowanie wibracjami pada Klasa GamePad udostÚpnia metodÚ, nazwanÈ SetVibration, która umoĝliwia programowi sterowanie silnikami odpowiedzialnymi za wibracje: GamePad.SetVibration(PlayerIndex.One, 0, 1); Metoda SetVibration uĝywa trzech parametrów. Pierwszy parametr identyfikuje pad, który ma wibrowaÊ. Drugi parametr, który musi mieÊ wartoĂÊ z przedziaïu od 0 do 1, steruje natÚĝeniem wibracji generowanych przez lewy silnik. Im wiÚksza jest ta liczba, tym bardziej intensywne sÈ wibracje pada. Trzeci parametr steruje prawym silnikiem dokïadnie tak samo, jak drugi parametr steruje lewym silnikiem. Powyĝsze wyraĝenie powoduje, ĝe prawy silnik pierwszego pada wibruje z peïnÈ prÚdkoĂciÈ., natomiast lewy silnik jest odpowiedzialny za wibracje z niskÈ czÚstotliwoĂciÈ. JeĂli sobie wyobrazisz, ĝe biuro GamePad zatrudnia pana SetVibration, bÚdziesz mógï przyjÈÊ, ĝe ten pracownik otrzymuje polecenia ustawiania wibracji konkretnego pada 78 CzÚĂÊ I Wprowadzenie wraz z parametrami obrotów lewego i prawego silnika. Po wywoïaniu tej metody pad zaczyna wibrowaÊ i wibruje tak dïugo, aĝ kolejne wywoïanie tej metody nie zmieni ustawieñ jego silników. Innymi sïowy, metodÚ SetVibration moĝna traktowaÊ jako przeïÈcznik, który moĝna ustawiaÊ w wielu róĝnych pozycjach. PoczÈtkowo oba silniki pada majÈ ustawionÈ szybkoĂÊ równÈ 0, co oznacza brak wibracji. Testowanie wartoĂci intensywnoĂci Gra musi oczywiĂcie zdecydowaÊ, w którym momencie naleĝy wïÈczyÊ wibracje. W tym celu musi sprawdzaÊ wartoĂci reprezentujÈce intensywnoĂÊ barw i wïÈczaÊ silnik wibracji, jeĂli któraĂ z tych wartoĂci bÚdzie zbyt duĝa. Program moĝe na przykïad wïÈczaÊ silniki, jeĂli intensywnoĂÊ którejkolwiek z barw — czerwonej, zielonej lub niebieskiej — bÚdzie wiÚksza niĝ 220. Oznacza to, ĝe program musi sprawdzaÊ wartoĂci intensywnoĂci w nastÚpujÈcy spo
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Microsoft XNA Game Studio 4.0. Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i własnego PC
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
89,00 zł
Idź do sklepu »

Opinie na temat publikacji:

Inne popularne pozycje z tej kategorii:

Czytaj również:

Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: