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)