ionut-py

Face Jocuri cu Python & Pygame

De Al Sweigart

Copyright © 2012 de Albert Sweigart

Unele drepturile rezervate. -Face Jocuri cu Python & Pygame‖) este licenţiat sub o Creative Commons Attribution-Noncommercial-Share Alike 3.0 Statele Unite licenţă.

Esti liber:

Pentru a partaja - pentru a copia, distribui, afişaj şi efectuaţi lucrările

Pentru a Remix - sa faca lucrari derivate

În următoarele condiţii:

Atribuirea - atributul trebuie să lucreze în modul specificat de catre autor sau licenţiatorul (dar nu in orice mod care sugerează că ei subscriu dumneavoastră sau utilizarea de munca). (vizibil include titlul şi numele autorului în orice extrase din acest lucru.)

Necomercial - Nu poţi folosi această operă în scopuri comerciale.

Partajaţi - dacă modificaţi deopotrivă, transforma sau construi de la această operă, puteţi distribui rezultate funcţionează doar sub licenţă identice sau similare pentru a prezenta o.

Acest sumar este situat aici: Http://creativecommons.org/licenses/by-nc-sa/3.0/us/

Echitabil utilizarea dvs si alte drepturi nu sunt în nici un fel afectat de mai sus. Există un rezumat pe înţelesul tuturor a Codului Juridic (întreaga licenţă), situat aici: Http://creativecommons.org/licenses/by-nc-sa/3.0/us/legalcode

Rezervaţi versiunea 2

Dacă aţi descărcat această carte de pe un torent, probabil e. Treceţi la Http://inventwithpython.com/pygame pentru a descărca cea mai recentă versiune.

ISBN (978-1469901732) 1-Edition

E-mail intrebari de autor: [email protected]

Pentru Calvin haos

Care este aceasta carte pentru? I

W HO este această carte pentru ?Când primiţi în jos pentru a-l, Programare de jocuri video este doar despre aprinderea pixeli pentru a face destul de imagini apar pe ecran ca răspuns la tastatură şi mouse-ului de intrare.

Şi acolo sunt foarte puţine lucruri care sunt la fel de distractiv.

Această carte vă va învăţa cum să vă graphical jocuri pe calculator în limbajul de programare Python folosind Pygame biblioteca. Această carte presupune că ştii un pic despre Python sau programare în general. Dacă nu ştiţi cum să program, puteţi afla prin descărcarea free book -inventa propriile jocuri pe calculator cu Python‖ din Http://inventwithpython.com. Sau puteţi sări la dreapta în această carte şi mai ales alegeţi-l. Această carte este pentru programator intermediar care a invatat ce variabile şi bucle sunt, dar acum vrea sa stie, -ce programe de joc reale arata?‖ o lung gol după prima programare a invatat dar eu nu ştiu cum să utilizaţi ca priceperea de a face ceva rece. E Speranta mea ca de jocuri în această carte vă va oferi suficiente idei despre cum funcţionează pentru a oferi o programele fundatiei sa implementeze propriile jocuri.

Textul complet din această carte este disponibil în format PDF la HTML sauHttp://inventwithpytho n .com/pygame.

-Al Sweigart

Ii Http://inventwithpython.com/pygame

D espre T I B C ăutaţiBună ziua! Această carte vă va învăţa cum să vă graphical jocuri pe calculator cu cadrul Pygame (denumită de asemenea biblioteca Pygame) în limbajul de programare Python. Pygame facilitează crearea de programe cu grafică 2D. Ambele Python şi cadrul Pygame poate fi descărcat gratuit de la Http://pytho n .sau g şi Http://pygame.org. Aveţi nevoie de un calculator şi această carte să începeţi propria jocuri. Această carte este o carte de programare intermediar. Dacă sunt complet noi pentru programare, încă mai puteţi încerca să urmaţi împreună cu codul sursă exemple şi cum funcţionează de programare. Ar putea fi mai uşor de a învăţa cum să programaţi în Python primul. -inventa propriile jocuri pe calculator cu Python‖ este o carte care este disponibil gratuit de la complet Http://inventwithpytho n .co m . Cartea asta te invata programare făcând non-grafic, bazata pe text de jocuri pentru incepatori, completă şi are de asemenea câteva capitole despre utilizarea Pygame biblioteca. Totuşi, dacă ştiţi deja cum să programaţi în Python (sau chiar o alta limba, deoarece Python este atât de uşor de pick up) şi doriţi să începeţi făcând jocuri dincolo de text, atunci aceasta este cartea pentru tine. Cartea începe cu o scurtă introducere în modul de biblioteca Pygame funcţionează şi funcţiile pe care le oferă. Apoi ea oferă completă de cod sursă pentru unele jocuri reale şi explică cum codul de lucrari, astfel încât puteţi să înţelegeţi cum programele de joc reale de utilizarea a Pygame.

Această carte dispune de şapte jocuri diferite care sunt clonii de jocuri populare ca probabil ai jucat deja. Jocurile sunt mult mai distractiv şi interactiv decât jocuri pe bază de text în -Inventa cu Python‖, dar sunt încă destul de scurt. Toate programele sunt mai puţin de 600 de linii de lungă. Acest lucru este destul de mic atunci când consideră că jocurile profesionale să descărcaţi sau cumpara de la un magazin poate fi sute de mii de linii de lungă. Aceste jocuri necesită o intreaga echipa de programatori şi artişti de lucru cu fiecare alte pentru luni sau ani pentru a face.

Site pentru această carte este Http://inventwithpython.com/pygam e . Toate programele şi fişierele menţionate în acest manual pot fi descărcate gratuit de pe acest site, inclusiv această carte în sine. Programarea este o mare activitate de creative, aşa încât vă rugăm să partajaţi această carte cât mai largă posibil. Licenţa Creative Commons că această carte este eliberată sub vă dă dreptul de a copia şi duplicat de această carte cât de mult doriţi (cât timp nu ai bani de încărcare). Dacă vreodată întrebări despre cum aceste programe de munca, nu ezitaţi să mi e-mail la [email protected].

Despre această carte iii

T CAPABIL DE C ONTENTS Care este aceasta carte pentru ? ............................................................................................... i

Despre acest huidui k ............................................................................................................ i i

Capitolul 1 - Instalarea Python şi Pygam e ............................................................................. 1

Ce trebuie să ştiţi înainte de a Begi n .................................................................................. 1

Descărcarea şi instalarea Pytho n ....................................................................................... 1

Instrucţiune de Windows s ................................................................................................. 1

Mac OS X Instrucţiuni s .................................................................................................... 2

Ubuntu şi Linux Instrucţiune s ........................................................................................... 2

Pornire Pytho n ................................................................................................................. 2

Instalarea Pygam e ............................................................................................................ 3

Cum să utilizaţi acest huidui k ........................................................................................... 4

Programul de caracteristici complete s ................................................................................ 4

Descărcaţi fişierul de sunet şi grafică s ............................................................................... 4

Numerele de linie şi spaţiu s .............................................................................................. 4

Încadrare text în acest huidui k ........................................................................................... 5

Controlaţi codul dumneavoastră Onlin e ............................................................................. 6

Mai multe informatii Informaţii despre Linkuri pe Http://invpy.co m .................................... 6

Capitolul 2 - Pygame Basic s ................................................................................................. 7

GUI vs. CL I .................................................................................................................... 7

Cod sursă pentru buna ziua lume cu Pygam e ...................................................................... 7

Setarea unui Pygame Progra m .......................................................................................... 8

Buclele de joc şi jocul de stat s ......................................................................................... 1 0

Pygame.caz.caz obiect s ......................................................................................... 1 1

Caz şi pygame QUIT.quit() funcţio narea n .............................................................. 1 2

Pixel coordona s .............................................................................................................. 1 3

Iv Http://inventwithpython.com/pygame

Un memento despre funcţiile, metode, Constructor, funcţiile şi funcţii în modulele (o d Diferenţa dintre ele ) ........................................................................................................ 1 4

Obiectele de suprafaţă şi Windo w .................................................................................... 1 5

Culori .............................................................................................................................. 1 6

Culoarea transparentă s .................................................................................................... 1 7

Pygame.Color obiect s ............................................................................................. 1 8

Rect obiect s ................................................................................................................... 1 8

Funcţia de desen primitive s ............................................................................................. 2 0

Pygame.PixelArray obiect s .................................................................................. 2 3

Afişaj de pygame..actualizare() funcţio narea n ........................................... 2 4

Animaţia ......................................................................................................................... 2 4

Cadre pe secundă şi pygame.timp. Obiect de ceas s ..................................................... 2 7

Desen de imagini cu pygame.image. Sarcina() şi blit( ) .................................. 2 8

Fonturi ............................................................................................................................ 2 8

Anti-Aliasin g ................................................................................................................. 3 0

Redarea sunetului s ......................................................................................................... 3 1

Sumar ............................................................................................................................. 3 2

Capitolul 3 - Memorie Puzzl e ............................................................................................. 3 3

Cum de a juca Puzzl Memorie e ....................................................................................... 3 3

Bucla pentru procesul de nesting s .................................................................................... 3 3

Cod sursă de memorie Puzzl e .......................................................................................... 3 4

Credite si import s ........................................................................................................... 4 2

Numerele Magic sunt Ba d ............................................................................................... 4 2

Controalele cu susţin declaraţia mintală s ..................................................................... 4 3

Spune dacă numărul este chiar sau Od d ........................................................................... 4 4

Crash devreme şi Crash adesea ! ...................................................................................... 4 4

Făcând codul sursă Uite Prett y ........................................................................................ 4 5

Cu ajutorul variabilelor constantă în loc de string s ............................................................ 4 6

Că Avem destule pictogramă s ......................................................................................... 4 7

Tuples vs. liste, neschimbătoare vs. Mutabl e .................................................................... 4 7


Despre această carte v

Un element Tuples nevoie de o ........................................................................................ 4 8 Comm braţului longitudinal

Conversia între liste şi Tuple s ......................................................................................... 4 9

Declaraţia globale şi de ce Variabile globale sunt Evi l ...................................................... 4 9

Structuri de date şi lista 2D s ............................................................................................ 5 1

- Start joc‖ Animatio n ..................................................................................................... 5 2

Jocul mai apăru p ............................................................................................................ 5 2

Caz de manipulare mai apăru p ........................................................................................ 5 3

Control W Caseta hich cursorul mouse-ului este de peste ................................................... 5 4

Manipularea Primul clic bo x ........................................................................................... 5 5

Manipularea nepotrivite pereche de pictogramă s .............................................................. 5 6

Manipularea Dacă Jucătorul nu va n ................................................................................. 5 6

Trasarea jocul de stat de grohotiş de n .............................................................................. 5 7

Crearea -Dezvăluit‖ Structur cutii date e ............................................................................ 5 8

Crearea de placa de structură de date: Pasul 1 - Obţineţi toate pictograma posibil s .............. 5 8

Pasul 2 - amestecarea şi Truncating Lista Tuturor pictogramă s .......................................... 5 9

Pasul 3 - plasarea pictograme pe vierilor d ........................................................................ 5 9

Capra de separare o listă în lista lista s .............................................................................. 6 0

Sistemul de coordonate diferite s ...................................................................................... 6 1

Convertirea de la Pixel coordonate pentru rubrica coordona s ............................................. 6 2

Desenul pictograma şi Syntactic Suga r ............................................................................ 6 3

Syntactic zahăr cu obţinerea un spaţiu de placa de pictograma lui de formă şi de colo r ........ 6 4

Desenul caseta de golf r ................................................................................................... 6 4

Manipularea dezvaluiri si acoperind Animatio n ................................................................ 6 5

Desenul întreaga vierilor d ............................................................................................... 6 6

Trasarea Highligh t .......................................................................................................... 6 7

- Start joc‖ Animatio n ..................................................................................................... 6 7

Dezvaluiri si acoperind grupuri de boxe s ......................................................................... 6 8

- Joc câştigat‖ Animatio n ................................................................................................ 6 8

Spune dacă Jucătorul a n n ............................................................................................... 6 9

Vi Http://inventwithpython.com/pygame

De ce deranjez având un principal() ? ...................................................................... 6 9

De ce deranjez cu lizibilitate îmbunătăţită ? ...................................................................... 7 0

Sumar şi un Hacking Suggestio n ..................................................................................... 7 4

Capitolul 4 - Glisaţi Puzzle ................................................................................................... 77

Cum de a juca Glisaţi Puzzle ............................................................................................. 77

Cod sursă pentru a glisa Puzzle ......................................................................................... 77

Al doilea verset, aceeaşi ca prima ...................................................................................... 85

Configurarea butoanelor ................................................................................................... 86

Fiind folosind codul de prost inteligent .............................................................................. 87

Buclă de joc principal ....................................................................................................... 88

Făcând clic pe butoanele de .............................................................................................. 89

Dalele de culisare cu mouse-ul .......................................................................................... 90

Dalele de culisare cu tastatura ........................................................................................... 90

-egal cu unul dintre‖ smecherie cu operatorul în ................................................................. 91

WASD şi tastele săgeţi ..................................................................................................... 91

Efectiv de pavaj glisaţi ..................................................................................................... 92

La ralanti şi rezistorul terminator Pygame programe ........................................................... 92

Control pentru un anumit caz, şi postarea de evenimente pentru a evenimentului Pygame Coadă .............................................................................................................................. 92

Crearea de placa de structură de date ................................................................................. 93

Poziţia de gol de urmărire nu ............................................................................................ 94

Facand o mutare prin actualizarea structurii de date al plăcii de ........................................... 94

Atunci când nu utilizaţi o afirmaţie .................................................................................... 95

Obţineţi un Not-So-aleatoare mutaţi .................................................................................. 96

Convertirea de faianta coordonate pentru Pixel coordonate ................................................. 97

Convertirea de la Pixel coordonate pentru coordonatele de placa de ..................................... 97

Desenul a gresie ............................................................................................................... 97

A face textul apar pe ecran ................................................................................................ 98

Desen de administraţie ..................................................................................................... 99

Trasarea granitei de bord .................................................................................................. 99


Despre această carte vii

Desenul butoanele .......................................................................................................... 100

Anima faianta glisează ................................................................................................... 100

Copia() Metoda de suprafaţă ........................................................................................ 101

Crearea unei noi puzzle .................................................................................................. 103

Resetarea plăcii de însufleţitoare ..................................................................................... 104

Timp vs. memorie este mai avantajos .............................................................................. 105

Numănui nu câteva octeţi ............................................................................................... 106

Nimeni nu ii pasa de câteva milioane de nanosecunde ...................................................... 107

Sumar ........................................................................................................................... 107

Capitolul 5 - Simularea ...................................................................................................... 108

Cum de a juca simula ..................................................................................................... 108

Cod sursă pentru a simula ............................................................................................... 108

Obişnuit de chestii de pornire .......................................................................................... 114

Configurarea butoanelor ................................................................................................. 115

Principalele() ........................................................................................................ 115

Unele variabile locale utilizate în acest program ............................................................... 116

Desen de administraţie şi manipularea Input .................................................................... 117

Control pentru clicuri de mouse ...................................................................................... 118

Control pentru tastatură apasă ......................................................................................... 118

Cele două membre ale jocului de buclă ............................................................................ 119

Descifrarea dacă Player apasă butoanele din dreapta ......................................................... 119

Timpul de epoca ............................................................................................................ 121

Trasarea de placa de ecran .............................................................................................. 122

Acelaşi vechi rezilia() ............................................................................................. 122

De reutilizare a variabilelor constant ............................................................................... 123

Anima butonul Flash ...................................................................................................... 123

Desenul butoanele .......................................................................................................... 126

Schimbare fundal însufleţitoare ....................................................................................... 126

Jocul a peste .................................................................................................................. 127 de animaţie

Viii Http://inventwithpython.com/pygame

Convertirea de la Pixel coordonate pentru butoane ........................................................... 129

Este explicit mai bine decât implicit ................................................................................ 129

Capitolul 6 - Putrede .......................................................................................................... 131

Cum de a juca putrede .................................................................................................... 131

Cod sursă pentru a putrede .............................................................................................. 131

Grila ............................................................................................................................. 137

Cod de configurare ......................................................................................................... 137

Principalele() ........................................................................................................ 138

A separa runGame() .................................................................................................... 139

Caz buclă de manipulare ................................................................................................. 139

Detectare coliziune ......................................................................................................... 140

Detectare coliziune cu Apple .......................................................................................... 141

Mutarea viermele ........................................................................................................... 142

Inserţia() Lista Metoda ............................................................................................ 142

Desenul Ecran ................................................................................................................ 143

Desenul -Apăsaţi o tastă‖ Text la ecranul ......................................................................... 143

Funcţia de checkForKeyPress() ....................................................................................... 143

Ecranul de pornire .......................................................................................................... 144

Rotirea ecranului de pornire text ..................................................................................... 145

Rotaţiile nu sunt perfecte ................................................................................................ 146

Decide unde apare Apple ................................................................................................ 147

Joc cu ecrane de peste .................................................................................................... 147

Funcţiile de desen .......................................................................................................... 148

Nu reutilizaţi numele variabilelor .................................................................................... 151

Capitolul 7 - Tetromino ...................................................................................................... 153

Cum de a juca Tetromino ................................................................................................ 153

Unele Nomenclatura Tetromino ...................................................................................... 153

Cod sursă pentru a Tetromino ......................................................................................... 154

Cod de configurare uzuale .............................................................................................. 166


Despre această carte ix

Setarea Distribuţie constante pentru menţinerea cheile ...................................................... 166

Mai mult cod de configurare ........................................................................................... 166

Setarea bucata de şabloane .............................................................................................. 168

Capra de separare a -Linie de organ‖ pe mai multe linii ..................................................... 171

Principalele() ........................................................................................................ 172

A incepe un joc nou ....................................................................................................... 173

Buclă de joc ................................................................................................................... 174


Întreruperea jocului ........................................................................................................ 174

Cu ajutorul mânerului de variabile pentru mişcarea de intrare de utilizator ......................... 175

Controlaţi dacă un diapozitiv sau de rotaţie este valabil .................................................... 175

Diagnosticare partea de jos ............................................................................................. 178

Mutarea ţinând apăsată tasta ........................................................................................... 179

Lăsând să cadă‖ bucata -Natural ...................................................................................... 182

Desenul totul pe ecran .................................................................................................... 182

MakeTextObjs() , o scurtătură pentru funcţia Text ..................................................... 183


Apăsaţi tasta de aşteptare pentru un caz cu checkForKeyPress() ................................ 183

ShowTextScreen() , un Text generic Screen Funcţie ................................................. 184

Funcţia de checkForQuit() .............................................................................................. 185

Funcţia de calculateLevelAndFallFreq() .......................................................................... 185

Bucăţi de generare cu getNewPiece() ......................................................................... 188

Adăugarea de bucati la placa de structură de date ............................................................. 189

Crearea unei noi structuri de date al plăcii de ................................................................... 189

La isOnBoard() şi isValidPosition() Funcţii ...................................................... 190

Control pentru, şi demontarea, linii complete ................................................................... 192

Conversia de la bordul coordonate pentru coordonatele de pixeli ....................................... 195

Desen o casetă pe bord sau în altă parte pe ecran .............................................................. 195

Desenul totul la ecran ..................................................................................................... 196

X Http://inventwithpython.com/pygame

Desen de scor şi nivelul Text .......................................................................................... 196

Desen o bucată de carton sau în altă parte pe ecran ........................................................... 197

Trasarea -Next‖ bucată .................................................................................................... 197

Sumar ........................................................................................................................... 198

Capitolul 8 - Veverita manca veverita ................................................................................. 200

Cum de a juca veverita manca veverita ............................................................................ 200

Designul Veverita manca veverita ................................................................................... 200

Cod sursă pentru a manca Veverita Veverita .................................................................... 201

Cod de configurare uzuale .............................................................................................. 211

Descriind Structuri de date .............................................................................................. 212

Principalele() ........................................................................................................ 213

La pygame.transforma.flip() .............................................................................. 214

Un joc mai detaliate membru decat de obicei ................................................................... 214

Crearea de Text obişnuit de organ ................................................................................... 215

Camere digitale .............................................................................................................. 215

- Zona activă‖ ................................................................................................................. 217

Urmărirea locaţia de lucruri în lumea jocului ................................................................... 218

Începând cu câteva iarba ................................................................................................. 219

Buclă de joc ................................................................................................................... 219

Control pentru a dezactiva Invulnerability ....................................................................... 219

Mutarea Inamicul Veverite ............................................................................................. 219

Demontarea Departe iarba si veverita obiecte ................................................................... 221

Atunci când ştergerea articolelor din lista, Iterate peste lista în marşarier ........................... 221

Adăugarea de noi iarba si veverita obiecte ....................................................................... 223

Camera foto detensionat şi deplasarea de la Cameră ......................................................... 223

Desenul de fundal, iarba, veverite, şi contorul de sanatate ................................................. 224


Mutarea Player, şi contabile pentru Bounce ..................................................................... 228

Detectare coliziune: Mananca sau fi mâncat ..................................................................... 229


Despre această carte xi

Ecranul de joc peste ....................................................................................................... 231

Castigarea ...................................................................................................................... 232

Desenul a contorului de sănătate grafice .......................................................................... 232


Matematica a funcţiei de sine .......................................................................................... 233

Compatibilitate cu Python versiunea 2 ............................................................................. 236

Funcţia de getRandomVelocity() ..................................................................................... 237

Diagnosticare un loc pentru a adăuga noi veverite si iarba ................................................. 237

Crearea de duşman Veverita Structuri de date .................................................................. 238

Inversarea orientării imaginii veverita .............................................................................. 239

Crearea de structuri de date de iarbă ................................................................................ 239

Control dacă este în afara zonei active ............................................................................. 240

Sumar ........................................................................................................................... 241

Capitolul 9 - Star Remorcherele .......................................................................................... 242

Cum de a juca Star Remorcherele .................................................................................... 242

Cod sursă pentru a Star Remorcherele ............................................................................. 242

Iniţial de configurare ...................................................................................................... 256

Structuri de date în stea remorcherele .............................................................................. 271

- Jocul de stat‖ structura datelor ....................................................................................... 271

Harta‖ de -structura datelor ............................................................................................. 271

Nivelurile de -‖ structura datelor ...................................................................................... 272

Citirea şi scrierea fişiere text ........................................................................................... 272

Fişiere text şi fişierele binare .......................................................................................... 272

Scris la fişierele de ......................................................................................................... 273

Citirea din fişierele ......................................................................................................... 274

Despre Star Hartă de împingere File Format .................................................................... 274

Funcţiile Recursive ........................................................................................................ 280

Supape hidraulice la revărsare ......................................................................................... 281

Prevenirea revărsarea de stivă cu o bază cazul .................................................................. 283

Xii Http://inventwithpython.com/pygame

La inundaţii algoritmul de umplere .................................................................................. 284

Trasarea pe hartă ............................................................................................................ 285

Controlaţi dacă nivelul este terminat ................................................................................ 287

Sumar ........................................................................................................................... 288

Capitolul 10 - Patru Extra Jocuri ......................................................................................... 289

Flippy, o -Othello‖ Clona ................................................................................................ 290

Cod sursă pentru Flippy .................................................................................................. 292

Cerneala vărsare, o -potopul acesta‖ Clona ....................................................................... 305

Cod sursă pentru cerneala vărsaţi .................................................................................... 305

Four-In-A-rând, o -Conectaţi patru‖ Clona ....................................................................... 317

Cod sursă pentru Four-In-A-Rând ................................................................................... 317

Gemgem, o -Bejeweled‖ Clona ........................................................................................ 327

Cod sursă pentru Gemgem .............................................................................................. 327

Sumar ........................................................................................................................... 340

Glosar ............................................................................................................................... 342

Despre autor ...................................................................................................................... 347

Despre această carte xiii

Această pagină necompletată intenţionat.

…cu exceptia mai sus text.

Şi textul de mai sus.








Traceback (cel mai recent apel ultima): Fişierul

"<pyshell#1>", linia 1, în blankpage def

blankpage(): blankpage()

Adâncimea maximă de interogari RuntimeError: depăşită

Xiv Http://inventwithpython.com/pygame


Capitolul 1 - Instalarea Python şi Pygame 1

C HAPTER 1 - I NSTALLINGP YGAME YTHON ŞI PCe trebuie să ştiţi înainte de a începeAcesta ar putea ajuta dacă ştiţi ceva despre programare Python (sau cum să programaţi în altă limbă pe linga Python) înainte de a citi aceasta carte; totuşi, chiar dacă nu puteţi încă să citiţi această carte oricum. Programarea nu este aproape la fel de tare ca oamenii cred ca este. Dacă vă activaţi în unele probleme, puteţi citi cartea gratuit -inventa propriile jocuri pe calculator cu Python‖ online la Http://inventwithpython.com sau pentru a căuta un subiect în care găsiţi confuz pe inventa cu Python wiki la Http://inventwithpython.com/wiki. Nu aveţi nevoie să ştiţi cum să utilizaţi biblioteca Pygame înainte de a citi aceasta carte. Capitolul următor este un scurt tutorial pe toate caracteristicile majore ale Pygame şi funcţii.

Doar în cazul în care nu a citit prima carte şi deja instalat Python şi Pygame pe calculator, instrucţiunile de instalare sunt în acest capitol. Dacă aveţi deja instalat atât de aceste apoi puteţi omite acest capitol.

Descărcarea şi instalarea PythonÎnainte de a ne putem începe programarea va trebui să instalaţi software numit Python interpret pe calculatorul dvs. (poate fi nevoie să solicitaţi un adult pentru ajutor aici.) interpretul este un program care înţelege instrucţiunile pe care veţi scrie (sau, mai degrabă, de tip) în Python limba. Fara interpret, calculatorul dumneavoastră nu va putea să ruleze programe Python dvs. Vom consultaţi -Python interpret‖ ca -Python‖ de acum.

A Python interpret de software poate fi descărcat de pe site-ul oficial de limbaj de programare Python, Http://ww w .pytho n .ORG. Aţi putea dori ajutorul altcuiva să descărcaţi şi să instalaţi software-ul Python. Instalarea este un pic diferit în funcţie de dacă sistemul de operare al calculatorului este Windows, Mac OS X sau un sistem de operare Linux precum Ubuntu. Puteţi de asemenea găsi clipuri video online de oameni de instalarea Python software pe computerele lor la Http://invpy.com/installing. Instrucţiuni de operare Windows

Când ajungeţi la Http://pytho n .sau g , ar trebui să vedeţi o listă de linkuri pe stânga (cum ar fi -Despre‖, -Stiri‖, -‖ Documentaţia, -Download‖, a.). Faceţi clic pe legătura de descărcare pentru a merge la

2 Http://inventwithpython.com/pygame

Pagina de descărcare, apoi căutaţi fişierul numit -Python 3.2 Windows Installer (binare Windows -- nu include sursa)‖ şi faceţi clic pe link pentru a descărca Python pentru Windows.

Faceţi dublu clic pe python-3.2.msi că tocmai aţi descărcat de pornire a Python installer. (dacă acesta nu porneşte, încercaţi făcând clic dreapta pe fişier şi alegerea instalaţi .) Odată ce instalatorul porneşte, doar ţine făcând clic pe butonul Next şi doar accepta opţiunile de instalare deoarece mergeţi (nu este nevoie de a face orice modificări). Când instalarea este finalizată, faceţi clic pe Finalizare .

Mac OS X InstrucţiuniMac OS X 10,5 vine cu Python 2.5.1 pre-instalat de Apple. În prezent, Pygame acceptă numai Python 2 şi nu Python 3. Cu toate acestea, programele în această carte funcţionează cu ambele Python 2 şi 3.

De asemenea, site are anumite Python informaţii suplimentare despre utilizarea Python pe un Mac la Http://doc s .Python.org/Dev/Using/Ma c .htm l . Ubuntu Linux şi instrucţiuniPygame pentru Linux suportă doar de asemenea Python 2, nu Python 3. Dacă sistemul de operare este Ubuntu, puteţi să instalaţi Python prin deschiderea unui terminal fereastra (de la desktop clic pe Aplicaţii > Accesorii > Terminal ) şi intrarea - sudo apt-get install python2.7 ‖ apoi apăsaţi Enter. Va trebui să introduceţi parola de root pentru a instala Python, astfel încât cere persoanei care detine calculatorul la tipul din această parolă dacă nu cunoaşteţi.

De asemenea, trebuie să instalaţi un software de ralanti. De la terminal, tip in - sudo apt-get install ‖ de ralanti. Parola de root este de asemenea necesar să instalaţi DE RALANTI (întrebaţi proprietarul calculatorului dumneavoastră să tastaţi în această parolă pentru dvs.).

Pornire PythonVom fi cu ajutorul software liber de la tipul din programele noastre şi rulaţi-le. Suporturile de ralanti pentru i nteractive D EVA L nvironment opment E. Dezvoltarea mediului este un software care face mai uşor pentru a scrie programe Python, exact ca procesor facilitează scrie carti.

Dacă sistemul de operare este Windows XP, ar trebui să puteţi rula Python făcând clic pe butonul Start şi apoi selectarea programelor, Python 3.1, DE RALANTI (Python GUI). Pentru Windows Vista sau

Windows 7, doar faceţi clic pe butonul Windows în colţul stânga, tip -‖ de ralanti şi selectaţi -DE RALANTI (Python GUI)‖.

Dacă sistemul de operare este Max OS X, porniţi la ralanti prin deschiderea geamului de vizare şi faceţi clic pe aplicaţii, apoi faceţi clic pe Python 3.2, apoi faceţi clic pe pictograma de ralanti.


Dacă sistemul de operare este Ubuntu sau Linux, începeţi prin deschiderea de ralanti un terminal window şi apoi de tip - ‖ ralanti3 şi apăsaţi Enter. Puteţi de asemenea să faceţi clic pe Aplicaţii în partea de sus a ecranului şi apoi selectaţi programare, apoi la ralanti 3.

Fereastra care apare la prima rulare la ralanti este numit shell interactive . Un shell este un program care vă permite să introduceţi instrucţiunile în calculator. În Python shell vă permite să introduceţi Python instrucţiuni şi învelişul trimite aceste instrucţiuni de Python interpret pentru a efectua.

Instalarea PygamePygame nu vin cu python. Ca Python, Pygame este disponibilă gratuit. Va trebui să descărcaţi şi instalaţi Pygame, care este la fel de uşor ca şi descărcarea şi instalarea Python interpret. Într-un browser web, accesaţi adresa URL Http://pygam e .sau g şi faceţi clic pe legătura de‖ -descărcări de pe partea stângă a site web. Această carte presupune că aveţi sistemul de operare Windows, dar Pygame funcţionează în acelaşi pentru fiecare sistem de operare. Trebuie să descărcaţi Pygame instalare pentru sistemul de operare şi de versiunea Python aţi instalat. Nu doriţi să descărcaţi -‖ sursă pentru Pygame, ci mai degraba cu Pygame -‖ binare pentru sistemul dumneavoastră de operare. Pentru Windows, descărcaţi pygame-1.9.1.win32-py3.2.msi. (Aceasta este Pygame pentru Python 3.2 pe Windows. Dacă aţi instalat o versiune diferită a Python (cum ar fi 2.7 sau 2.6) Descărcaţi .msi pentru versiunea de Python.) versiunea curentă a Pygame la momentul această carte a fost scrisă este 1.9.1. Dacă vedeţi o versiune nouă de pe site, descărcaţi şi instalaţi Pygame mai noi.

Pentru Mac OS X, descărcaţi .zip sau .dmg file pentru versiunea de Python aveţi şi rulaţi-o.

Pentru Linux, deschideţi un terminal şi rulaţi - sudo apt-get install python-pygame ‖.

Pe Windows, faceţi dublu clic pe fişierul descărcat pentru a instala Pygame. Pentru a verifica că Pygame este instalat corect, tip următoarele în cochilia interactive:

>>> import pygame


Dacă nu apare nimic după ce aţi lovit tasta Enter, apoi stii Pygame a fost instalat cu succes. Dacă eroarea ImportError: Nr. modul numit pygame apare, apoi încercaţi să instalaţi din nou Pygame (şi asiguraţi-vă că aţi introdus corect pygame import).

Acest capitol are cinci mici programe care demonstra cum să utilizaţi diferite caracteristici care asigură Pygame. În ultimul capitol, va utiliza aceste caracteristici pentru un joc complet scris în Python cu Pygame.

Un tutorial video despre cum să instalaţi Pygame este disponibil de la această carte website-ul Http://invpy.com/videos. Cum să utilizaţi această carte-Face Jocuri cu Python & Pygame‖ este diferit de alte carti de programare deoarece se concentrează pe întregul cod sursă pentru mai multe programe de joc. În loc de a vă didactice concepte şi lăsând de programare până la tine pentru a face programele cu aceste concepte, această carte vă arată unele programe şi apoi explică modul în care sunt puse impreuna.

În general, ar trebui să citiţi aceste capitole în ordine. Există multe concepte care sunt utilizate în aceste jocuri, şi acestea sunt doar a explicat în detaliu în primul joc în care apar. Dar dacă există un joc să cred că este interesant, merge înainte şi sări la acest capitol. Puteţi întotdeauna citiţi capitolele anterioare mai târziu dacă ai inainte de tine.

Programele de caracteristici completeFiecare capitol se concentrează pe un singur program de joc şi explicaţi cum diferite parti din codul funcţionează. Este foarte util pentru a copia aceste programe prin tastarea în linie cu linie de cod din această carte.

Cu toate acestea, puteţi descărca codul sursă fişier din această carte. Într-un browser web, accesaţi adresa URL Http://invpy.com/source şi urmaţi instrucţiunile pentru a descărca codul sursă fişier. Dar introducerea textului în codul de tine chiar vă ajută să aflaţi informaţii codul mai bine. Descărcarea de fişiere de sunet şi graficăÎn timp ce vă puteţi doar de tip în codul citit din această carte, va trebui să descărcaţi fişiere de sunet şi grafică utilizate de jocuri în această carte de la Http://invp y .com/descărcări. Asiguraţi-vă că aceste fişiere de sunet şi de imagine sunt amplasate în acelaşi folder ca şi fişierul .py Python altfel nu va fi programul Python capabil de a găsi aceste fişiere. Numerele de linie şi spaţiiCând introduceţi codul sursă-te, nu introduceţi numerele de linie care apar la începutul fiecărei linii. De exemplu, dacă vedeţi acest în carte:


1. Numărul = random.randint(1, 20)2. Spam = 423. Imprimaţi('Hello lume!")

Nu este nevoie să introduceţi -1.‖ pe partea stângă sau de spaţiu care urmează imediat după ea. Doar de tip cam aşa:

Numărul = random.randint(1, 20) spam = 42Imprimaţi('Hello lume!")

Aceste numere sunt utilizate numai pentru ca această carte poate consultaţi linii specifice in cod. Ele nu sunt parte din programul de efective.

O parte de la numerele de linie, aveţi grijă să introduceţi codul exact aşa cum apare. Observaţi că unele din liniile nu începe de la marginea din partea stângă extremă de pe pagina, dar sunt adâncit de patru sau opt sau mai multe spaţii. Aveţi grijă să introduceţi corect numărul de spaţii la începutul fiecare linie. (deoarece fiecare caracter în ralanti este de aceeaşi lăţime, puteţi să număraţi numărul de spaţii de numărare a numărul de caractere de mai sus sau mai jos linie le priviţi.)

De exemplu în codul de mai jos puteţi vedea că a doua linie este începută de către patru spaţii pentru că cele patru caractere (-whil‖) pe linia de mai sus sunt peste începută de spaţiu. A treia linie este începută de către un alt patru spaţii (cele patru caractere, -dacă n‖ sunt peste linia a treia este începută de spaţiu):

În timp ce spam < 10:

Dacă numărul == 42: IMPRIMARE('Hello')

Încadrare text în această carteUnele linii de cod sunt prea lungi pentru a monta pe o linie de pe pagini din această carte şi textul din cod va înfăşuraţi în jurul la următoarea linie. Când introduceţi aceste linii în fişierul editor, introduceţi codul toate pe o linie fără apăsarea Enter.

Puteţi spune când o nouă linie începe prin a uita la numerele de linie de pe partea stângă a cod. De exemplu, codul de mai jos are doar două linii de cod, chiar dacă prima linie se înfăşoară în jurul:

1. Imprimaţi('Aceasta este prima linie! Xxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxx")2. Imprimaţi('Aceasta este a doua linie, nu de linia a treia.")


Controlaţi codul dumneavoastră onlineAnumite programe în această carte sunt un pic de timp. Deşi este foarte utilă pentru a afla Python prin introducerea în codul sursă pentru aceste programe, vă poate face erorile tipografice care cauza accidental programelor dumneavoastră la accident a. Acesta nu poate fi evident unde typo este.

Puteţi copia şi lipi textul codului sursă dvs online la cartea dispozitivului dif. Testerul va indica a diferenţialului de orice diferenţe între codul sursă în carte şi codul sursă aţi tastat. Aceasta este o modalitate uşoară de diagnosticare orice erorile tipografice în programul dvs.

Copierea şi lipirea textului este un calculator foarte util, special pentru calificare programare calculator. Există un tutorial video pe copierea şi lipirea la această carte website-ul Http://invpy.com/copypaste. Dif online dispozitivului este la această pagină web: Http://invpy.com/diff/pygam e . Există de asemenea un tutorial video despre cum să utilizaţi acest instrument de pe website-carte. Mai multe informatii Informaţii despre Linkuri pe Http://invpy.comExistă o mulţime care puteţi afla despre programare. Dar nu aveţi nevoie pentru a afla toate de acum. Există de mai multe ori în această carte unde aţi putea dori pentru a afla aceste detalii şi explicaţii suplimentare, dar daca eu ii incluse în această carte apoi ar adăuga mai multe pagini. Dacă această carte mai mari, mai grele cade accidental pe tine de greutatea aceste multe pagini suplimentare ar te zdrobesc, rezultând moartea. În schimb, am inclus - mai multe informatii‖ link-uri în această carte să puteţi urmări pe acest website-carte. Nu trebuie să citiţi aceste informaţii suplimentare pentru a înţelege nimic din această carte, dar există. dacă sunt curios. Aceste (şi alte) legături au fost scurtate şi începe cu Http://invp y .co m . Toate informaţiile din aceste -mai multe info‖ links poate fi de asemenea descărcat de Http://invpy.com/pygamemoreinfo. Chiar dacă această carte nu este periculos de grea, vă rugăm să nu lăsaţi să cadă pe tine oricum.

Capitolul 2 - elemente de bază Pygame 7

C HAPTER 2 - P YGAME B ASICCa si cum Python mai multe module ca , , sau de matematica aleatoriu timp care oferă funcţii suplimentare pentru programele dvs., cadrul Pygame include mai multe module cu funcţii pentru trasarea grafică, redarea de sunete, manipularea mouse-ului de intrare şi alte lucruri.

Acest capitol va acoperi modulele de bază şi funcţii care Pygame oferă şi presupune că ştiţi deja programare Python de bază. Dacă aveţi probleme cu unele concepte de programare, puteţi citi în -inventa propriile jocuri pe calculator cu Python‖ carte online la Http://invp y. com/huidui k . Această carte este menita a finaliza incepatori la programare. -Inventa cu Python‖ carte are de asemenea cateva capitole care acoperă Pygame. Puteţi să le citiţi online la Http://invp y. com/chap17. Odată ce aţi afla mai multe despre Pygame, puteţi vizualiza alte module care Pygame oferă din documentaţia online la Http://pygame.org/doc s . GUI vs. CLIProgramele de Python puteţi scrie cu Python încorporat de funcţii numai trataţi cu text prin print() şi funcţiile de intrare(). Programul dumneavoastră poate afişa textul de pe ecran şi să lăsaţi tip utilizator în text de la tastatură. Acest tip de program are o interfaţă cu linie de comandă , sau CLI (care este pronunţată ca prima parte a -urca‖ şi rime cu -cer‖). Aceste programe sunt oarecum limitată deoarece nu pot afişa grafica, au culori, sau folosiţi mouse-ul. Aceste programe de CLI obţine decât de intrare de la tastatură cu input() şi chiar şi apoi utilizatorul trebuie să apăsaţi Enter inainte de program poate răspunde la intrare. Aceasta înseamnă în timp real (continuă să funcţioneze fără cod de aşteptare pentru utilizator) jocurile de acţiune sunt imposibil de a face.

Pygame oferă funcţii pentru crearea de programe cu o interfaţă grafică pentru utilizator , sau GUI (pronunţat, -gumos‖). In loc de un text pe baza de CLI, programele cu o placă grafică pe baza de GUI poate indica o fereastra cu imagini şi culori.

Cod sursă pentru buna ziua lume cu PygamePrimul nostru program efectuate cu Pygame este un mic program care face o fereastra care zice lumea Alo!‖ apar pe ecran. Deschide un fişier nou editor făcând clic pe meniul Fişier lui de ralanti, apoi geam nou . Tip în următorul cod în editorul de dosarul lui de ralanti şi o salva ca blankpygame.py . Apoi rulaţi programul prin apăsarea F5 sau selectând RUN > rulaţi module

din meniul din partea de sus a fisierului editor.


Reţineţi, nu introduceţi numerele sau perioadele de la începutul fiecărei linii (asta este doar pentru referinţă în această carte).

1. Import pygame, sys2. De la pygame.localnicii import *

3.4. Pygame.init()5. DISPLAYSURF = pygame.afişaj.set_mode((400, 300))6. Pygame.afişaj.set_Titlul('Hello lume!")

7. În timp ce adevarat: # jocul principal de buclă 8. Pentru caz în caz.obtine pygame.():9. Dacă caz.tip == QUIT:

10. Pygame.quit()11. Sys.exit()12. Pygame.afişaj.actualizare()

Când efectuaţi acest program, o fereastră de negru ca aceasta va apărea:

Yay! Tocmai aţi făcut din lume cele mai plictisitoare joc video! E doar o fereastră cu Alo!‖ în partea

de sus a ferestrei (în ceea ce se numeşte bara de titlu a ferestrei , care deţine titlul text). Dar crearea

unui geam este primul pas pentru a face jocurile grafice. Când faceţi clic pe butonul X în colţul ferestrei, programul se va încheia şi fereastra va dispărea.

Apelarea print() pentru a face textul apar în fereastra nu funcţionează deoarece print() este o funcţie pentru CLI programe. La fel si pentru intrare() pentru a obţine tastatură de intrare de utilizator. Pygame utilizează alte funcţii pentru intrare şi ieşire care sunt explicate mai târziu în acest capitol. Acum, să privim fiecare linie în lumea noastră Alo‖ program în mai multe detalii.

Setarea unui Program PygamePrimele câteva linii de cod in lumea buna programului sunt liniile care va începe aproape fiecare program scrie că utilizează Pygame.

1. Import pygame, sys


Linia 1 este o simplă declaraţie de import ca importurile de pygame şi module de sys astfel încât programul nostru poate utiliza funcţiile în ele. Toate funcţiile Pygame tratare grafică, sunet şi alte caracteristici care asigură Pygame sunt în modulul pygame.

Reţineţi că atunci când modulul de import pygame vă importa automat toate modulele care sunt în modulul pygame, precum pygame.imaginilor şi pygame.mixer.muzica .Nu există nevoia de a importa aceste module-module de interior cu declaratiile de import suplimentare.

2. De la pygame.localnicii import *

Linia 2 este de asemenea o declaraţie de import. Totuşi, în loc de import format modulename, foloseşte din modulename format de import * În mod normal dacă doriţi să apelaţi o funcţie care este în modul, trebuie să utilizaţi modulename.functionname() formatul după modulul de importator. Cu toate acestea, cu din import modulename * , puteţi omite modulename. Pur şi simplu utilizaţi functionname porţiune şi() (ca Python încorporat de funcţii).

Motivul pentru care folosiţi acest formular de declaraţie de import pentru pygame.localnicii este deoarece pygame.localnicii conţine mai multe variabile de constantă care sunt uşor de identificat ca fiind in pygame.localnicii pygame modulul fără.localnici. În faţa lor. Pentru toate celelalte module, aveţi în general doriţi să utilizaţi formatul modulename regulate de import. (Există mai multe informaţii despre ce doriţi să faceţi acest lucru la Http://invpy.com/namespaces.) 4. Pygame.init()

Linia 4 este pygame.init() apel, care întotdeauna trebuie să fie numit după importarea pygame modulul şi înainte de apelarea orice alte Pygame funcţie. Nu ai nevoie sa stii ce această funcţie nu, trebuie doar să ştii că acesta trebuie să fie numit prima pentru multe funcţii Pygame la lucru. Dacă ai văzut vreodată un mesaj de eroare ca pygame.eroare: font nu este iniţializată , verificaţi pentru a vedea dacă aţi uitat să apelaţi pygame.init() la începutul programului dvs.

5. DISPLAYSURF = pygame.afişaj.set_mode((400, 300))

Linia 5 este un apel la pygame.afişaj.set_mode() , care revine la suprafaţa obiectului de pygame.fereastra. (suprafaţă obiecte sunt descrise mai târziu în acest capitol.) observa ca vom trece un tuple de două numere întregi de funcţie: (400, 300) . Acest tuple spune set_mode() cât de mare şi cât de mare pentru a face geamul în pixeli. (400, 300) va face o fereastră cu o lăţime de 400 pixeli şi înălţime de 300 pixeli.


Nu uitaţi să treacă un tuple de două numere întregi pentru a seta_mode() , nu doar două numere întregi. Corectă de a apela funcţia este ca aceasta: pygame.afişaj.set_mode((400, 300)) . O funcţie apel ca pygame.afişaj.set_mode (400, 300) va cauza o eroare care arată ca acest: TypeError: argument 1 trebuie să fie de 2-articolul secvenţa, nu int .

Suprafaţa de pygame. obiect (vom le apel obiecte de suprafaţă pentru scurt) returnate este memorat în o variabilă numită DISPLAYSURF .

6. Pygame.afişaj.set_Titlul('Hello lume!")

Linia 6 seturi de text care va apărea în partea de sus a ferestrei prin apelarea pygame.afişaj.set_Titlul() . Şirul valoarea "Bună ziua lume!" este trecut în această funcţie apel pentru a face ca textul apar ca titlul:

Buclele de joc şi de joc membre7. În timp ce adevarat: # jocul principal de buclă 8. Pentru caz în caz.obtine pygame.():

Linia 7 este un timp buclă care are o starea pur şi simplu valoarea adevărată . Aceasta înseamnă că niciodată nu iese datorită stării sale de evaluare la fals . Singurul mod de a programului va mai ieşi din bucla este dacă o limită declaratie este executată (care se deplasează executarea de prima linie după buclă) sau sys.exit() (care încheie programul). Dacă o buclă de acest fel a fost în interiorul unei funcţii, o declaraţie de retur se va mişca executarea din bucla (precum şi funcţia prea).

Jocuri în această carte toate au aceste bucle de adevărat în ele în timp ce împreună cu un comentariu pe care o numesc - jocul principal‖ buclă. O buclă de joc (numită de asemenea o buclă principală ) este o buclă unde codul nu trei lucruri:

1. Mânere de evenimente.2. Actualizează jocul de stat.3. Trage jocul de stat de ecran.

Jocul membru este pur şi simplu un mod de a face trimitere la un set de valori pentru toate variabilele intr-un joc de program. În multe jocuri, jocul a stat include valorile în variabile care pinii jucător de sănătate şi de poziţie, şi poziţia de dusmani, care marchează au fost făcute pe o placa, scor sau al caror rând este. Ori de câte ori se întâmplă ceva ca player


Luând deteriorarea (care coboară valoarea lor de sănătate), sau dusman se deplasează undeva, sau se intampla ceva in lumea jocului spunem că jocul de stat s-a schimbat.

Dacă aţi mai jucat un joc care vă permit să salvat, - salvaţi membru‖ este jocul de stat la punctul în care aţi salvat-o. În cele mai multe jocuri, oprindu-se de jocul va preveni jocul de stat de la schimbarea.

Deoarece jocul de stat este de obicei actualizat în răspuns la evenimente (cum ar fi clicuri de mouse sau tastatură apasă) sau trecerea timpului, buclă de joc este constant de mai multe ori pe secundă pentru orice evenimente noi care au petrecut. În interiorul buclă principală este organ care arată la evenimentele care au fost create (cu Pygame, aceasta se face prin apelarea pygame.caz.obţineţi() ). Buclă principală are de asemenea cod care actualizează jocul de stat pe baza evenimentelor care au fost create. Aceasta este de obicei denumită caz de manipulare .

Pygame.caz.Caz de obiecteOrice moment utilizatorul nu are unul din mai multe acţiuni (acestea sunt enumerate mai târziu în acest capitol) cum ar fi apăsarea o tastatură tasta sau deplasarea mouse pe fereastra programului, un pygame.caz.caz obiect este creat de biblioteca Pygame pentru a înregistra acest -caz‖. Acesta este un tip de obiect numit caz că există în cazul în care modul de sine este în modul pygame.) putem afla care evenimentele au petrecut prin apelarea pygame.caz.obţineţi() , care returnează o listă de pygame.caz.caz obiecte (care nu va suna la caz de obiecte pentru scurt).

Lista de caz obiecte vor fi pentru fiecare caz că sa întâmplat de la ultima pygame.caz.obţineţi() a fost numit. (Sau, dacă pygame.caz.obţineţi() nu a fost

niciodată numit, evenimentele petrecute de la începutul programului.)


7. În timp ce adevarat: # jocul principal de buclă 8. Pentru caz în caz.obtine pygame.():

Linia 8 este o buclă pentru ca va iterate peste lista de caz obiecte care a fost returnat de pygame.caz.obţineţi() . Pe fiecare prin iteratie pentru o variabilă numită buclă, cazul va fi atribuit valoarea următorul eveniment obiect în această listă. Lista cu obiectele returnate de pygame.caz.obţineţi() va fi în ordinea în care evenimentele întâmplat. Dacă utilizatorul a făcut clic pe mouse şi apoi apăsat tasta o tastatură, caz obiect pentru clic de mouse ar fi primul element din listă şi caz obiect pentru tastatura apăsaţi ar fi doua. Dacă nu evenimentele au petrecut, apoi pygame.caz.obţineţi() va reveni o listă goală.

Caz şi pygame QUIT.quit()

9. Dacă caz.tip == QUIT:10. Pygame.quit()11. Sys.exit()

Obiectele au un membru variabil (numite de asemenea atribute sau proprietăţi ) numit tip care ne spune ce fel de caz obiectul reprezintă. Pygame are o constantă pentru fiecare variabilă de tipuri posibile în pygame.localnicii module. Linia 9 controale dacă caz tip de obiect este egal cu demisia constant . Reţineţi că deoarece am folosit de la pygame.localnicii import * sub forma de declaratie de import, avem doar la tipul QUIT în loc de pygame.localnicii.QUIT .

Dacă evenimentul este un obiect quit caz, apoi pygame.quit() şi sys.exit() funcţii sunt

denumite. La pygame.quit() este un fel de opusul pygame.init() : se ruleaza de cod care dezactivează Pygame biblioteca. Programele dumneavoastră trebuie întotdeauna să apelaţi pygame.quit() inainte de apel sys.exit() pentru a încheia programul. În mod normal nu prea conteaza deoarece Python se închide când programul iese oricum. Dar există un bug în ralanti care determină să atârne de ralanti dacă un program se încheie înainte de pygame Pygame.quit() este numit.

Deoarece nu avem nici daca afirmatiile ca rula cod pentru alte tipuri de caz obiect, nu există niciun caz de manipulare de cod pentru atunci când utilizatorul clicuri de mouse, apasă tastele tastaturii, sau determină orice alt tip de caz crearea obiectelor. Utilizatorul poate face lucruri pentru a crea aceste obiecte de evenimente dar nu schimba nimic din programul pentru ca programul nu are orice caz de manipulare de cod pentru aceste tipuri de caz de obiecte. După buclă pe linia 8 pentru este efectuată de manipulare toate obiectele care au fost returnate de către pygame.caz.obţineţi(), executarea programului continuă să linia 12.

12. pygame.afişaj.actualizare()



Linia 12 pygame.afişaj de apeluri.actualizare() , care atrage suprafaţa obiectului returnat de pygame.afişaj.set_mode() de ecran (amintesc am memorat acest obiect în variabila DISPLAYSURF). Deoarece suprafaţa obiectului nu a schimbat (de exemplu de unele dintre funcţiile de desen care sunt explicate mai târziu în acest capitol), aceeaşi imagine negru este retrasată de ecran de fiecare dată pygame.afişaj.actualizare() este numit.

Care este întregul program. După linia 12 este realizată, rezistenţă infinită în timp ce porneşte din nou cu buclă de la început. Acest program nu are nimic pe linga face o fereastra negru apar pe ecran, verificaţi constant pentru a părăsi caz, şi apoi la retrasarea neschimbate fereastra la ecran negru de peste si peste din nou. Să învăţăm cum să faceţi lucruri interesante apar pe această fereastră în loc de doar intuneric prin învăţarea despre pixeli, suprafaţă de obiecte, obiecte de culoare, Rect obiecte, şi funcţiile de desen Pygame.

Coordonatele de pixeliFereastra ca -Hello World‖ program creează este doar compus din patratica punctele de pe ecran numit de pixeli . Fiecare pixel începe off de negru dar poate fi setată la o culoare diferită. Imagina ca in loc de o suprafaţă obiect care este de 400 pixeli latime si de 300 pixeli inaltime, am avut o suprafaţă obiect care a fost de 8 pixeli de 8 pixeli. Dacă mici de 8x8 suprafaţa a fost mărit astfel încât fiecare pixel arată ca un pătrat în a grilei şi am adăugat numerelor pentru axa X şi Y, apoi o bună reprezentare a putea uita ceva de genul:

Ne putem referi la o anumit pixel folosind un sistem de coordonate carteziene. Fiecare coloană a axelor X şi fiecare rând al axei Y va avea o -adresa‖ că este un număr întreg de la 0 la 7 astfel încât să ne putem localiza orice pixel prin specificarea axelor X şi Y numere întregi.

De exemplu, în peste 8x8, imaginea putem vedea ca pixeli la Coordonatele XY (4, 0, 2, 2, 0, 5), si (5, 6) au fost vopsite de negru, pixel la (2, 4) a fost pictat gri, în timp ce toate celelalte pixelii sunt vopsite în alb. Coordonatele XY sunt de asemenea denumite puncte . Dacă aţi realizat o matematica de clasa si invatat despre coordonate carteziene, puteţi observa că axa Y începe la 0 în partea de sus şi apoi creşte o coborâre , mai degrabă decât creşterea cum merge. Aceasta este doar cât de lucru în coordonate carteziene Pygame (şi aproape fiecare limbaj de programare).


În cadrul Pygame adesea reprezintă un tuple coordonate carteziene a două numere întregi, cum ar fi (4, 0) sau (2, 2). Primul număr întreg este coordonata X şi a doua este coordonata Y. (coordonate carteziene sunt acoperite în detaliu în capitolul 12 din -inventa propriile jocuri pe calculator cu Python‖ la Http://invp y. com/chap12)

Un memento despre funcţiile, metode, Constructor, funcţiile şi funcţii în modulele (şi diferenţa între ele)Funcţii şi metode sunt aproape acelaşi lucru. Acestea pot fi ambele numite pentru a executa cod în ele. Diferenţa între o funcţie şi o metodă este ca o metodă va fi întotdeauna ataşat la un obiect. Metodele de obicei schimba ceva despre acea obiect (puteţi să cred că a ataşat obiect ca un fel de argumentul permanentă a trecut la metoda).

Aceasta este o funcţie apel de o funcţie denumită foo() :

Foo()

Aceasta este o metoda de apel de metoda a numit de asemenea foo() , care este ataşat la un obiect stocate în o variabilă numită Balon ratusca :

Balon ratusca.foo()

Un apel de la o funcţie în interiorul unui modul poate arăta ca o metoda de apel. Pentru a face diferenţa, aveţi nevoie de a se uita la primul nume şi vezi dacă este numele unui modul sau de numele variabilei care conţine un obiect. Puteţi spune ca sys.exit() este un apel la funcţia în interiorul unui modul, deoarece în partea de sus a programului va fi import declaraţie ca importul sys .

Un constructor funcţie este acelasi lucru ca o funcţie normală apel, cu excepţia că valoarea sa de retur este un nou obiect. Doar privind codul sursă, o funcţie şi funcţia de constructor arata la fel.

Funcţiile de constructor (numite de asemenea pur şi simplu o -constructor‖ sau uneori -ctor‖ (-consultaţi-torului‖) pentru scurt) sunt doar un nume pentru funcţii care reveni un nou obiect. Dar de obicei ctors începe cu o majusculă. De aceea când scrieţi propriile programe, funcţia dvs. numai numele ar trebui să înceapă cu o literă mică scrisoare.

De exemplu, pygame.Rect() şi pygame.Suprafata() sunt ambele funcţii de constructor în interiorul modulului pygame ca noul retur rect şi obiecte de suprafaţă. (aceste obiecte sunt descrise mai târziu.)

Aici este un exemplu de funcţie apel, o metoda de apel, şi un apel la o funcţie în interiorul unui modul:

Whammy

import carbogazoase()



Ou = Wombat()

Ou.bluhbluh() whammy.spam()

Chiar daca aceste nume sunt toate, puteţi spune care este o funcţie apel, o metoda de apel, şi un apel la o funcţie în interiorul o metoda. Numele whammy se referă la un modul, deoarece puteţi vedea sunt importate pe prima linie. De efervescentă numele nu înainte şi paranteze după, deci stii este o funcţie apel.

Wombat() este de asemenea o funcţie apel, în acest caz este un constructor funcţia care revine unui obiect.

(litera care începe cu nu este o garantie ca e o funcţie de constructor mai degrabă decât o funcţie regulate, dar este un pariu în siguranţă.) obiectul este memorat în o variabilă numit Oul . Oul.bluhbluh() apel este o metoda de apel, pe care le poti spune deoarece bluhbluh este ataşat la o variabilă cu un obiect în ea.

Între timp, whammy.spam() este o funcţie apel, nu este o metodă apel. Puteţi spune nu este o metoda pentru că numele whammy a fost importat ca modul mai devreme.

Obiectele de suprafaţă şi geamObiectele de suprafaţă sunt obiecte care reprezintă o rectangulare de imagine 2D. Pixelii de suprafaţa obiectului poate fi schimbat prin apelarea funcţiilor de desen Pygame (descrise mai târziu în acest capitol) şi apoi afişat pe ecran. Fereastra de la frontiera, bara de titlu şi butoane nu sunt parte din suprafaţa afişajului obiect.

În special, suprafaţa obiectului returnat de pygame.afişaj.set_mode() este numit suprafaţa afişajului . Ceva care este trasată pe suprafaţa afişajului obiect va fi afişată pe fereastră când pygame.afişaj.actualizare() este numit. Este mult mai rapid pentru a desena pe un obiect de suprafaţă (care există numai în memoria calculatorului) decât este de a elabora un obiect de suprafaţă la ecranul calculatorului. Memorie de calculator este mult mai rapid pentru a schimba mult de pixeli de pe un monitor.

Adesea programul dvs va atrage mai multe lucruri diferite de o suprafaţă obiect. După ce aţi terminat de desen totul pe suprafaţa afişajului obiect pentru acest joc de iteraţie buclă (numit un cadru , ca o imagine de pe un DVD de pauză este numit) pe o suprafaţă de obiect, poate fi trasată pe ecran. Calculatorul poate desena cadre foarte repede, şi programele noastre de multe ori va rula în jur de 30 de cadre pe secundă (30 FPS). Aceasta se numeşte -rata cadrelor‖ şi este explicat mai târziu în acest capitol.

Suprafaţa de desen pe obiecte vor fi acoperite în funcţiile de desen‖ -primitiv şi imagini - Schema‖ sectiunile mai târziu în acest capitol.


CuloriExistă trei culori primare de lumina: roşu, verde şi albastru. (roşu, albastru şi galben sunt culorile primare pentru vopsele şi pigmenţi, dar calculatorul monitorul utilizează lumina si nu vopsea.) Prin combinarea diferite sume de aceste trei culori puteţi forma orice altă culoare. In Pygame, ne reprezintă culorile cu tuples a trei numere întregi. Prima valoare în tuple este cât de mult roşu este de culoare. Un număr întreg de valoarea 0 înseamnă că nu este roşu în această culoare şi valoarea 255 înseamnă suma maximă de roşu de culoare. A doua valoare este de culoare verde şi a treia valoare este albastru. Aceste tuples a trei numere întregi utilizate pentru a reprezenta o culoare sunt deseori numite valori RGB .

Deoarece puteţi folosi orice combinaţie de 0 la 255 pentru fiecare din cele trei culori primare, aceasta înseamnă Pygame poate desena 16,777,216 diferite culori (256 x 256 x 256 Culori). Totuşi, dacă încercaţi să utilizaţi un număr mai mare de 255 sau un număr negativ, veţi primi o eroare care arată ca- ValueError: Invalid argument ‖ de culoare.

De exemplu, va vom crea tuple (0, 0, 0) şi depozitaţi pe o variabilă numită negru . Cu nici o cantitate de roşu, verde sau albastru, culoarea rezultată este complet negru. Culoarea negru este lipsa de orice culoare. A tuple (255, 255, 255) pentru o suma maxima de roşu, verde şi albastru pentru a duce în alb. Culoarea alb este întreaga combinaţie de roşu, verde şi albastru. Tuple de 255, 0, 0) reprezintă cantitatea maximă de roşu dar nu cantitatea de verde şi albastru, astfel încât culoarea rezultată este roşu. În mod similar, (0, 255, 0) este verde şi (0, 0, 255) este albastru.

Puteţi amesteca cantitatea de roşu, verde şi albastru pentru a forma alte culori. Aici sunt valori RGB pentru câteva culori comune:

Culoare Valori RGBAqua ( 0, 255, 255)Negru ( 0, 0, 0)

Albastru ( 0, 0, 255)Fucsia (255, 0, 255)

Gri (128, 128, 128)În verde ( 0, 128, 0)

Lămâie verde ( 0, 255, 0)Castaniu (128, 0, 0)

Bleumarin ( 0, 0, 128)Măsline (128, 128, 0)Violet (128, 0, 128)Roşu (255, 0, 0)

Argintiu (192, 192, 192)Teal ( 0, 128, 128)Alb (255, 255, 255)

Galben (255, 255, 0)


Culorilor transparenteAtunci când vă uitaţi prin fereastra de sticla care are o nuanţă de roşu, toate culorile în spatele ei au o nuanţă de roşu de adăugat la ele. Puteţi simula acest efect prin adăugarea unui al patrulea 0 la 255 numărul întreg la valori de culoare.

Această valoare este cunoscut ca alfa . Este o măsură de cum mată (deci nu o culoare este transparentă). În mod normal atunci când vă trasaţi un pixel de pe o suprafaţă de obiect, noua culoare complet înlocuieşte orice culoare era deja acolo. Dar cu culori care au o valoare de alfa, puteţi în loc doar adăugaţi o nuanţă de culoare care este deja acolo.

De exemplu, acest tuple de trei numere întregi este de culoare verde: (0, 255, 0) . Dar dacă se adaugă o a patra număr întreg pentru alfa, putem face aceasta jumatate de culoare verde transparent: (0, 255, 0, 128) . O alfa valoarea 255 este complet opac (respectiv, transparenta la toate). Culorile (0, 255, 0) şi (0, 255, 0, 255) căutaţi exact aceleaşi. O valoare de 0 înseamnă alfa culoarea este complet transparentă. Dacă o trasaţi orice culoare care are o valoare de 0 alfa de o suprafaţă de obiect, nu va avea nici un efect, deoarece această culoare este complet transparentă şi invizibil.

Pentru a desena cu ajutorul culorilor transparente, trebuie să creaţi un obiect de suprafaţă cu converti_alpha() . De exemplu, următorul cod creează un obiect de suprafaţă culorilor transparente poate fi trasată pe:

AnotherSurface = DISPLAYSURF.converti_alpha()

Odată ce lucrurile au fost redactate intocmite pe suprafaţa obiectului stocate în anotherSurface , apoi anotherSurface poate fi -blitted‖ (de copiat) la DISPLAYSURF asa va apărea pe ecran. (Consultaţi - Schema de imagini cu pygame.image. Sarcina() şi blit() ‖ secţiunea mai târziu în acest capitol).

Este important să reţineţi că nu puteţi folosi culorilor transparente de pe obiecte de suprafaţă nu este returnat de la o converti_alpha() apel, inclusiv suprafaţa afişajului care a fost intors de la pygame.afişaj.set_mode() .

Dacă am crea o culoare tuple de a atrage legendarul Unicorn roz invizibil, vom folosi (255, 192, 192, 0) , care se termina părând complet invizibil la fel ca orice alta culoare care are un 0 pentru alfa. Este, după toate, invizibil.


(de mai sus este un instantaneu de un desen de unicorn roz invizibil.)

Pygame. obiecte de culoareTrebuie să ştiţi cum să reprezinte o culoare pentru ca funcţiile de desen lui Pygame nevoie de un mod de a sti ce culoare vrei sa atraga cu. Un tuple de trei sau patru numere întregi este un mod. Un alt mod este ca o pygame.Color obiect. Puteţi crea culori obiecte prin apelarea pygame.Color() funcţia de constructor şi trecând fie trei sau patru numere întregi. Puteţi memora acest obiect de culoare în variabile ca puteţi stoca tuples în variabile. Încercaţi să introduceţi următoarele în cochilia interactive:

>>> import pygame >>> pygame.Color(255, 0, 0).

(255, 0, 0, 255)

>>> myColor = pygame.Color(255, 0, 0, 128)

>>> myColor == (255, 0, 0, 128) Adevărat

>>>

Orice desen în funcţie Pygame (care vom învăţa despre un pic) că un parametru pentru culoare poate avea fie forma sau color de tuple obiect sub forma de o culoare a trecut pentru ea. Chiar dacă acestea sunt diferite tipuri de date, un obiect de culoare este egal cu un tuple de patru numere întregi dacă ambele reprezintă aceeaşi culoare (ca si cum 42 == 42.0 va evalua cu adevarat ).

Acum că ştiţi cum să reprezinte culori (ca un obiect de culoare.pygame sau un tuple de trei sau patru numere întregi pentru roşu, verde, albastru, şi opţional alfa) şi coordonate (ca un tuple de două numere întregi pentru X şi Y), să învăţăm despre pygame.Rect obiecte astfel încât să putem începe folosind desenul lui Pygame funcţii.

Rect obiectePygame are două moduri de a reprezenta zone dreptunghiulare (ca există două moduri de a reprezenta culori). Primul este un tuple de patru numere întregi:

1. coordonata X din colţul din stânga sus.


2. Coordonata Y din colţul din stânga sus.3. Lăţimea (în pixeli) a dreptunghiului.4. Apoi înălţime (în pixeli) a dreptunghiului.

Al doilea mod este ca o pygame.Rect obiect, pe care o numim Rect obiecte pentru scurt. De exemplu, codul de mai jos creează un Rect obiect cu o colţul stânga sus la (10, 20) că este de 200 pixeli latime si de 300 pixeli înalt:

>>> import pygame

>>> spamRect = pygame.Rect(10, 20, 200, 300) >>> spamRect == (10, 20, 200, 300)

Adevărat

Comodele lucru despre acest lucru este că Rect obiect calculează automat coordonatele pentru alte caracteristici ale dreptunghiului. De exemplu, dacă aveţi nevoie să ştiţi coordonata X a marginii din dreapta a pygame.Rect obiect am memorat în variabila spamRect, puteţi avea acces la rect obiect atributul de drept al lui:

>>>

spamRect.dreapta 210

Codul pentru Pygame de Rect obiect calculat automat că dacă marginea din stânga este la coordonata X 10 şi dreptunghiului este de 200 pixeli latime, apoi marginea dreapta trebuie să fie la coordonata X 210. Dacă vă realocaţi atributul de dreapta, toate celelalte atribute sunt automat recalculată:

>>> spam.dreapta = 350 >>>

spam.stânga 150

Iată o listă cu toate atributele care pygame.Rect obiecte furniza (în exemplul nostru, variabila unde Rect este stocată în obiect o variabilă numită myRect ):


Nume atribut Descriere

MyRect.stânga Valoarea int coordonata X din partea stângă a dreptunghiului.

MyRect.dreapta Valoarea int coordonata X din partea dreapta a dreptunghiului.

MyRect.sus Valoarea int coordonata Y din partea de sus a dreptunghiului.

MyRect.jos Valoarea int coordonata Y din partea inferioară.

MyRect.centrex Valoarea int coordonata X a centrului dreptunghi.

MyRect.centery Valoarea int coordonata Y a centrul dreptunghiului.

MyRect.width Valoarea int de lăţimea dreptunghiului.

MyRect.înălţime Valoarea int de înălţimea dreptunghiului.

MyRect.dimensiunea O a doua ints tuple: (lăţime, înălţime)

MyRect.topleft O a doua ints tuple: (stânga, sus)

MyRect.topright O a doua ints tuple: (dreapta sus)

MyRect.bottomleft O a doua ints tuple: (stânga jos)

MyRect.bottomright O a doua ints tuple: (dreapta jos)

MyRect.midleft O a doua ints tuple: (stânga, centery)

MyRect.midright O a doua ints tuple: (dreapta, centery)

MyRect.midtop O a doua ints tuple: (Centrex, sus)

MyRect.midbottom O a doua ints tuple: (Centrex, jos)

Desenul de primitiv de funcţiiPygame oferă mai multe funcţii diferite pentru elaborarea de diferite forme pe o suprafaţă de obiect. Aceste forme precum dreptunghiuri, cercuri, elipse, linii sau pixeli individuali sunt deseori numite primitive de desen . Deschideţi editorul de dosarul lui de ralanti şi tipul în următorul program şi o salva ca desen.py .




3.4. Pygame.init()5.6. # setaţi fereastra7. DISPLAYSURF = pygame.afişaj.set_mode((500, 400), 0, 32)8. Pygame.afişaj.set_Titlul('Drawing")9.

10. # setat de culori11. Negru = ( 0, 0, 0)12. = alb (255, 255, 255)13. Roşu = (255, 0, 0)14. Verde = ( 0, 255, 0)

15.Albastru = ( 0, 0, 255)

16.17. # desena pe suprafaţa obiectului18. DISPLAYSURF.umpleţi(alb)

19. Pygame.intocmeste.liniei poligonale(DISPLAYSURF, Verde, ((146, 0), (291, 106), (236, 277), (56, 277), (0, 106)))20. Pygame.intocmeste.linie(DISPLAYSURF, albastru (60, 60), (120, 60), 4)21. Pygame.intocmeste.linie(DISPLAYSURF, albastru (120, 60), (60, 120))22. Pygame.intocmeste.linie(DISPLAYSURF, albastru, 60, 120), (120, 120), 4)23. Pygame.intocmeste.cerc(DISPLAYSURF, albastru (300, 50), 20, 0)24. Pygame.intocmeste.elipsă(DISPLAYSURF, roşu, (300, 250, 40, 80), 1)25. Pygame.intocmeste.rect(DISPLAYSURF, roşu, (200, 150, 100, 50))26.27. PixObj = pygame.PixelArray(DISPLAYSURF)28. PixObj[480][380] = NEGRU29. PixObj[482][382] = NEGRU30. PixObj[484][384] = NEGRU31. PixObj[486][386] = NEGRU32. PixObj[488][388] = NEGRU33. Del pixObj34.35. # run joc de buclă36. În timp ce adevarat:37. Pentru caz în caz.obtine pygame.():38. Dacă caz.tip == QUIT:39. Pygame.quit()40. Sys.exit()41. Pygame.afişaj.actualizare()

Când acest program, este afişată următoarea fereastră până când utilizatorul închide fereastra:


Observaţi cum facem variabilele constantă pentru fiecare de culori. Aceasta face ca codul nostru mai lizibile, deoarece imaginea verde în codul sursă este mult mai usor de inteles ca reprezentând de culoarea verde decât (0, 255, 0) .

Desenul de funcţii sunt numite după formele ei atrag. Parametrii treci aceste funcţii le spun care obiect pe suprafaţă, unde sa forma (şi ce dimensiune), in ce culoare, şi cât de larg pentru a face linii. Puteţi vedea cum aceste funcţii sunt denumite în desenul.py programului, dar aici este o scurtă descriere a fiecărei funcţii:

l Umpleţi (color) - umpleţi() nu este o funcţie dar o metoda de pygame. obiecte de suprafaţă Acesta va umple complet în întreaga suprafaţă obiect cu valoare de orice culoare să treci ca pentru culoarea parametrului.

l Pygame.intocmeste.liniei poligonale(suprafata, culoare, pointlist, lăţime) - un poligon este forma doar laturi plate. Suprafaţa şi parametrii de culoare spune funcţia pe ce suprafata a trasa linia poligonală şi ce culoare pentru a face.

Este un parametru pointlist de tuple sau listă de puncte (tuple sau listă de două-număr întreg tuples pentru coordonatelor XY). Linia poligonală este aspirat prin trasarea de linii între fiecare punct şi punctul care vine după el în tuple. Apoi este trasată o linie de la ultimul punct la primul punct. Puteţi de asemenea să treacă o listă de puncte în loc de un tuple de puncte.

Lăţimea parametru este opţional. Dacă lăsaţi-o, a liniei poligonale ca este tras va fi completat, exact ca poligon noastre verzi de pe ecran este completat cu culoare. Dacă nu trece un număr întreg de valoare pentru parametrul lăţime, numai conturul liniei poligonale va fi elaborat. Număr întreg de reprezintă câţi pixeli lăţimea liniei poligonale conturul lui va fi. Trecând 1 pentru lăţimea parametru va face un poligon de slab, când trece 4 sau 10 sau 20 va face mai groasă poligoane. Dacă treceţi de număr întreg de 0 pentru parametrul lăţime, liniei poligonale vor fi completate (ca dacă stânga lăţimea parametru cu totul).

Toate pygame.draw desen funcţii au parametri lăţime opţional la sfârşitul, şi acestea funcţionează în acelaşi mod ca pygame.intocmeste. lăţimea liniei poligonale() 's parametru. Probabil un nume mai bun pentru lăţimea parametru ar fi fost grosimea , deoarece ca parametru controlează modul de gros liniile ai sorţi sunt.



l Pygame.intocmeste.linie(suprafata, culoare, Start_point, final_point, lăţime) - Această funcţie trasează o linie între punctul de start_ şi final_point parametri.

l Pygame.Trasaţi liniile(suprafata.culoare, închis, pointlist, lăţime) - Această funcţie atrage o serie de linii de la un punct la altul, mult pygame.intocmeste.liniei poligonale() . Singura diferenţă este că dacă treceţi de fals pentru parametrul închisă, nu va exista o linie de la ultimul punct în pointlist parametru la primul punct. Dacă treceţi de adevarat , apoi se va trage o linie de la ultimul punct la prima.

l Pygame.intocmeste.cerc(suprafata, culoare, center_point, raza, lăţime) - Această funcţie trage un cerc. Centrul cercului este în centrul_point parametru. Număr întreg de trecut pentru raza de seturi de parametri de dimensiunea cercului.

Raza unui cerc este distanţa de la centrul de muchie. (raza de cerc este întotdeauna jumătate din diametrul.) trecând 20 pentru raza parametru va elabora un cerc care are o rază de 20 de pixeli.

l Pygame.desenaţi elipsa(suprafata.culoare, Dreptunghi de delimitare perimetru_, lăţime) - Această funcţie trage o elipsă (care este ca o strivit sau întinse cerc). Această funcţie a tuturor parametrilor de obicei, dar pentru a spune cât de mare şi unde funcţia pentru a desena elipsa, trebuie să specificaţi Dreptunghi de delimitare perimetru elipsei. Un Dreptunghi de delimitare

perimetru este mai mic dreptunghi care poate fi elaborat în jurul unei forme. Iată un exemplu de o elipsă şi Dreptunghi de delimitare perimetru:

Dreptunghi de delimitare_ parametru poate fi o pygame.Rect obiect sau un tuple de patru numere întregi. Reţineţi că nu specificaţi punctul central pentru elipsă cum faci tu pentru pygame.intocmeste.cerc() .

l Pygame.intocmeste.rect(suprafata dreptunghiului, color,_tuple, lăţime) - Această funcţie atrage un dreptunghi. Dreptunghiul_tuple este fie un tuple de patru numere întregi (pentru Coordonatele XY din colţul stânga sus şi lăţimea şi înălţimea) sau un pygame.Rect obiect poate fi trecut în schimb. Dacă dreptunghiului_tuple are aceeaşi dimensiune pentru lăţimea şi înălţimea, un pătrat va fi elaborat.

Pygame.PixelArray obiecteDin nefericire, nu există o singură funcţie puteţi apel care va seta un singur pixel la o culoare

(decât dacă apelul pygame.intocmeste.line() cu acelaşi punct de start şi de final). În cadrul Pygame are nevoie pentru a rula unele organ în culise înainte şi după trasarea de o suprafaţă obiect. Dacă ar fi să faceţi acest lucru pentru fiecare pixel ai vrut să setaţi, programul dumneavoastră ar fi funcţionat mult mai lent. (Prin testarea rapidă a mea, desen de pixeli în acest fel este de două sau de trei ori mai mari.)

În schimb, trebuie să creaţi un pygame.PixelArray obiect (le vom numi PixelArray obiecte

pe scurt) a unui obiect de suprafaţă şi apoi setaţi pixeli individuali. Crearea unui obiect PixelArray suprafeţei obiect va -Blocaţi‖ suprafaţa obiectului. În timp ce o suprafaţă de obiect este blocat, desen


Funcţiile pot fi încă numit pe ea, dar nu poate fi imagini cum PNG sau JPG Imaginile desenate pe ea cu blit() . ( blit() este explicat mai târziu în acest capitol).

Dacă doriţi să vedeţi dacă un obiect de suprafaţă este blocat, get_blocat() metoda de suprafaţă va reveni Adevărat dacă este blocat şi falsă dacă nu este.

La obiectul care este PixelArray returnate de pygame.PixelArray() poate avea pixeli individuali stabilite prin accesarea lor cu două indexuri. De exemplu, linia 28's pixObj[480][380] = NEGRU va seta pixel la coordonata X 480 şi coordonata Y 380 să fie negre (reţineţi că variabila memorează culoarea negru tuple (0, 0, 0 )).

Pentru a spune Pygame că aţi terminat desenul de pixeli individuali, şterge PixelArray obiect cu o declaraţie de del. Asta este ceea ce linia 33 nu. Ştergerea PixelArray obiect va -deblocaţi‖ suprafaţa obiectului astfel încât să poate din nou Draw imaginile de pe ea. Dacă uitaţi să ştergeţi obiectul PixelArray, următoarea dată când încercaţi să blit (sa atraga) o imagine la suprafaţă programul va ridica o eroare, - pygame.eroare: Suprafeţele trebuie să nu fie blocat în timpul ‖ blit.

Afişaj de pygame..actualizare()

După ce aţi terminat de apelarea funcţiilor de desen pentru a face suprafaţa afişajului obiect uite cum doriţi, trebuie să apelaţi pygame.afişaj.actualizare() pentru a face suprafaţa afişajului apar efectiv pe monitorul utilizatorului.

Un lucru de care trebuie să ţineţi minte este că pygame.afişaj.actualizare() va face doar suprafaţa afişajului (suprafaţa unui obiect care a fost returnat de la apel la pygame.afişaj.set_mode() ) apar pe ecran. Dacă doriţi ca imaginile de pe alte obiecte de suprafaţă pentru a apărea pe ecran, trebuie să le‖ -blit (copie) pentru a le suprafaţa afişajului obiect cu blit() (care este explicat în viitor - Schema de imagini‖").

AnimaţieAcum că ştim cum să obţineţi Pygame cadrul pentru a desena pe ecran, să învăţăm cum să faceţi fotografii animate. Un joc cu numai încă, nemişcat imaginile ar fi destul de plictisitor. (vânzări de joc -Uite Rock‖ au fost dezamăgitoare.) de imagini animate sunt rezultatul desen o imagine pe ecran, apoi o fracţiune de secundă mai târziu desen diferit imaginii de pe ecran. Imaginaţi programului din fereastra era 6 pixeli latime si de 1 pixel inalt, cu toţi pixelii cu exceptia unui alb negru pixel la 4, 0. Ar arata asa:



Dacă aţi schimbat fereastra astfel încât 3, 0 a fost negru şi 4,0 era alb, ar arata asa:

Pentru utilizator, seamana cu negru pixel are -mutat‖ peste la stânga. Dacă redrew fereastra pentru a fi negru cu pixel la 2, 0, ar continua să arate ca şi negru pixel este în mişcare stânga:

Acesta poate părea negru cu pixel este în mişcare, dar aceasta este doar o iluzie. La calculator, este doar care prezintă trei imagini diferite ca fiecare doar ca se intampla sa am un pixel de negru. Ia în considerare dacă următoarele trei imagini au fost rapid indicate pe ecran:

Pentru utilizator, ar arăta ca pisica se deplasează spre veverita. Dar la calculator, sunt doar o adunatura de pixeli. Trucul pentru a face credibil părând animaţia este de a avea programul dvs desenaţi o imagine în fereastra, aşteptaţi o fracţiune de secundă şi apoi desenaţi o imagine uşor diferite.

Aici este un exemplu de program care demonstrează un simplu animaţie. Tip acest cod în editorul de dosarul lui de ralanti şi o salva ca catanimation.py . De asemenea, va fi nevoie de fişier de imagine cat.png pentru a fi în acelaşi folder ca şi catanimation.py fişier. Puteţi descărca această imagine din Http://invp y .com/cat.pn g . Acest cod este disponibilă la

Http://invpy.com/catanimatio n. py.



3.4. Pygame.init()

5.6. FPS = 30 # setarea de cadre pe secundă 7. FpsClock = pygame.timp.Ceas()

8.9. # setaţi fereastra

10. DISPLAYSURF = pygame.afişaj.set_mode((400, 300), 0, 32)11. Pygame.afişaj.set_Titlul('Animaţie")12.13. Alb = (255, 255, 255)14. CatImg = pygame.image. Sarcina('cat.png")15. Catx = 1016. Caty = 1017. Direcţie = "DREAPTA"18.

19. În timp ce adevarat: # buclă de joc principal 20. DISPLAYSURF.umpleţi(alb)21.22. Dacă direcţia == "dreapta":23. Catx + = 524. Dacă catx == 280:25. Direcţie = ""26. Direcţia elif == "":27. Caty + = 528. Dacă caty == 220:29. Direcţie = "STÂNGA"30. Direcţia elif == "stânga":31. Catx -= 532. Dacă catx == 10:33. Direcţie = "sus"34. Direcţia elif == "':35. Caty -= 536. Dacă caty == 10:37. Direcţie = "DREAPTA"

38.39. DISPLAYSURF.blit(catImg, (catx, caty))

40.41. Pentru caz în caz.obtine pygame.():42. Dacă caz.tip == QUIT:43. Pygame.quit()44. Sys.exit()45.46. Pygame.afişaj.actualizare()



47. fpsClock.tick(FPS)

Uite ca pisica animate Go! Acest program va fi mult mai mult de un succes comercial decât jocul meu, -Uite Rock 2: un bolovan‖ diferite.

Cadre pe secundă şi pygame.timp. obiecte de ceasRata de cadre sau rata de reîmprospătare este numărul de imagini pe care programul trage pe secundă şi este măsurată în FPS sau cadre pe secundă . (pe monitoare de calculator numele comun pentru FPS este hertz. Multe dintre monitoarele au o frecvenţă a cadrelor de 60 hertz, sau 60 de cadre pe secundă.) o rată scăzută în jocuri video poate face jocul uite sacadate sau de iritat. Dacă programul este prea mult cod pentru a rula la extragerea pentru ecran destul de frecvent, apoi de FPS. Dar de jocuri în această carte sunt suficient de simplu ca aceasta nu va emite chiar pe calculatoarele mai vechi.

O pygame.timp. obiect de ceas ne pot ajuta să asiguraţi-vă că programul nostru funcţionează la o anumită maxim de FPS. Acest obiect de ceas va asigura că jocul nostru de programe nu prea rapidă prin punerea în mici pauze de pe fiecare iteraţie a buclei de joc. Dacă nu am aceste pauze, jocul nostru program va rula mai rapid ca calculatorul ar putea rula. Acest lucru este adesea prea rapidă pentru jucător şi la calculatoarele obţineţi mai repede ca vor rula mai rapid joc prea. Un apel la tick() metoda de un obiect de ceas în joc loop puteţi asigura că jocul ruleaza la aceeasi viteza indiferent de cât de rapidă a unui calculator se ruleaza pe. Ceasul de obiect este creat de pe linia 7 a catanimation.py program.

7. FpsClock = pygame.timp.Ceas()

Ceasul lui obiect tick() trebuie să fie numit chiar la sfârşitul jocului, buclă după apelul la afişajul.actualizare pygame.() . Lungimea de pauză este calculată pe baza a cat de mult a fost de la precedenta apel la tick() , care ar avea loc la sfârşitul anului de iteraţie a buclei de joc. (prima data tick() este numit nu întrerupe la toate.) În programul de animaţie, este să funcţioneze pe linia 47 ca ultima instrucţiune de joc în buclă.

Tot ce trebuie să ştiţi este că trebuie să bifaţi apel() data per iteratie prin bucla de joc la capătul buclei. De obicei acest lucru este dreapta după apelul la pygame.afişaj.actualizare() .

47. fpsClock.tick(FPS)

Încercaţi modificarea fps constant variabilă pentru a executa acelasi program la diferite ale cadrelor. O setare pentru a o valoare inferioară ar face programul ruleaza mai lent. Setarea la o valoare mai mare ar face ca programul să funcţioneze mai rapid.


Desen de imagini cu pygame.image. Sarcina() şi blit()Desenul de funcţii sunt frumoase dacă doriţi să desenaţi forme simple de pe ecran, dar multe jocuri au imagini (numite de asemenea sprites ). Pygame este posibilitatea de a încărca imagini pe obiecte de suprafaţă din PNG, JPG, GIF, BMP BMP şi fişierele de imagine. Diferentele dintre aceste formate de fişiere de imagine este descrisă la Http://invpy.com/format s .

Imaginea de pisica a fost memorat în un fişier numit cat.png . Pentru a incarca acest fisier imaginea lui, string

"Pisica.png" este trecut de la imaginea.sarcina pygame.() . Pe imaginea.sarcina pygame.() apelul va reveni o suprafaţă de obiect care are imaginea desenate pe ea. Această suprafaţă obiect va fi o suprafaţă separate obiect de la suprafaţa afişajului de obiect, astfel încât trebuie să ne blit (copie) imaginea de pe suprafaţa obiectului de suprafaţa afişajului obiect. Blitting desenul este conţinutul o suprafaţă pe de alta. Este adoptată cu blit() Suprafaţa obiectului metoda.

Dacă primiţi un mesaj de eroare ca - pygame.eroare: nu putea deschide cat.png ‖ la apelarea pygame.image. Sarcina() , apoi asiguraţi-vă că pisica. fişier png este în acelaşi folder ca şi catanimation.py înainte de a rula fişiere program.

39. DISPLAYSURF.blit(catImg, (catx, caty))

Linia 39 a programului de animaţie utilizează blit() pentru a copia catImg la DISPLAYSURF . Există doi parametri pentru blit() . Prima este sursa obiect de suprafaţă, care este ceea ce vor fi copiate pe suprafaţa DISPLAYSURF obiect. Al doilea parametru este un număr întreg cu două tuple pentru valorile X şi Y a topleft colţul unde imaginea trebuie să fie blitted a.

Dacă catx şi caty au fost setate la 100 şi 200 şi lăţimea catImg era 125 şi înălţime a fost 79 , acest blit() apel ar copiere acest imaginea pe DISPLAYSURF astfel încât colţul din stânga sus al catImg era la coordonate XY (100, 200) şi colţul dreapta jos a fost coordonate XY la (225, 279).

Reţineţi că nu puteţi blit la o suprafaţă care este în prezent -blocat‖ (cum ar fi atunci când un obiect PixelArray a fost făcută de el şi încă nu au fost şterse.)

Restul de buclă de joc este doar schimbarea caty catx , , şi direcţia variabile astfel încât cat se mişcă în jurul geamului. Există de asemenea un apel la pygame.caz.obţineţi() pentru a gestiona QUIT caz.

FonturiDacă doriţi să desenaţi de text la ecran, veţi putea scrie mai multe apeluri la pygame.intocmeste.line() să atragă pe liniile de fiecare literă. Aceasta ar fi o durere de la toate cele de tip


Pygame.trasaţi linia() apeluri.şi figura afară toate coordonatele XY, şi probabil că nu ar arata foarte bine.

Mesajul de mai sus ar dura de patruzeci de unul apelurile pygame.intocmeste.line() . În schimb, Pygame oferă unele funcţii mult mai simplă pentru fonturi şi crearea de text. Aici este un mic program cu ajutorul Pygame Hello lume e font funcţii. Tipul acesta de dosarul lui de ralanti în editor şi o salva ca fonttext.py :


3.4. Pygame.init()5. DISPLAYSURF = pygame.afişaj.set_mode((400, 300))6. Pygame.afişaj.set_Titlul('Hello lume!")

7.8. Alb = (255, 255, 255)9. Verde = (0, 255, 0)

10. Albastru = (0, 0, 128)

11.12. FontObj = pygame.font.Font('freesansbold.ttf", 32)13. TextSurfaceObj = fontObj.render('Hello lume!", adevărat, verde, albastru)14. TextRectObj = textSurfaceObj.get_rect()15. TextRectObj.centru = (200, 150)

16.17. În timp ce adevarat: # jocul principal de buclă 18. DISPLAYSURF.umpleţi(alb)19. DISPLAYSURF.blit(textSurfaceObj, textRectObj)20. Pentru caz în caz.obtine pygame.():21. Dacă caz.tip == QUIT:22. Pygame.quit()23. Sys.exit()24. Pygame.afişaj.actualizare()

Există şase paşi pentru a face textul apar pe ecran:

1. Creaţi un pygame.font.Font obiect . (ca pe linia 12)

2. Creaţi un obiect de suprafaţă cu textul trase de pe acesta prin apelarea obiectului de font- render() . (linia 13)

3. Creaţi un obiect Rect de pe suprafaţa obiectului prin apelarea suprafaţa obiectului ne _rect() . (14) Această linie Rect obiect va avea lăţimea şi înălţimea setată corect

pentru textul care a fost prestate, dar partea de sus şi din stânga va fi atribute 0 .


4. Setaţi poziţia Rect obiect prin schimbarea unul din atributele. Pe linia 15, setaţi centrul Rect obiect să fie la 200, 150.

5. Blit suprafaţa obiect cu textul de pe suprafaţa obiectului returnat de pygame.afişaj.set_mode() . (linia 19)

6. Apel pygame.afişaj.actualizare() pentru a face suprafaţa afişajului apare pe ecran. (linia 24)

Parametrii de pygame.font.Font() funcţia de constructor este un şir de font file pentru a utiliza şi un număr întreg de dimensiunea fontului (în puncte, ca masura de procesoare cum cuvântul font size). Pe linia 12, vom trece "freesansbold." (aceasta este ttf un font care vine cu Pygame) şi întreg 32 (pentru un punct de 32 de dimensiune font).

Consultaţi Http://invp y .com/usingotherfonts pentru mai multe informaţii despre utilizarea altor fonturi. Parametrii de render() apel sunt un şir de text pentru a face o valoare booleene pentru a specifica dacă vrem anti-aliasing (explicate mai târziu în acest capitol), culoarea textului şi culoarea de fundal. Dacă doriţi un fundal transparent, apoi lăsaţi pur şi simplu de pe culoare de fundal parametru în metoda apel.

Anti-AliasingAnti-aliasing este o tehnica de grafice pentru a face textul şi forme mai pătrăţoase adăugând un pic de blur la marginile lor. Este nevoie de un pic mai mult timp sa de calcul cu anti-aliasing, astfel încât deşi grafica poate arata mai bine, programul dumneavoastră poate rula mai lent (dar numai un pic).

Dacă faceţi zoom pe un alias linie şi o linie de anti-alias, ele arata asa:

Pentru a face textul lui Pygame utilizaţi anti-aliasing, trece adevărat pentru al doilea Parametru de randare() . La pygame.intocmeste.aaline() şi pygame.intocmeste.aalines() funcţii au aceeaşi parametri ca pygame.intocmeste.line() şi


Pygame.Trasaţi liniile.() , cu excepţia vor elabora anti-alias (netede) liniile în loc de alias (pătrăţoase) liniile.

Redarea de suneteRedarea de sunete care sunt stocate în fişiere de sunet este chiar mai simplă decât afişarea imaginilor din fişierele de imagine. Mai întâi, trebuie să creaţi un pygame.mixer. obiectul (Sunet care o numim obiecte de sunet pentru scurt) prin apelarea pygame.mixer.Sunet() funcţia de constructor. Este nevoie de un string parametru, care este numele fişierului de fişier audio. Pygame pot incarca WAV, mp3 sau fişierele OGG. Diferenţa între aceste formate de fişiere audio este explicat la Http://invpy.com/format s .

Pentru a reda acest sunet, apelaţi la obiect de sunet joc() . Dacă doriţi să opriţi imediat obiect de sunet de la redarea de apel de stop() . Opritorul() nu are argumente. Iată unele mostre de cod:

SoundObj = pygame.mixer.Sunet('bipuri.wav") SoundObj.play()

Timpul de import

Timp.1 sleep # aşteptaţi şi lăsaţi joc de sunet pentru 1 secundă soundObj.stop()

Puteţi descărca de bipuri.wav fişier din Http://invp y .com/bip-wa v .

Executarea programului continuă imediat după play() este numit; nu aşteptaţi de sunet pentru a finaliza joacă înainte de a trece la următoarea linie de cod.

Sunetul de obiecte sunt bune pentru efecte de sunet pentru a juca atunci când jucător are deteriorări, barele oblice o sabie sau colectează o monedă. Dar jocurile dvs. ar putea fi de asemenea mai bine daca muzică de fundal joacă indiferent de ce era in joc. Pygame poate doar una de sarcină a reda fişiere de muzică în fundal la un moment dat. Pentru a încărca un fişier de muzică de fundal, apelaţi pygame.mixer.muzica. Sarcina() şi se trece un string de argument de fişier audio pentru sarcină. Acest fişier poate fi WAV, mp3 sau formatul MIDI.

Pentru a începe redarea încărcat fişierul sunet ca muzică de fundal, apelaţi pygame.mixer.music.play(-1, 0.0) . La -1 face argumentul muzică de fundal pentru totdeauna de buclă atunci când ajunge la sfârşitul fişierului de sunet. Dacă îl setaţi la un număr întreg de 0 sau mai mare, apoi de muzică va numai buclă care numărul de ori în loc de încâlcire pentru totdeauna. 0.0 Mijloace de a reda fişierul sunet de la început. Dacă treceţi de la un mai mare număr întreg sau flotantă, muzica va începe redarea ca multe secunde în fişierul de sunet. De exemplu, dacă treceţi de 13,5 pentru al doilea parametru, fişierul sunet cu începe redarea de la punctul 13.5 secunde în de la început.


Pentru a opri redarea de muzică de fundal imediat, apelaţi pygame.mixer.muzica.stop() . Această funcţie nu are argumente.

Iată câteva exemple de cod de metode şi de sunet funcţii:

# încărcarea şi redarea unui efect de sunet:

SoundObj = pygame.mixer.Sound('beepingsound.wav") soundObj.play()

# încărcarea şi redarea de muzică de fundal:

Pygame.mixer.muzica. Sarcina(backgroundmusic.mp3') Pygame.mixer.music.play(-1, 0.0)

# ...unele mai mult din codul dumneavoastră aici...

Pygame.mixer.muzica.stop()

SumarAceasta acoperă elementele de bază de a face jocuri de grafice cu cadrul Pygame. Desigur, doar citind despre aceste funcţii probabil nu este de ajuns pentru a vă ajuta să învăţaţi cum să faceţi jocuri cu ajutorul acestor funcţii. Restul de capitole din această carte fiecare focus pe codul sursă pentru un mic, joc complet. Aceasta vă va oferi o idee de ce programe de joc complet -arată ca‖, astfel încât să puteţi primi apoi câteva idei pentru modul de organ propriile programe de joc.

Spre deosebire de -inventa propriile jocuri pe calculator cu Python‖ carte, această carte presupune ca stii baza de programare Python. Dacă aveţi probleme să uitaţi cum variabile, funcţiile, bucle, dacă - altceva declaratiile, si conditiile de munca, probabil că puteţi afla exact de ce a vazut ceea ce e în cod şi modul în care se comportă de program. Dar dacă încă blocat, puteţi citi -Inventa cu Python‖ cartea pentru oameni care sunt complet noi pentru programare) pentru gratuit online la Http://inventwithpytho n .co m .

Capitolul 3 - Memorie Puzz le 33

C HAPTER 3 - M EMORYP UZZLE

Cum de a juca Puzzle de memorieÎn memorie joc de puzzle, mai multe pictograme sunt acoperite de cutii albe. Există două de fiecare pictogramă. Playerul poate faceţi clic pe doua cutii pentru a vedea ce pictograma este în spatele lor. Dacă pictogramele corespund, acele cutii sperii. Jucătorul câştigă atunci când toate casetele de pe bordul sunt descoperite.Pentru a da o tentă de jucător, casetele sunt descoperite rapid o dată la începutul jocului.

Pentru bucle imbricateUn concept care veţi vedea în memorie Puzzle (şi cele mai de jocuri în această carte) este utilizarea de buclă pentru interiorul alt pentru buclă. Acestea sunt numite pentru bucle imbricate Procesul de nesting pentru bucle sunt la îndemână pentru a trece prin fiecare combinaţie posibilă de două liste. Tip următoarele în cochilia interactive:

>>> Pentru x în [0, 1, 2, 3, 4]: ... Pentru y în ["a", "b", "c"]:

... Imprimaţi(x, y)

...0 O0 B0 C1 O1 B1 C


2 b 2 c

3 o

3 b 3 c

4 o

4 b

4 c

>>>

Există de mai multe ori în memoria codul de puzzle de care avem nevoie să iterate prin fiecare posibilă

X şi coordonata Y. Vom folosi procesul de nesting pentru bucle pentru a ne asigura că putem obţine fiecare combinaţie. Reţineţi că bucla pentru interior ( buclă pentru interiorul alte pentru buclă) va trece prin toate multor serii înainte de a merge la următoarea iteraţie exterior pentru buclă. Dacă am inversa ordinea de pentru bucle, aceleaşi valori vor fi tipărite dar vor fi imprimate pe o ordine diferită. Introduceţi următorul cod în cochilie, interactive şi comparaţi ordinea acesta imprimă valori la ordinea în procesul de nesting anterioare pentru bucla de exemplu:

>>> Pentru y în ["a", "b", "c"]: ... Pentru x în [0, 1, 2, 3, 4]:

... Imprimaţi(x, y)

...0 O1 O2 O3 O4 O0 B1 B2 B3 B4 B0 C1 C2 C3 C4 C

>>>

Cod sursă de memorie PuzzleAcest cod sursă poate fi descărcat de la Http://invpy.com/memorypuzzle.py.

Treceţi înainte şi cu primul tip în întregul program în dosarul lui de ralanti editor, salvati- memorypuzzle.py , şi rulaţi-o. Dacă obţineţi orice mesaje de eroare, uite la numărul de linie care

este menţionată în eroare


Capitolul 3 - Memorie Puzzle 35

Mesajul şi vă verificaţi codul pentru orice erorile tipografice. Puteţi de asemenea să copiaţi şi lipiţi cod în web de la http://invpy . com/dif/memorypuzzle pentru a vedea dacă diferenţele între codul dumneavoastră şi codul în carte. Probabil că ai să ridice câteva idei despre cum funcţionează programul doar prin tastarea în data. Şi atunci când aţi terminat introducerea textului în, apoi puteţi juca jocul pentru tine.

1. # Puzzle de memorie2. # De Al Sweigart [email protected]. # Http://inventwithpython.com/pygame4. # Eliberată sub un "licenta" BSD simplificată

5.6. Import, pygame aleatorie, sys7. De la pygame.localnicii import *

8.9. FPS = 30 # cadre pe secundă, viteza generală a programului

10. WINDOWWIDTH = 640 # dimensiunea ferestrei lăţime în pixeli 11. WINDOWHEIGHT = 480 # dimensiunea windows" înălţime în pixeli 12. REVEALSPEED = 8 # cutii de viteză' şi capacele relevă culisant 13. BOXSIZE = 40 # dimensiunea înălţime cutie & lăţime în pixeli 14. GAPSIZE = 10 # dimensiunea spaţiului dintre casete în pixeli 15. BOARDWIDTH = 10 # numărul de coloane de pictograme 16. BOARDHEIGHT = 7 # numărul de rânduri de pictograme 17. Susţin (BOARDWIDTH * BOARDHEIGHT) % 2 == 0, "trebuie să aibă un număr de cutii

pentru perechi de chibrituri."18. XMARGIN = int((WINDOWWIDTH - (BOARDWIDTH * (BOXSIZE + GAPSIZE))) / 2)19. YMARGIN = int((WINDOWHEIGHT - (BOARDHEIGHT * (BOXSIZE + GAPSIZE))) / 2)

20.21. # R G B

22. Gri = (100, 100, 100)

23.NAVYBLUE = ( 60, 60, 100)

24. Alb = (255, 255, 255)25. Roşu = (255, 0, 0)26. În Verde = ( 0, 255, 0)27. Albastru = ( 0, 0, 255)28. Galben = (255, 255, 0)29. Portocaliu = (255, 128, 0)30. Violet = (255, 0, 255)31. Turcoaz = ( 0, 255, 255)32.

33. BGCOLOR = NAVYBLUE34. LIGHTBGCOLOR = GRI35. BOXCOLOR = alb

36. HIGHLIGHTCOLOR = ALBASTRU

37.38. Gogoaşă = 'donut"


39. SQUARE = ""plasanăvod"40. DIAMOND = 'diamond"41. Linii = "linii"42. Ovalul = "ovale"

43.44. ALLCOLORS = (roşu, verde, albastru, galben, portocaliu, violet, turcoaz)45. ALLSHAPES = (GOGOAŞĂ, pătrat, Diamond, linii, oval)46. Susţin len(ALLCOLORS) * len(ALLSHAPES) * 2 >= BOARDWIDTH * BOARDHEIGHT,

- Placa este prea mare pentru numărul de forme/culorile definite." 47.48. Def principalele():49. FPSCLOCK, DISPLAYSURF globale50. Pygame.init()51. FPSCLOCK = pygame.timp.Ceas()52. DISPLAYSURF = pygame.afişaj.set_mode((WINDOWWIDTH, WINDOWHEIGHT))

53.54. Mousex = 0 # utilizate pentru a stoca coordonata x a mouse caz 55. Mousey = 0 # utilizate pentru a stoca coordonata Y a mouse caz 56. Pygame.afişaj.set_Titlul(Litiu-Ion fără "Joc")57.58. MainBoard = getRandomizedBoard()59. RevealedBoxes = generateRevealedBoxesData(Fals)

60.61. FirstSelection = None # stochează (x, y) din prima casetă de executat clic. 62.

63. DISPLAYSURF.umpleţi(BGCOLOR)64. StartGameAnimation(mainBoard)

65.66. În timp ce adevarat: # jocul principal de buclă 67. MouseClicked = fals68.

69. DISPLAYSURF.umpleţi(BGCOLOR) # desenul ferestrei 70. Placă de bază, revealedBoxes drawBoard()71.

72. Pentru caz în caz.obtine pygame.(): # caz buclă de manipulare 73. Dacă caz.tip == QUIT sau (caz.tip == KEYUP şi caz.==

K_iasă):74. Pygame.quit()75. Sys.exit()

76. Elif caz.tip == MOUSEMOTION:77. mousex, mousey = caz.pos78. Elif caz.tip == MOUSEBUTTONUP:79. mousex, mousey = caz.pos80. mouseClicked = adevărat81.82. Boxx, designerilor = getBoxAtPixel(mousex, mousey)



83. Dacă boxx != nici unul şi designerilor != fără:84. # mouse este în prezent peste o cutie.85. Dacă nu revealedBoxes[boxx][designerilor]:86. drawHighlightBox(boxx, patrat)87. Dacă nu revealedBoxes[boxx][designerilor] şi mouseClicked:

88. RevealBoxesAnimation(mainBoard, [(boxx, patrat)])89. RevealedBoxes[boxx][designerilor] = True # cutia pe ca

- dezvaluit"90. Dacă firstSelection == fără: # caseta de curent a fost primul

Rubrica a făcut clic91. FirstSelection = (boxx, patrat)92. Altceva: # caseta de curent a fost al doilea clic caseta93. # Verificaţi dacă există o potrivire între cele două pictograme.

94.Pictogramă1forma, culoarea = getShapeAndColor pictograma1(mainBoard,

FirstSelection[0], firstSelection[1])


Boxx, patrat)96.

97.Dacă pictograma de1forma != forma sau pictograma pictograma21! color=

Pictogramă2culoare:

98.# Pictograme nu corespund. Re-capac până ambele selecţii.

99. Pygame.timp.aşteptaţi(1000) # 1000 milisecunde = 1 sec100. CoverBoxesAnimation(mainBoard,

[(firstSelection[0], firstSelection[1]), (boxx, patrat)])101. RevealedBoxes[firstSelection[0]][firstSelection

[1]] = fals102. RevealedBoxes[boxx][designerilor] = fals

103.Elif hasWon(revealedBoxes): # verificaţi dacă toate perechi găsite

104. GameWonAnimation(mainBoard)105. Pygame.timp.aşteptaţi (2000)106.107. # placa de resetare108. MainBoard = getRandomizedBoard()109. RevealedBoxes = generateRevealedBoxesData(Fals)110.111. # arată complet placa nedescoperite pentru un al doilea.112. Placă de bază, revealedBoxes drawBoard()113. Pygame.afişaj.actualizare()114. Pygame.timp.aşteptaţi(1000)115.116. # Replay start joc animaţie.117. StartGameAnimation(mainBoard)

118. FirstSelection = None # reset firstSelection variabilei119.

120. # Retrasarea ecran şi aşteptaţi un ceas ticăie.121. Pygame.afişaj.actualizare()


122. FPSCLOCK.tick(FPS)123.124.125. Def generateRevealedBoxesData(val):126. RevealedBoxes = []127. Pentru i în gama(BOARDWIDTH):128. RevealedBoxes.append ([val] * BOARDHEIGHT)129. RevealedBoxes de retur130.131.132. Def getRandomizedBoard():133. # Obţineţi o listă de fiecare posibilă forma în fiecare culoare.134. Pictograme = []135. Pentru culoare în ALLCOLORS:136. Pentru forma în ALLSHAPES:137. Pictograme.append( (forma, culoare) )138.

139. Random.Shuffle (pictograme) # depăşirilor ordinea listei de pictograme

140. NumIconsUsed = int(BOARDWIDTH * BOARDHEIGHT / 2) # calcula cât de multe pictograme sunt necesare

141. Pictograme = pictograme[:numIconsUsed] * 2 # două din fiecare 142. Random.Shuffle (pictograme)143.144. # crea consiliul de structură de date, cu pictograme plasate aleator.145. Bordul = []146. Pentru x în gama(BOARDWIDTH):147. Coloana = []148. Pentru y în gama(BOARDHEIGHT):149. Coloana.append(pictograme[0])

150. Del pictograme[0] # demontaţi pictograme ca noi le alocaţi 151. Bordul.append(coloană)152. Placa de retur153.154.155. Def splitIntoGroupsOf(groupSize, PARTEALISTĂ):156. # împarte o listă în lista de liste, unde listele de interior au la157. # majoritatea groupSize numărul de articole.158. Rezultatul = []159. Pentru i în gama(0, len(PARTEALISTĂ), groupSize):160. Rezultatul.append(PARTEALISTĂ[i:i + groupSize])161. Rezultatul de retur162.163.164. Def leftTopCoordsOfBox(boxx, patrat):165. # Converti coordonatele la pixel coordonatele plăcii166. Stânga = boxx * (BOXSIZE + GAPSIZE) + XMARGIN



167. Sus = patrat * (BOXSIZE + GAPSIZE) + YMARGIN168. Retur (stânga, sus)169.170.171. Def getBoxAtPixel(x, y):172. Pentru boxx în gama(BOARDWIDTH):173. Pentru designerilor în gama(BOARDHEIGHT):174. Stânga, sus = leftTopCoordsOfBox(boxx, patrat)175. BoxRect = pygame.Rect(stânga, sus, BOXSIZE, BOXSIZE)176. Dacă boxRect.collidepoint(x, y):

177. Retur (boxx, patrat)178. Retur (Nici unul, nici una)179.180.

181. Def drawIcon(forma, culoare, boxx, patrat):

182. Sfert = int(BOXSIZE * 0.25) # syntactic zahăr 183. Jumătate = int(BOXSIZE * 0,5) # syntactic zahăr

184.185. Stânga, sus = leftTopCoordsOfBox(boxx, patrat) # obţine de la bordul coords coords pixel 186. # Trage forme187. Dacă forma == GOGOAŞĂ:188. Pygame.intocmeste.cerc(DISPLAYSURF, culoare, (stânga + jumătate, sus + jumatate),Jumătate - 5)

189. Pygame.intocmeste.cerc(DISPLAYSURF, BGCOLOR, (stânga + jumătate, sus + jumatate), sfert - 5)190. Forma elif == SQUARE:

191. Pygame.intocmeste.rect(DISPLAYSURF, culoare, (stânga + sfert, sus + sfert, BOXSIZE - jumatate, BOXSIZE - jumatate))192. Forma elif == DIAMOND:

193. Pygame.intocmeste.liniei poligonale(DISPLAYSURF, culoare, ((stânga + jumătate, sus), (stânga + BOXSIZE - 1, sus + jumatate), (stânga + jumătate, sus + BOXSIZE - 1, stânga, sus +Jumatate)))194. Forma elif == linii:195. Pentru i în gama(0, BOXSIZE, 4):196. Pygame.intocmeste.linie(DISPLAYSURF, culoare, (stânga, sus + (i), (stânga +I, partea superioară))

197. Pygame.intocmeste.linie(DISPLAYSURF, culoare, (stânga + i, sus + BOXSIZE - 1), (stânga + BOXSIZE - 1, sus + i))198. Forma elif == OVAL:

199. Pygame.intocmeste.elipsă(DISPLAYSURF, culoare, (stânga, sus + sfert, BOXSIZE, jumatate))

200.201.

202. Def getShapeAndColor(bord, boxx, patrat):

203. # valoarea pentru forma x, y la faţa locului este memorat în bord [x][y][0]


204. # Culoarea valoarea pentru x, y la faţa locului este memorat în bord [x][y][1]205. Placa de retur[boxx][designerilor][0][boxx placa][designerilor][1]206.207.208. Def drawBoxCovers(bord, cutii, acoperire):209. # Trage lăzi acoperite/dezvaluit. - rubricile" este o listă210. # de două liste de element, care au x şi y fata locului din cutie.211. Pentru rubrica in cutii:212. Stânga, sus = leftTopCoordsOfBox(box[0], box[1])213. Pygame.intocmeste.rect(DISPLAYSURF, BGCOLOR, (stânga, sus, BOXSIZE,BOXSIZE))214. Forma, culoare = getShapeAndColor(bord, rubrica[0], box[1])215. DrawIcon(forma, culoare, box[0], box[1])

216. Dacă > 0 de acoperire: # capacul numai dacă există o acoperire 217. Pygame.intocmeste.rect(DISPLAYSURF, BOXCOLOR, (stânga, sus, acoperire,BOXSIZE))218. Pygame.afişaj.actualizare()219. FPSCLOCK.tick(FPS)220.221.222. Def revealBoxesAnimation(boxesToReveal placa):223. # face caseta "dezvăluie" animaţie.224. Pentru acoperirea în gama(BOXSIZE, (-REVEALSPEED) - 1, - REVEALSPEED):225. Placa drawBoxCovers(, boxesToReveal, acoperire)226.227.228. Def coverBoxesAnimation(boxesToCover placa):229. # face - capac cutie de animaţie".230. Pentru gama de acoperire în alin. 0, BOXSIZE + REVEALSPEED, REVEALSPEED):231. Placa drawBoxCovers(, boxesToCover, acoperire)232.233.234. Def drawBoard(, dezvăluit plăcii):235. # Trage toate rubricile in acoperite sau arătat stat.236. Pentru boxx în gama(BOARDWIDTH):237. Pentru designerilor în gama(BOARDHEIGHT):238. Stânga, sus = leftTopCoordsOfBox(boxx, patrat)239. Dacă nu este arătat[boxx][designerilor]:240. # Trage o acoperite caseta.

241. Pygame.intocmeste.rect(DISPLAYSURF, BOXCOLOR, (stânga, sus, BOXSIZE, BOXSIZE))242. Altceva:243. # Trage (arătat) pictograma.244. forma, culoare = getShapeAndColor(bord, boxx, patrat)245. drawIcon(forma, culoare, boxx, patrat)246.



247.248. Def drawHighlightBox(boxx, patrat):249. Stânga, sus = leftTopCoordsOfBox(boxx, patrat)

250. Pygame.intocmeste.rect(DISPLAYSURF, HIGHLIGHTCOLOR, (stânga - 5, partea superioară - 5, BOXSIZE + 10, BOXSIZE + 10), 4)

251.252.

253. Def startGameAnimation(bord):254. # aleatoriu dezvăluie casetele de 8 la un moment dat.255. CoveredBoxes = generateRevealedBoxesData(Fals)256. Rubricile = []257. Pentru x în gama(BOARDWIDTH):258. Pentru y în gama(BOARDHEIGHT):259. Rubricile.append( (x, y) )260. Random.aleator(cutii)261. BoxGroups = splitIntoGroupsOf(8, cutii)262.263. Placa drawBoard(, coveredBoxes)264. Pentru boxGroup în boxGroups:265. Placa revealBoxesAnimation(, boxGroup)266. Placa coverBoxesAnimation(, boxGroup)

267.268.

269. Def gameWonAnimation(bord):

270. # flash de culoare de fundal când player a câştigat271. CoveredBoxes = generateRevealedBoxesData(adevarat)272. Culoare1 = LIGHTBGCOLOR273. Culoare2 = BGCOLOR274.275. Pentru i în gama(13):

276. Culoare1, culoare2 = culoare2, culoare1 # Culorile swap 277. DISPLAYSURF.umpleţi(culoare1)278. Placa drawBoard(, coveredBoxes)279. Pygame.afişaj.actualizare()280. Pygame.timp.aşteptaţi(300)281.282.283. Def hasWon(revealedBoxes):284. # Revine Adevărat dacă toate casetele au fost dezvăluit, în caz contrar fals285. Pentru i în revealedBoxes:286. Dacă falsă în i:

287. Retur # false de retur de fals dacă toate casetele sunt acoperite. 288. Adevarat de retur

289.290.291. Dacă __name__ == "__main__":


292. principalele()

Credite si importuri1. # Puzzle de memorie2. # De Al Sweigart [email protected]. # Http://inventwithpython.com/pygame4. # Eliberată sub un "licenta" BSD simplificată

5.6. Import, pygame aleatorie, sys7. De la pygame.localnicii import *

În partea de sus a programului sunt comentarii despre ce joc este, cine a facut asta, şi în cazul în care utilizatorul ar putea găsi mai multe informaţii. Există de asemenea o notă că codul sursă este liber copyable sub un-‖ BSD licenţa. simplificată Licenţa BSD simplificat este mai adecvată pentru software decât

Licenţa creative (care aceasta comune de carte este eliberată sub), dar practic înseamnă acelaşi lucru: oameni sunt libere de a copia şi împărtăşi acest joc. Mai multe informatii Informaţii despre licenţe pot fi găsite la Http://invpy.com/licenses.

Prezentul program face uz de multe funcţii în alte module, astfel încât importurile aceste module pe linia 6. Linia 7 este de asemenea o declaraţie de import în modulul de la (nume) import * format, ceea ce înseamnă că nu trebuie să tastaţi numele modulului în faţă. Nu există funcţii în pygame. modulul de filiale, dar sunt mai multe variabile de constantă în vrem noi pentru a utiliza precum MOUSEMOTION , KEYUP , SAU PĂRĂSIŢI . Folosind acest stil de declaraţia de import, avem doar la tipul MOUSEMOTION mai degrabă decât pygame.localnicii.MOUSEMOTION .

Numerele Magic sunt necorespunzătoare9. FPS = 30 # cadre pe secundă, viteza generală a programului

10. WINDOWWIDTH = 640 # dimensiunea ferestrei lăţime în pixeli 11. WINDOWHEIGHT = 480 # dimensiunea windows" înălţime în pixeli 12. REVEALSPEED = 8 # cutii de viteză' şi capacele relevă culisant 13. BOXSIZE = 40 # dimensiunea înălţime cutie & lăţime în pixeli 14. GAPSIZE = 10 # dimensiunea spaţiului dintre casete în pixeli

Programele de joc în această carte utilizaţi o mulţime de variabile de constanta. Este posibil să nu dai seama de ce sunt atât de utilă. De exemplu, în loc de a folosi BOXSIZE variabilă în codul nostru am putea chiar tip număr întreg de 40 direct in cod. Dar există două motive pentru a utiliza variabile de constanta.

Dacă am mai vrut să modificaţi dimensiunea fiecare cutie mai târziu, am fi să treceţi prin întregul program şi găsiţi şi înlocuiţi de fiecare dată am introdus 40 . Doar prin utilizarea BOXSIZE constant,

avem doar pentru a schimba linia 13 şi restul programului este deja până la data. Aceasta este



Mult mai bine, mai ales ca am putea folosi numărul întreg de 40 pentru altceva în afară de dimensiunea cutii albe şi schimbarea ca 40 accidental ar cauza bug în programul nostru.

Al doilea, acesta face codul mai lizibile. Treceţi la Secţiunea următoare şi căutaţi la linia 18. Aceasta stabileşte un calcul pentru XMARGIN constant, care este cât de mulţi pixeli sunt pe partea laterală a intregul consiliu de administratie. Acesta este un aspect complicat de expresie, dar puteţi piesa cu grijă ce înseamnă. Linia 18 arată ca mai jos:

XMARGIN = int((WINDOWWIDTH - (BOARDWIDTH * (BOXSIZE + GAPSIZE))) / 2)

Dar dacă linia 18 nu utilizaţi variabilele constantă, ar arata asa:

XMARGIN = int((640 - (10 * (40 + 10))) / 2)

Acum devine imposibil de a aminti exact ce programator destinate sa spui. Aceste numere de inexplicabilă în codul sursă sunt adesea numit magic de numere . Ori de câte ori vă aflaţi în introducerea numerelor magice, trebuie să luaţi în calcul înlocuirea lor cu o constantă în loc de variabile. La Python interpret, ambele linii anterioare sunt exact aceleaşi. Dar pentru un om programator care este citită codul sursă şi încercarea de a înţelege cum funcţionează, a doua versiune de linie 18 nu face mult sens! Constantele ajuta cu adevarat lizibilitatea codului sursă.

Desigur, puteţi merge prea departe de înlocuire a numerelor cu variabilele constantă. Priviţi următorul cod:

ZERO = 0 Unul = 1

Două = 99999999

TWOANDTHREEQUARTERS = 2,75

Nu scrie codul asa. E ridicol.

Mintală verificări cu declaratiile afirma15. BOARDWIDTH = 10 # numărul de coloane de pictograme 16. BOARDHEIGHT = 7 # numărul de rânduri de pictograme 17. Susţin (BOARDWIDTH * BOARDHEIGHT) % 2 == 0, "trebuie să aibă un număr de cutii

pentru perechi de chibrituri."18. XMARGIN = int((WINDOWWIDTH - (BOARDWIDTH * (BOXSIZE + GAPSIZE))) / 2)19. YMARGIN = int((WINDOWHEIGHT - (BOARDHEIGHT * (BOXSIZE + GAPSIZE))) / 2)


Declaraţia de afirmare pe linia 15 asigură lăţimea şi înălţimea plăcii am selectat va duce la o chiar numărul de cutii (deoarece vom avea de perechi de pictograme în acest joc). Există trei piese de la o afirmare declaratie: susţin cuvânt cheie, o expresie pe care, dacă rezultatele în zdrobitor false , programul. A treia parte (după virgulă după expresia) este un şir care apare în cazul în care programul se blochează din cauza afirmaţie.

Declaraţia de afirmare cu o expresie practic zice, -programator afirmă că această expresie trebuie să fie adevărat , în caz contrar programului crash.‖ este un bun mod de a adăuga o luciditate verificaţi la programul dumneavoastră pentru a vă asigura că dacă executarea trece vreodată o afirmaţie putem cel putin stie ca acest cod este funcţionează normal.

Spune dacă numărul este chiar sau imparDacă produsul a plăcii lăţimea şi înălţimea este impartit la doi şi are o restul de 0 ( operatorul haut module evaluează ce % restul este) apoi numărul este chiar. Numerele chiar impartit la doi avea întotdeauna un restul zero. Numere ciudate impartit la doi avea întotdeauna un restul una. Acesta este un truc bun de reţinut dacă aveţi nevoie de codul dumneavoastră de spune dacă numărul este chiar sau ciudat:

>>> someNumber ciugulesti ceva = % 2 == 0

>>> someNumber isOdd = % 2 != 0

În cazul de mai sus, dacă întreg în someNumber era chiar, apoi ciugulesti ceva va fi adevărat . Dacă era ciudat, apoi isOdd va fi adevărat .

Crash devreme şi Crash des!Avand in programul dumneavoastră crash este un lucru rau. Aceasta se întâmplă atunci când programul dumneavoastră are vreo greşeală în cod şi nu poate continua. Dar sunt unele cazuri unde gafele un program de devreme pot evita mai rău bugs mai târziu.

Dacă valorile am ales pentru BOARDHEIGHT BOARDWIDTH şi că am ales pe linia 15 şi 16 duce la o placa cu un număr impar de cutii (cum ar fi dacă lăţimea au fost 3 şi înălţime au fost 5), apoi acolo ar fi întotdeauna una stânga peste pictograma care nu ar fi avut o pereche care să se potrivească. Acest lucru ar cauza un bug mai târziu în program şi ar putea lua o mulţime de lucrări de depanare pentru a figura în afara ca adevarata sursa bug este chiar la începutul programului. De fapt, doar pentru distracţie, încercaţi comentând în afirmarea astfel încât nu rulează şi apoi setarea BOARDWIDTH şi

Constantele BOARDHEIGHT atât la numerele de ciudat. Atunci când rulaţi programul, va arăta imediat o eroare se întâmplă pe o linie 149 în memorypuzzle.py , care este în getRandomizedBoard() !

Traceback (cel mai recent apel ultima):



Fişierul "C:\carte2svn\src\memorypuzzle.py", linia 292, modulul în <> Principalele()

Fişierul "C:\carte2svn\src\memorypuzzle.py", linia 58, în principal MainBoard = getRandomizedBoard()

Fişierul "C:\carte2svn\src\memorypuzzle.py", linia 149, în getRandomizedBoard

Coloanele.append(pictograme[0]) IndexError: lista index în afara domeniului

Am putea petrece mult timp privind la getRandomizedBoard() incearca sa afle ce e rau cu el înainte de seama ca getRandomizedBoard() este foarte bine: adevarata sursa a fost bug pe linia 15 şi 16 unde vom seta BOARDWIDTH şi constantele BOARDHEIGHT.

Afirmatia conform careia se asigură că acest lucru se întâmplă niciodată. Dacă codul nostru va crash, vrem să crash de îndată ce detectează ceva este teribil de greşit, deoarece în caz contrar bug nu pot deveni evident mult mai târziu până în program. Crash mai devreme!

Doriţi să adăugaţi susţin declaratii oricând există o condiţie în programul dumneavoastră care trebuie întotdeauna, întotdeauna, fi . Crash des! Nu trebuie să treceţi peste bord şi puneţi susţin declaratii peste tot, dar deseori zdrobitoare cu afirmă merge un drum lung în detectarea Adevărata sursă a unui bug. Crash devreme şi crash des!

(În codul dumneavoastră că este. Nu, zice, cand calare pe un ponei.)

Făcând codul sursă arată foarte21. # R G B22. Gri = (100, 100, 100)

23.NAVYBLUE = ( 60, 60, 100)

24. Alb = (255, 255, 255)25. Roşu = (255, 0, 0)26. În Verde = ( 0, 255, 0)27. Albastru = ( 0, 0, 255)28. Galben = (255, 255, 0)29. Portocaliu = (255, 128, 0)30. Violet = (255, 0, 255)31. Turcoaz = ( 0, 255, 255)32.

33. BGCOLOR = NAVYBLUE34. LIGHTBGCOLOR = GRI35. BOXCOLOR = alb36. HIGHLIGHTCOLOR = ALBASTRU

Reţineţi că culorile in Pygame sunt reprezentate de un tuple de trei numere întregi de la 0 la 255 . Aceste trei numere întregi reprezintă cantitatea de roşu, verde şi albastru în culoarea care este de ce aceste


Tuples sunt denumite valori RGB. Anunţ spaţierea tuples pe liniile de la 22 la 31 sunt astfel încât R, G şi B numerele întregi. În Python de indentare (spaţiul de la începutul liniei) este trebuie să fie exact, dar distanţa în restul de linie nu este atat de stricta. Prin spaţierea în numere întregi în tuple, putem vedea clar cum valori RGB comparaţi cu fiecare alte. (Mai multe info pe spaţiul dintre rânduri şi indentare este ca Http://invpy.com/whitespac e .) Acesta este un lucru frumos pentru a vă face organ mai lizibile astfel, dar nu se obosesc cheltuiţi prea mult timp pentru a face. Codul nu avea sa fie destul de la lucru. La un anumit punct, va fi să petreacă mai mult timp decât ai spatii de tastare ar fi salvat prin având lizibile tuple valorile.

Cu ajutorul variabilelor constantă în loc de sfori38. Gogoaşă = 'donut"39. SQUARE = ""plasanăvod"40. DIAMOND = 'diamond"41. Linii = "linii"42. Ovalul = "ovale"

De asemenea, programul stabileşte variabilele constantă pentru unele şiruri. Aceste constante vor fi utilizate în structura de date pentru consiliul de administraţie, spatiile care de urmărire bord au care pictograme. Folosind o variabilă de constantă în loc de şirul de valoare este o idee bună. Priviţi următorul cod, care vine de la linia 187:

Dacă forma == GOGOAŞĂ:

Forma variabilă va fi setat la una dintre sforile 'donut" , ""plasanăvod" , "iamond" , "linii" , sau "ovale" şi apoi comparate cu constanta de aluat. Dacă am făcut un typo atunci când linia de scris 187, de exemplu, ceva de genul:

Dacă forma == DUNOT:

Apoi Python ar crash, oferind un mesaj de eroare spunând că nu este numit DUNOT variabilă . Acest lucru este bun. Deoarece programul a eşuat pe linia 187, când ne verificaţi ca linia va fi uşor pentru a vedea ca bug a fost provocat de un typo. Totuşi, dacă am fost folosind sfori în loc de variabile şi constante a făcut acelaşi typo, linia 187 ar arăta acest:

Dacă forma == 'dunot":

Acest lucru este perfect acceptabilă Python cod, astfel încât acesta va distruge la prima când executaţi. Totuşi, acest lucru va duce la bug mai pe stranii programului nostru. Deoarece nu se autosuspende cand problema este cauzată, poate fi mult mai greu pentru a găsi.



Că Avem destule pictograme44. ALLCOLORS = (roşu, verde, albastru, galben, portocaliu, violet, turcoaz)45. ALLSHAPES = (GOGOAŞĂ, pătrat, Diamond, linii, oval)

46. Susţin len(ALLCOLORS) * len(ALLSHAPES) * 2 >= BOARDWIDTH * BOARDHEIGHT, "Placa este prea mare pentru numărul de forme/culorile definite."

Pentru jocul nostru program pentru a putea crea pictograme pentru fiecare posibilitate de culoare şi formă combinaţie, avem nevoie de a face un tuple ca detine toate aceste valori. Există de asemenea o alta afirmatie pe linia 46 pentru a vă asigura că nu sunt suficient de forma combinatii de culori/pentru dimensiunea de bord am. Dacă nu există, apoi programul va crash pe linia 46 şi vom şti că ne fie trebuie să adăugaţi mai multe culori şi forme sau lăţimea şi înălţimea plăcii de dimensiuni mai mici. Cu 7 culori şi 5 forme, putem face 35 (7 x 5) pictograme diferite. Si pentru ca o sa facem o pereche de fiecare pictogramă, înseamnă că putem avea o placa cu până la 70 (35 x 2 sau 7 x 5 x 2) spaţii.

Tuples vs. liste, neschimbătoare vs. mutabilSă fi observat că ALLCOLORS şi ALLSHAPES variabile sunt tuples în loc de liste. Când nu vrem să utilizaţi tuples şi când facem doriţi să utilizaţi liste? Şi care este diferenţa între ele oricum?

Tuples şi listele sunt aceleaşi în fiecare mod cu excepţia a două: tuples utilizaţi paranteze în loc de paranteze pătrate şi elementele din tuples nu pot fi modificate (dar elementele din liste pot fi modificate). Adesea ne liste de apel mutabil (in sensul ca ele pot fi schimbate) şi tuples neschimbătoare (in sensul ca ele nu poate fi schimbată).

Pentru un exemplu de a incerca sa schimbe valorile în liste şi tuples, priviţi următorul cod:

>>> listVal = [1, 1, 2, 3, 5, 8] >>> tupleVal = (1, 1, 2, 3, 5, 8)

>>> listVal[4] = 'Hello!"

>>> listVal

[1, 1, 2, 3, "Bună ziua!", 8] >>> tupleVal[4] = 'Hello!"

Traceback (cel mai recent apel ultima): Fişierul "<stdin>", linia 1, modulul în <>

TypeError: "obiect" tuple nu acceptă atribuirea element >>> tupleVal

(1, 1, 2, 3, 5, 8)

>>> tupleVal[4] 5

Observaţi că atunci când vom încerca să schimbaţi elementul la indicele 2 în tuple, Python ne oferă un mesaj de eroare spunând că obiectele tuple nu acceptă -element‖ atribuire.


Este o prostie beneficiază şi de un important beneficiu tuple stabilitate selectabilă a. De un beneficiu este ca organ care utilizează tuples este uşor mai mare de cod care utilizează liste. (Python este capabil de a face unele optimizări ştiind că valorile de la un tuple va schimba niciodata.) Dar având codul dvs. Executaţi cateva nanosecunde mai repede nu este importantă.

Beneficii importante cu ajutorul tuples este similară de a beneficia de ajutorul constant variabile: e un semn ca valoarea în tuple va schimba niciodata, astfel încât oricine citind codul de mai târziu va putea spune, -ma pot astepta ca aceasta tuple va fi întotdeauna acelaşi. În caz contrar programator ar fi folosit o listă.‖ Aceasta vă permite de asemenea un viitor programator codul dumneavoastră de citire spune, -dacă am vedea o listă valoarea, stiu ca nu poate fi modificat în acest program. În caz contrar, programator care a scris acest cod ar fi folosit un‖ tuple.

Încă mai puteţi aloca o nouă valoare pentru o variabila tuple:

>>> tupleVal = (1, 2, 3)

>>> tupleVal = (1, 2, 3, 4)

Motivul acest cod lucrări este că codul nu este schimbarea (1, 2, 3) tuple pe a doua linie. Este atribuirea unui tuple complet nouă (1, 2, 3, 4) la tupleVal , şi suprascrierea tuple vechi de valoare. Nu puteţi folosi paranteze pătrate pentru a modifica un element în tuple.

Şirurile sunt de asemenea un tip de date imuabilă. Puteţi utiliza paranteze pătrate pentru a citi un singur caracter într-un string, dar nu puteţi modifica un singur caracter într-un string:

>>> strVal = 'Hello' >>> strVal[1]

"e"

>>> strVal[1] = "X" Traceback (cel mai recent apel ultima):

Fişierul "<stdin>", linia 1, modulul în <>

TypeError: "tr" obiect nu acceptă atribuirea element

Un element Tuples nevoie de o virgulă de braţ longitudinalDe asemenea, un minor detalii despre tuples: Dacă aveţi nevoie vreodată să scrie codul despre un tuple care are una valoarea în o, atunci acesta trebuie să aibă o virgulă în ea, cum ar fi acest:

OneValueTuple = (42 )


Dacă uitaţi acest virgulă (şi este foarte uşor de uitat), apoi Python nu va putea spune diferenta dintre aceasta şi un set de paranteze care doar schimba ordinea operaţiilor. De exemplu, căutaţi în următoarele două linii de cod:

VariableA = (5 * 6) variableB = (5 * 6, )

Valoarea care este stocat în variableA este doar număr întreg de 30 . Totuşi, expresia pentru declaraţia de atribuire este variableB 's unic obiect tuple valoarea (30, ) . Blank tuple valorile nu aveţi nevoie de o virgula in ei, poate fi doar un set de paranteze singuri: () .

Conversia între liste şi TuplesPuteţi converti între lista şi valorile tuple exact cum puteţi converti între string şi număr întreg de valori. Trece o valoare tuple la lista() şi acesta va reveni o lista sub forma de ca valoarea tuple. Sau, treceţi o listă de valori tuple() şi acesta va reveni un tuple sub forma de lista la valoarea. Încercaţi să introduceţi următoarele în cochilia interactive:

>>> spam = (1, 2, 3, 4) >>> spam = lista(spam)

>>> spam

[1, 2, 3, 4]

>>> spam = tuple(spam) >>> spam

(1, 2, 3, 4)

>>>

Declaraţia globale şi de ce Variabile globale sunt rele48. Def principalele():49. FPSCLOCK, DISPLAYSURF globale50. Pygame.init()51. FPSCLOCK = pygame.timp.Ceas()52. DISPLAYSURF = pygame.afişaj.set_mode((WINDOWWIDTH, WINDOWHEIGHT))

53.54. Mousex = 0 # utilizate pentru a stoca coordonata x a mouse caz 55. Mousey = 0 # utilizate pentru a stoca coordonata Y a mouse caz 56. Pygame.afişaj.set_Titlul(Litiu-Ion fără "Joc")

Aceasta este începutul principalele() , care este unde (destul de ciudat) partea principală a jocului este de cod. Funcţiile numite în funcţia principală de() va fi explicată mai târziu în acest capitol.

Linia 49 este o declaraţie de global. Declaraţia global globală este cuvântul cheie urmat de o listă de delimitat de numele variabilelor. Aceste nume de variabile sunt apoi marcate cu global


Variabile. În interiorul principalelor() , aceste denumiri nu sunt pentru variabilele locale care ar putea avea să aibă acelaşi nume ca variabile globale. Acestea sunt variabile globale. Toate valorile atribuite în principal() va persista în afara principalelor() . Suntem marcarea FPSCLOCK şi DISPLAYSURF variabile ca global deoarece acestea sunt utilizate în mai multe alte funcţii în program. (Mai multe informatii este la Http://invp y. com/cuvinte e .) Există patru reguli simple pentru a determina dacă o variabilă este local sau global:

1. Dacă există o declaraţie de global o variabilă de la începutul funcţiei, apoi variabila este global.

2. Dacă numele de o variabilă în funcţie are acelaşi nume ca şi funcţia de variabile globale niciodată nu atribuie variabilei o valoare apoi că variabila globală este variabilă.

3. Dacă numele de o variabilă în funcţie are acelaşi nume ca şi funcţia de variabile globale nu atribuiţi variabilei o valoare apoi ca variabilă este o variabilă de local.

4. Dacă nu există o variabila globala cu numele variabilei în funcţie, apoi ca variabilă este evident o variabilă de local.

Vă doriţi în general să evite utilizarea variabilelor globale în interiorul funcţiilor. O funcţie este trebuia sa fie ca un mini-program în interiorul programului cu intrări specifice (parametrii) şi o ieşire (valoarea de retur). Dar o funcţie care citeşte şi scrie în variabile globale are intrări suplimentare şi de ieşire. Deoarece ar putea variabile globale au fost modificate în mai multe locuri înainte de funcţia a fost numit, poate fi dificil de a raporta un bug care implică un rau valoarea setată în variabila globală.

Având o funcţie ca un program de mini-separate care nu folosiţi variabile globale face mai uşor de a gãsi erori în codul dvs., deoarece parametrii funcţiei sunt clar cunoscute. De asemenea, schimbarea codului în funcţie mai uşoară, deoarece dacă funcţia nouă funcţionează cu aceeaşi parametri şi oferă aceeaşi valoare de retur, va face automat funcţionează cu restul programului ca vechiul funcţie.

Practic, utilizând variabile globale ar putea face mai uşor pentru a scrie programul dumneavoastră dar au în general o face mai greu de depanare.

În jocuri în această carte, variabilele globale sunt folosite in cea mai mare parte de variabile care ar fi constantele global nu schimba niciodata ca, dar este nevoie de pygame.init() numit primul. Deoarece acest lucru se întâmplă în principalele() , acestea sunt setate în principalele() şi trebuie să fie global pentru alte funcţii pentru a vedea. Dar variabile globale sunt utilizate ca şi constante nu se schimba, astfel încât sunt mai puţin susceptibile de a cauza confuz de bug-uri.

Dacă nu înţelegeţi această, nu vă faceţi griji. Scriu doar codul dumneavoastră astfel încât să treacă în valori la funcţii mai degrabă decât au funcţiile citiţi variabile globale in general.


Structuri de date şi listele de 2D58. MainBoard = getRandomizedBoard()59. RevealedBoxes = generateRevealedBoxesData(Fals)

Funcţia de getRandomizedBoard() revine o structură de date care reprezintă membru al consiliului de administratie. Funcţia de generateRevealedBoxesData() revine o structură de date care reprezintă care casetele sunt acoperite, respectiv. Valorile de retur din aceste funcţii sunt bidimensionale (2D), liste sau liste de liste. O listă de liste de liste de valori ar fi o listă de 3D. Un alt cuvânt pentru două sau mai multe liste de tridimensională este o listă de multidimensional.

Dacă avem o lista valoarea memorată în o variabilă numită spam , am putea accesa o valoare in lista cu paranteze pătrate, astfel ca spam[2] pentru a prelua a treia valoare din listă. Dacă valoarea de spam[2] este în sine o listă, atunci am putea folosi un alt set de paranteze pătrate pentru a recupera o valoare în lista . Aceasta ar arăta, de exemplu, spam[2][4] , care ar prelua valoarea de al cincilea în lista care este a treia valoare în spam . Cu ajutorul acestei practici editoriale de liste de liste facilitează hartă o placa 2D la o valoare de lista 2D. Deoarece mainBoard variabilă va stoca pictograme din acesta, daca am vrut sa o pictograma de pe placa de pe poziţia (4, 5) apoi am putea să folosesc expresia mainBoard[4][5] . Deoarece pictogramele înşişi sunt stocate ca element cu două tuples cu formă şi culoare, completă de structură de date este o lista de lista de două-articolul tuples. Uff!

Aici este un exemplu de mici. Spune la bordul arata ca acest:

Datele corespunzătoare de structura ar fi:

MainBoard = [[(GOGOAŞĂ, albastru), (linii, albastru), (pătrat, PORTOCALIU)], [(pătrat,

Verde), (GOGOAŞĂ, albastru), (DIAMOND, galben)], [(pătrat, verde), (oval, galben), (pătrat, portocaliu)], [(Diamond, galben), (linii, albastru), (oval, galben)]]

(Dacă cartea este în alb şi negru, puteţi vedea o versiune de culoare a imaginii de mai sus la Http://invpy.com/memoryboard.) veţi observa că mainBoard[X][y] va corespunde pictograma de la (x, y) coordonează pe placa.


Intre timp, a dezvaluit‖ -casetele de structură de date este de asemenea o listă de 2D, cu excepţia cazului în loc de două-articolul tuples ca placa de structură de date, are valori booleene: Adevărat dacă caseta de la care x, coordonata y este identificată şi falsă dacă este acoperit. Trecerea la false generateRevealedBoxesData() setează toate valorile Booleene de la fals . (Această funcţie este explicat în detaliu mai târziu.)

Aceste două structuri de date sunt utilizate pentru a urmări în statul de joc.

"Start joc" Animaţie

61. FirstSelection = None # stochează (x, y) din prima casetă de executat clic. 62.

63. DISPLAYSURF.umpleţi(BGCOLOR)64. StartGameAnimation(mainBoard)

Linia 61 setează o variabilă numită firstSelection cu valoarea FĂRĂ . ( Nici este valoarea care reprezintă o lipsă de o valoare. Aceasta este singura valoare a datelor de tip, NoneType . Mai multe informatii la http://invpy.com/None) când player clicuri pe o pictograma de pe bordul, programul are nevoie de pin dacă aceasta a fost prima pictogramă din pereche care a fost executat clic pe pictograma sau al doilea. Dacă firstSelection este nimeni , faceţi clic pe pictograma a fost pe prima şi ne stoca Coordonatele XY în variabila firstSelection ca un tuple de două numere întregi (unul pentru X valoarea, alte pentru Y). Pe al doilea clic valoarea va fi acest tuple şi nu fără , care este cum programul pinii ca este al doilea clic pictograma. Linia 63 se umple întreaga suprafaţă cu culoarea de fundal. Aceasta va fi de asemenea vopsea peste ceva care a folosit pentru a fi pe suprafaţă, care ne dă o curat pentru a începe trasarea pe graphics. Dacă nu aţi jucat joc puzzle de memorie, veţi observa că la începutul jocului, toate casetele sunt repede acoperite şi fără capac aleator pentru a da player aruncaţi o privire la care pictograme sunt sub care casetele. Acest lucru se întâmplă în startGameAnimation toate() , care este explicat mai târziu în acest capitol.

Este important de a da player această privire indrazneata (dar nu suficient de mult de o privire indrazneata de a lasa jucatorul memora cu uşurinţă pictograma de locaţii), pentru ca altfel ar avea nici un indiciu unde orice pictograme sunt. Făcând clic pe pictogramele orbeste nu este la fel de plăcută ca şi având o mica sugestie pentru a continua..

Buclă de joc66. În timp ce adevarat: # jocul principal de buclă 67. MouseClicked = fals68.

69. DISPLAYSURF.umpleţi(BGCOLOR) # desenul ferestrei 70. Placă de bază, revealedBoxes drawBoard()


Buclă de joc este o buclă infinită de care începe pe linia 66 care menţine repetând calculul pentru cât timp de joc este în curs. Nu uitaţi că jocul mânerele de buclă de evenimente, actualizări de jocul de stat, şi trage jocul de stat de ecran.

Jocul a stat pentru memoria programului de puzzle este stocat în următoarele variabile:

l MainBoardl RevealedBoxesl FirstSelectionl MouseClickedl Mousexl Mousey

Pe fiecare iteraţie a buclei de joc în memorie program de puzzle, mouseClicked stochează o variabilă valoarea Booleene este adevărat dacă jucătorul a făcut clic pe mouse în timpul acestui joc prin iteratie buclă. (Aceasta este parte a urmărirea jocul de stat.)

Pe linia 69, suprafaţa este vopsite cu culoarea de fundal pentru a şterge ceva care a fost trasate anterior pe ea. Programul apoi apeluri drawBoard() pentru a desena curente a bazate pe placa de bord si -arătat rubricile‖ structuri de date care ne trece-o. (Aceste linii de cod sunt parte din desen şi actualizarea ecranului.)

Nu uitaţi că desenul nostru funcţionează numai pe suprafaţa de afişare de memorie de obiect. Acest obiect de suprafaţă nu va apărea efectiv pe ecran până când facem apel pygame.afişaj.actualizare() , care este adoptată la sfârşitul jocului de buclă pe linia 121.

Caz buclă de manipulare72. Pentru caz în caz.obtine pygame.(): # caz buclă de manipulare 73. Dacă caz.tip == QUIT sau (caz.tip == KEYUP şi caz.==

K_iasă):74. Pygame.quit()75. Sys.exit()

76. Elif caz.tip == MOUSEMOTION:77. mousex, mousey = caz.pos78. Elif caz.tip == MOUSEBUTTONUP:

79. Mousey mousex, = caz.pos80. MouseClicked = Adevărat

Buclă de pe linia de pentru 72 execută cod pentru fiecare caz că sa întâmplat de la ultima iteraţie a buclei de joc. Această buclă este numit caz manipularea buclă (care este diferit de buclă de joc, desi caz manipularea buclă este în interiorul jocului buclă) şi iterates peste lista de

pygame.caz obiecte returnate de pygame.caz.obţineţi() apel.


Dacă evenimentul a fost un obiect fie un caz QUIT sau un eveniment KEYUP pentru tasta Esc, apoi programul ar trebui să pună capăt. În caz contrar, în caz de MOUSEMOTION (de eveniment cursorului mouse-ului a fost mutată) sau MOUSEBUTTONUP caz (butonul mouse-ului a fost apăsat mai devreme şi acum butonul a fost lăsaţi până), poziţia cursorului mouse-ului trebuie să fie stocate în mousey mousex şi variabile. Dacă acest lucru a fost un caz, mouseClicked MOUSEBUTTONUP trebuie de asemenea setat la adevarat .

O dată am manevrat toate evenimentele, valorile memorate în mousey mousex , , şi mouseClicked ne va spune orice player de intrare care ne-a dat. Acum noi trebuie să actualizaţi jocul de stat şi trasaţi rezultatele de ecran.

Caseta de control care cursorul mouse-ului este de peste82. Boxx, designerilor = getBoxAtPixel(mousex, mousey)83. Dacă boxx != nici unul şi designerilor != fără:84. # mouse este în prezent peste o cutie.85. Dacă nu revealedBoxes[boxx][designerilor]:86. drawHighlightBox(boxx, patrat)

Funcţia de getBoxAtPixel() va reveni un tuple de două numere întregi. Unitatea nicaieri reprezintă coordonatele placa XY caseta care sunt coordonatele mouse-ului peste. Cum getBoxAtPixel() nu este explicat mai târziu. Toate trebuie sa stim acum este că dacă mousey mousex şi coordonatele erau peste o cutie, un tuple din placa XY coordonatele sunt returnate de funcţii şi stocate în boxx şi designerilor . În cazul în care cursorul mouse-ului nu a fost peste orice caseta (de exemplu, dacă acesta a fost oprit pentru a plăcii sau o întrerupere în între cutii) apoi tuple (Nici unul, nici una) este returnat de funcţie şi boxx şi designerilor vor atât nu au nici unul stocate în ele.

Suntem interesaţi numai în cazul în care boxx şi designerilor nu au nici unul din ele, astfel încât următoarea de mai multe linii de cod sunt in blocul urmând dacă linia de declaratie asupra 83 ca verificările pentru acest caz. Dacă executarea a ajuns în interiorul acestui bloc, stim ca utilizatorul are mouse cursorul peste o cutie (si poate ca are de asemenea executat clic pe mouse, în funcţie de valoarea memorată în mouseClicked ).

Declaratia de pe linia de dacă 85 controale dacă caseta este acoperit sau nu prin citirea valoarea memorată în revealedBoxes[boxx][designerilor] . Dacă este fals , apoi ştim caseta este acoperit. ori de câte ori mouse este peste o caseta de acoperit, atragem o lumină albastră în jurul caseta pentru a informa player care pot faceţi clic pe ea. Această evidenţă nu este făcut pentru cutiile care sunt deja descoperite. Desenul de evidenţiere este tratată de către drawHighlightBox noastre() , care este explicat mai târziu.

87. Dacă nu revealedBoxes[boxx][designerilor] şi mouseClicked:88. revealBoxesAnimation(mainBoard, [(boxx, patrat)])


89. RevealedBoxes[boxx][designerilor] = True # cutia pe "arătat"

Pe linia 87, verificaţi dacă cursorul mouse-ului este nu numai pe o caseta de acoperit dar dacă a fost de asemenea clic de mouse. În acest caz, vrem să joace -dezvăluie‖ animaţia pentru ca rubrica prin apelarea revealBoxesAnimation noastre() (care este, Ca cu toate celelalte funcţii principale de() apeluri, a explicat mai târziu în acest capitol). Trebuie să reţineţi că chemarea această funcţie numai trage animaţia din cutie fiind descoperite. Nu este până când linia 89 atunci când am setat revealedBoxes[boxx][designerilor] = adevărat că structura de date ca pinii de joc este actualizat de stat.

Dacă Comentariu linie 89 şi apoi rulaţi programul, veţi observa că după ce faceţi clic pe o casetă de dezvăluie animaţia este jucat, dar apoi caseta apare imediat acoperite din nou. Aceasta deoarece revealedBoxes[boxx][designerilor] este încă setată la fals , astfel încât la următoarea iteraţie de joc, buclă de administraţie este trasată cu această casetă acoperit. Linia nu 89 ar provoca destul de ciudata bug în programul nostru.

Manipularea Prima caseta de executat clic90. Dacă firstSelection == fără: # caseta de curent a fost primul

Rubrica a făcut clic91. FirstSelection = (boxx, patrat)92. Altceva: # caseta de curent a fost al doilea clic caseta93. # Verificaţi dacă există o potrivire între cele două pictograme.


FirstSelection[0], firstSelection[1])


Boxx, patrat)

Înainte de executarea a intrat in joc, buclă de firstSelection era setat la nici variabilă . Programul nostru va interpreta acest lucru înseamnă că nu au fost clic pe casetele astfel încât dacă linia anilor 'starea este adevarat , care reprezinta aceasta este prima din cele două eventual de aliniere casetele care a fost apăsat. Vrem să joace dezvăluie animaţia pentru caseta şi menţine apoi ca rubrica neacoperită. Am setat firstSelection variabilă pentru a o tuple din cutie coordonatele pentru caseta care a fost apăsat.

Dacă aceasta este a doua casetă jucătorul a făcut clic pe, vrem să joace dezvăluie animaţia pentru ca rubrica dar apoi verificaţi dacă cele două pictograme sub casetele sunt congruente. Funcţia de getShapeAndColor() (explicate mai târziu) va prelua forma şi culoarea valorilor de pictograme. (Aceste valori va fi una dintre valorile de la ALLCOLORS şi ALLSHAPES tuples.)


Manipulaţi o pereche de nepotrivite de pictograme

97.Dacă pictograma de1forma != forma sau pictograma pictograma21! color=

Pictogramă2culoare:

98.# Pictograme nu corespund. Re-capac până ambele selecţii.

99. Pygame.timp.aşteptaţi(1000) # 1000 milisecunde = 1 sec100. CoverBoxesAnimation(mainBoard,

[(firstSelection[0], firstSelection[1]), (boxx, patrat)])101. RevealedBoxes[firstSelection[0]][firstSelection

[1]] = fals102. RevealedBoxes[boxx][designerilor] = fals

Declaratia de pe linia de dacă 97 controale dacă fie cu forme sau culori cu două pictograme nu corespund. Dacă acesta este cazul, atunci pentru a întrerupe jocul pentru 1000 milisecunde (care este acelaşi cu 1 secundă) prin apelarea pygame.timp.aşteptaţi(1000) astfel ca player are o sansa de a vedea că cele două pictograme nu corespund. Apoi -‖ capacul de animaţie joacă pentru ambele casete. De asemenea, dorim să actualizaţi jocul de stat pentru a marca aceste cutii ca au descoperit (acoperite).

Manipularea Dacă Jucătorul a câştigat

103.Elif hasWon(revealedBoxes): # verificaţi dacă toate perechi găsite

104. GameWonAnimation(mainBoard)105. Pygame.timp.aşteptaţi (2000)106.107. # placa de resetare108. MainBoard = getRandomizedBoard()109. RevealedBoxes = generateRevealedBoxesData(Fals)110.111. # arată complet placa nedescoperite pentru un al doilea.112. Placă de bază, revealedBoxes drawBoard()113. Pygame.afişaj.actualizare()114. Pygame.timp.aşteptaţi(1000)115.116. # Replay start joc animaţie.117. StartGameAnimation(mainBoard)118. FirstSelection = None # reset firstSelection variabilei

În caz contrar, dacă linia 97's starea au fost false , apoi cele două pictograme trebuie să fie un meci. Programul nu are chiar sa faca altceva la casetele de la acel punct: poate doar lasa ambele casete în arătat stat. Cu toate acestea, programul trebuie să verificaţi dacă aceasta a fost ultima pereche de pictograme de pe placa pentru a se potrivesc. Aceasta se face în interiorul hasWon noastre() , care revine Adevărat dacă consiliul de administratie de la un stat câştigătoare este ca toate casetele sunt revelate).


Dacă acesta este cazul, vrem să joc - Joc câştigat‖ animaţia prin apelarea gameWonAnimation() , apoi pauză uşor pentru a lasa jucatorul gusturile în victoria lor şi apoi resetaţi de structuri de date în mainBoard şi revealedBoxes pentru a începe un nou joc.

Linia 117 redă -start joc‖ animaţie din nou. După care, executarea programului va doar în buclă la joc de buclă ca de obicei, şi player poate continua să joace până când ieşiţi din program.

Indiferent dacă cele două casete de aliniere au fost sau nu, după a doua linie a fost apasat pe caseta 118 va seta variabila firstSelection înapoi la nici unul astfel încât următoarea casetă player clicuri pe va fi interpretată ca primul clic caseta de o pereche de eventual de aliniere pictograme.

Trasarea jocul de stat la ecran120. # Retrasarea ecran şi aşteptaţi un ceas ticăie.121. Pygame.afişaj.actualizare()122. FPSCLOCK.tick(FPS)

În acest punct, jocul de stat a fost actualizată în funcţie de jucător de intrare, şi cele mai recente jocul de stat a fost atras de suprafaţă de afişare DISPLAYSURF obiect. Am ajuns la sfârşitul jocului, buclă astfel încât am apel pygame.afişaj.actualizare() pentru a desena DISPLAYSURF

Suprafata de la obiect la ecranul calculatorului.

Linia 9 seta fps constant la numărul întreg de 30 , sensul vrem de joc pentru a rula (la majoritatea) la 30 de cadre pe secundă. Dacă vrem de program pentru a rula mai rapid, putem creşte acest număr. Dacă vrem programul să funcţioneze mai lent, ne poate scădea acest număr. Acesta poate fi setat la o valoare de plutire ca 0.5 , care va rula programul la jumătate de cadru pe secundă, un cadru pe două secunde.

Pentru a funcţiona la 30 de cadre pe secundă, fiecare cadru trebuie să fie elaborate în 1/30 -a unei a doua. Aceasta înseamnă că pygame.afişaj.actualizare() şi toate codul în bucla de joc trebuie să execute în sub 33,3 ms. Orice moderne de calculator poate face acest lucru cu uşurinţă cu o grămadă de timp. Pentru a preveni programul de a merge prea repede, vom numi tick() a pygame.Ceas obiect în FPSCLOCK să-l pause programul pentru restul de 33,3 ms.

Deoarece acest lucru este realizat de la capătul de joc, buclă acesta asigură că fiecare iteraţie a buclei de joc ia (cel puţin) 33,3 ms. Dacă din orice motiv pygame.afişaj.actualizare() apel şi codul în bucla de joc durează mai mult decât 33,3 milisecunde, apoi bifaţi() nu va aşteptaţi la toate şi readuceţi imediat.


Am tot spunea că alte funcţii ar putea fi explicată mai târziu în capitolul. Acum că am trecut peste principalele() şi aveţi o idee despre cum funcţionează programul general, să mergem în detalii de toate celelalte funcţii care sunt numite de la principalele() .

Crearea "arătat cutii" structură de date125. Def generateRevealedBoxesData(val):126. RevealedBoxes = []127. Pentru i în gama(BOARDWIDTH):128. RevealedBoxes.append ([val] * BOARDHEIGHT)129. RevealedBoxes de retur

Funcţia de generateRevealedBoxesData() trebuie să creaţi o listă de liste de valori booleene. Valoarea de booleene de va fi doar una care este trecut în funcţie ca val de parametru. Vom începe cu structură de date ca o listă goală în revealedBoxes variabilă.

Pentru a face structura datelor au revealedBoxes[X][y] structura, de care avem nevoie pentru a vă asigura că listele de interior reprezintă coloanele verticale de administraţie şi nu de rânduri de pe orizontală. În caz contrar, structură de date va avea o revealedBoxes[y][X] structura.

Buclă pentru a va crea coloanele şi apoi le va adăuga la revealedBoxes . Coloanele sunt create utilizând lista de replicare, astfel încât coloana lista are ca multe val valori caBOARDHEIGHT dictează.

Crearea de placa de structură de date: Pasul 1 - Obţineţi toate pictogramele de posibile132. Def getRandomizedBoard():133. # Obţineţi o listă de fiecare posibilă forma în fiecare culoare.134. Pictograme = []135. Pentru culoare în ALLCOLORS:136. Pentru forma în ALLSHAPES:137. Pictograme.append( (forma, culoare) )

Consiliul de structură de date este doar o listă de liste de tuples, unde fiecare tuple are două valori: una pentru pictograma de formă şi unul pentru culoarea pictogramei. Dar crearea această structură de date este un pic complicat. Avem nevoie de a fi sigur de a avea exact cât de multe pictograme pentru numărul de cutii de pe placă şi de asemenea că există două şi numai două simboluri de fiecare tip.

Primul pas pentru a face acest lucru este de a crea o lista cu fiecare combinaţie posibilă de formă şi culoare. Amintim ca avem o lista de fiecare culoare şi formă în ALLCOLORS şi ALLSHAPES , astfel încât procesul de nesting pentru bucle de pe liniile 135 şi 136 va trece prin fiecare posibilă forma pentru fiecare posibila culoare. Acestea sunt fiecare adăugate la lista de pictograme de pe linia variabilă 137.


Pasul 2 - amestecarea şi Truncating lista cu toate pictogramele139. Random.Shuffle (pictograme) # depăşirilor ordinea listei de pictograme

140. NumIconsUsed = int(BOARDWIDTH * BOARDHEIGHT / 2) # calcula cât de multe pictograme sunt necesare

141. Pictograme = pictograme[:numIconsUsed] * 2 # două din fiecare 142. Random.Shuffle (pictograme)

Dar reţineţi, pot exista mai multe combinaţii posibile decat spatiile de pe placa. Avem nevoie pentru a calcula numărul de spaţii de pe bordul prin înmulţirea BOARDWIDTH prin BOARDHEIGHT . Apoi împărţim acel număr de 2 pentru ca ne va fi de perechi de pictograme. Pe o placa cu 70 spatii, am nevoie de doar 35 pictograme diferite, deoarece vor fi două de fiecare pictogramă. Acest număr va fi memorat în numIconsUsed .

Linia 141 utilizează lista pentru feliere de a pune mina pe primul numIconsUsed număr de pictograme în listă. (Dacă aţi uitat cum lista lucrarilor de feliere, verificaţi Http://invp y. com/felia.) Această listă a fost târât pe linia 139, astfel încât nu va fi întotdeauna aceleaşi pictograme fiecare joc. Apoi această listă este replicată prin utilizarea * operatorul astfel încât sunt două din fiecare dintre pictograme. Acest nou dublate lista va suprascrie lista vechi în pictograme variabilă. Din prima jumatate a acestui nou lista este identic cu ultima jumătate, vom numi aleator() din nou pentru a amesteca aleator ordinea de pictograme. Pasul 3 - Introducerea pictogramelor de pe bordul144. # crea consiliul de structură de date, cu pictograme plasate aleator.145. Bordul = []146. Pentru x în gama(BOARDWIDTH):147. Coloana = []148. Pentru y în gama(BOARDHEIGHT):149. Coloana.append(pictograme[0])

150. Del pictograme[0] # demontaţi pictograme ca noi le alocaţi 151. Bordul.append(coloană)152. Placa de retur

Acum avem nevoie de a crea o listă de liste de date structură pentru placa. Putem face acest lucru cu bucle imbricate pentru ca generateRevealedBoxesData() . Pentru fiecare coloană de pe bordul, vom crea o listă de pictograme de selectate aleatoriu. Cum vom adăuga pictograme în coloană, pe linia 149 atunci ne vom şterge din faţă al listei de pictograme de pe linia 150. Acest mod, pictogramele lista devine mai scurta si mai scurta, pictograme[0] va avea o pictogramă diferită pentru a adăuga la coloanele.

La imaginea acestui tip de mai bine, următorul cod în cochilia interactive. Observaţi cum

del declaraţie schimbă myList lista.

>>> myList = ['cat", "Dog", "ouse", "şopârlă"]


>>> del myList[0] >>> myList

['dog", "ouse", "şopârlă"]

>>> del myList[0] >>> myList

['mouse", "şopârlă"]

>>> del myList[0]

>>> myList ['şopârlă"]

>>> del myList[0]

>>> myList

[]

>>>

Deoarece suntem ştergerea elementul din faţă de pe lista, alte elemente înainte de cuplare astfel încât următorul element din lista devine noua -primul element‖. Acesta este acelaşi mod linie 150 funcţionează.

Capra de separare o listă în lista de liste155. Def splitIntoGroupsOf(groupSize, PARTEALISTĂ):156. # împarte o listă în lista de liste, unde listele de interior au la157. # majoritatea groupSize numărul de articole. 158. Rezultatul = []159. Pentru i în gama(0, len(PARTEALISTĂ), groupSize):160. Rezultatul.append(PARTEALISTĂ[i:i + groupSize])161. Rezultatul de retur

Funcţia de splitIntoGroupsOf() (care va fi numit de către startGameAnimation() ) împarte o listă în lista de liste, unde interior de liste au groupSize numărul de articole din ele. (ultima lista ar putea fi mai puţin dacă există mai puţin de articole groupSize stânga peste.)

Apelul la gamă() pe linia 159 utilizează trei-parametru sub forma de gamă() . (Dacă nu sunt familiarizati cu acest formular, să ia o privire la Http://invpy.com/range.) să utilizaţi un exemplu. Dacă lungimea lista este 20 şi groupSize parametru este 8 , apoi gamei(0, len(PARTEALISTĂ), groupSize) evaluează în gama(0, 20, 8) . Acest lucru va da i valorile 0 , variabilă 8 , şi 16 pentru cele trei multor serii de pentru buclă.

Lista de feliere pe linia 160 cu partealistă[i:i + groupSize] creează liste că sunt adăugate la lista de rezultate. Pe fiecare iteraţie unde i este 0 , 8 , şi 16 (şi groupSize este de 8 ), această listă expresia de feliere ar fi partealistă[0:8] , apoi partealistă[8:16] de pe a doua iteratii, şi apoi partealistă[16:24] în a treia iteraţie.


Reţineţi că deşi cea mai mare index de partealistă ar fi 19 în exemplu nostru, PARTEALISTĂ[16:24] nu va ridica o eroare IndexError deşi 24 este mai mare decât 19 . Acesta va crea o listă secţiunii cu restul de elemente din listă. Listă pentru feliere nu distruge sau modifica lista originală stocate în partealistă . Doar copii o parte a sa de a evalua la o lista noua valoare. Această listă nouă valoare este lista care este adăugat la lista de rezultatul variabilei pe linia 160. Astfel încât atunci când vom duce la sfârşitul această funcţie, suntem o listă de liste.

Diferitele sisteme de coordonate164. Def leftTopCoordsOfBox(boxx, patrat):165. # Converti coordonatele la pixel coordonatele plăcii166. Stânga = boxx * (BOXSIZE + GAPSIZE) + XMARGIN167. Sus = patrat * (BOXSIZE + GAPSIZE) + YMARGIN168. Retur (stânga, sus)

Trebuie să vă familiarizaţi cu sistemele de coordonate carteziene. (Dacă doriţi o perfecţionare pe acest subiect, citiţi Http://invp y .com/coordonatele.) În cele mai multe dintre jocurile noastre vom fi folosind mai multe sisteme de coordonate carteziene. Un sistem de coordonate care este utilizat în memorie joc de puzzle este de pixel sau coordonate de ecran. Dar ne va fi de asemenea folosind un alt sistem de coordonate pentru casete. Acest lucru este pentru ca va fi mai usor de

utilizat (3, 2) să consultaţi caseta de a 4 a de la stânga şi a 3 a din partea de sus (Reţineţi că numerele de start cu 0, nu 1) în loc să utilizaţi caseta de coordonate de pixeli, colţul din stânga sus, (220, 165). Totuşi, avem nevoie de un mod de a traduce între aceste două sisteme de coordonate. Aici este o imagine de joc şi cele două sisteme de coordonate diferite. Reţineţi că fereastra este de 640 pixeli latime si de 480 pixeli inaltime, astfel încât (639, 479) este în colţul din dreapta jos (deoarece colţul stânga sus pixel este (0, 0), si nu (1, 1)).


Funcţia de leftTopCoordsOfBox() va lua coordonatele de caseta şi retur pixel coordonatele. Pentru ca o cutie ocupă mai multe pixelii de pe ecran, întotdeauna vom reveni singur pixel în colţul din stânga sus al casetei. Această valoare va fi returnat ca un număr întreg de tuple. LeftTopCoordsOfBox de(), de multe ori va fi utilizat atunci când avem nevoie de pixel coordonatele pentru trasarea aceste cutii.

Convertirea de la Pixel coordonate pentru coordonatele de cutie171. Def getBoxAtPixel(x, y):172. Pentru boxx în gama(BOARDWIDTH):173. Pentru designerilor în gama(BOARDHEIGHT):174. Stânga, sus = leftTopCoordsOfBox(boxx, patrat)175. BoxRect = pygame.Rect(stânga, sus, BOXSIZE, BOXSIZE)176. Dacă boxRect.collidepoint(x, y):177. retur (boxx, patrat)178. Retur (Nici unul, nici una)

Vom avea nevoie de asemenea de o funcţie pentru a converti de pixel coordonate (care clicuri de mouse şi mişcarea mouse evenimente utilizare) pe coordonatele de caseta (astfel încât putem afla peste care caz petrecut în caseta mouse-ului). Rect obiecte au o collidepoint() că puteţi trece coordonatele X şi Y prea şi acesta va reveni Adevărat dacă coordonatele sunt în interiorul (de coliziune cu) Rect obiect zona lui.



Pentru a afla care sunt coordonatele de mouse caseta de peste, vom merge prin fiecare rubrica coordonatelor şi apelaţi collidepoint() pe un obiect de Rect cu cele coordonate. Când collidepoint() revine adevarat , stim noi am găsit caseta care a fost executat clic pe sau deplasat deasupra şi va reveni la rubrica coordonatele. Dacă nici unul din ei reveni adevarat , apoi a getBoxAtPixel() va reveni la valoarea (Nici unul, nici una) . Acest tuple este returnat în loc de pur şi simplu returnarea nici unul pentru ca apelantul în getBoxAtPixel() este asteptat la o tuple de două valori pentru a fi returnat.

Desenul pictograma şi zahăr Syntactic181. Def drawIcon(forma, culoare, boxx, patrat):

182. Sfert = int(BOXSIZE * 0.25) # syntactic zahăr 183. Jumătate = int(BOXSIZE * 0,5) # syntactic zahăr

184.185. Stânga, sus = leftTopCoordsOfBox(boxx, patrat) # obţine de la bordul coords coords pixel

Funcţia de drawIcon() va atrage o pictogramă (cu formă şi culoare ) în spaţiu ale caror coordonate sunt date în boxx şi parametrii de voluminoase. Fiecare formă posibil are un set diferit de funcţia de desen Pygame apeluri pentru ea, deci trebuie să aibă un set mare de dacă şi elif declaratii pentru a face deosebirea între ele. (aceste declaraţii sunt de pe liniile 187 la 198.)

Coordonatele X şi Y din stânga şi marginea de sus a casetei poate fi obţinută prin apelarea leftTopCoordsOfBox() . Lăţimea şi înălţimea casetei sunt setate în BOXSIZE constantă. Cu toate acestea, multe dintre forma funcţia de desen utilizarea apeluri în punctul de mijloc şi un sfert de punct de caseta precum. Putem calcula această şi depozitaţi în variabile trimestru şi jumătate . Am putea la fel de usor au cod int(BOXSIZE * 0,25) în loc de variabila sfert , dar acest fel codul devine mai uşor de citit deoarece este mai evident ce sfert reprezinta mai degraba decat int(BOXSIZE * 0.25) .

Aceste variabile sunt un exemplu de syntactic zahăr. Syntactic zahărul este atunci când vom adăuga codul care ar fi fost scris în alt mod (probabil cu mai puţin reale de cod şi variabile), dar nu face codul sursă mai uşor de citit. Variabilele sunt constante de o forma de syntactic zahăr. Pre-calcularea unei valori şi de stocare într-o variabilă este un alt tip de zahar syntactic. (De exemplu, în getRandomizedBoard() , am putea fi făcută cu uşurinţă codul de pe liniile 140 şi linia 141 într-o singură linie de cod. Dar e mai uşor de citit ca două linii separate.) nu avem nevoie de a avea extra trimestru şi jumătate variabile, dar le face codul mai uşor de citit. Cod care este uşor de citit este uşor de depanare şi upgrade în viitor.

186. # Trage forme187. Dacă forma ==

GOGOAŞĂ:


188. Pygame.intocmeste.cerc(DISPLAYSURF, culoare, (stânga + jumătate, sus + jumatate),Jumătate - 5)

189. Pygame.intocmeste.cerc(DISPLAYSURF, BGCOLOR, (stânga + jumătate, sus + jumatate), sfert - 5)190. Forma elif == SQUARE:

191. Pygame.intocmeste.rect(DISPLAYSURF, culoare, (stânga + sfert, sus + sfert, BOXSIZE - jumatate, BOXSIZE - jumatate))192. Forma elif == DIAMOND:

193. Pygame.intocmeste.liniei poligonale(DISPLAYSURF, culoare, ((stânga + jumătate, sus), (stânga + BOXSIZE - 1, sus + jumatate), (stânga + jumătate, sus + BOXSIZE - 1, stânga, sus + jumatate)))194. Forma elif == linii:195. Pentru i în gama(0, BOXSIZE, 4):196. Pygame.intocmeste.linie(DISPLAYSURF, culoare, (stânga, sus + (i), (stânga +I, partea superioară))

197. Pygame.intocmeste.linie(DISPLAYSURF, culoare, (stânga + i, sus + BOXSIZE - 1), (stânga + BOXSIZE - 1, sus + i))198. Forma elif == OVAL:

199. Pygame.intocmeste.elipsă(DISPLAYSURF, culoare, (stânga, sus + sfert, BOXSIZE, jumatate))

Fiecare gogoaşă, pătrat, diamond, linii, şi funcţiile oval necesita diferite desen primitiv de a face apeluri cu funcţia.

Syntactic zahăr cu obţinerea un spaţiu de placa de pictograma lui de formă şi culoare202. Def getShapeAndColor(bord, boxx, patrat):203. # forma valoarea pentru x, y la faţa locului este memorat în bord [x][y][0]204. # Culoarea valoarea pentru x, y la faţa locului este memorat în bord [x][y][1]205. Placa de retur[boxx][designerilor][0][boxx placa][designerilor][1]

Funcţia de getShapeAndColor() are numai o singură linie. Ai putea intreba de ce am vrea o funcţie în loc de doar de introducerea de text în care o singură linie de cod ori de câte ori am nevoie. Aceasta se face pentru acelaşi motiv vom utiliza variabilele constantă: îmbunătăţeşte lizibilitatea cod.

Este uşor să aflăm de ce un cod ca forma, culoare = getShapeAndColor() . Dar dacă aţi privi un cod ca forma, culoare = bordul[boxx][designerilor][0] [boxx placa][designerilor][1] , ar fi un pic mai greu pentru a figura în afară.

Capacul cutiei de desen208. Def drawBoxCovers(bord, cutii, acoperire):209. # Trage lăzi acoperite/dezvaluit. - rubricile" este o listă210. # de două liste de element, care au x şi y fata locului din cutie.211. Pentru rubrica in cutii:


212. Stânga, sus = leftTopCoordsOfBox(box[0], box[1])213. Pygame.intocmeste.rect(DISPLAYSURF, BGCOLOR, (stânga, sus, BOXSIZE,BOXSIZE))214. Forma, culoare = getShapeAndColor(bord, rubrica[0], box[1])215. DrawIcon(forma, culoare, box[0], box[1])

216. Dacă > 0 de acoperire: # capacul numai dacă există o acoperire 217. Pygame.intocmeste.rect(DISPLAYSURF, BOXCOLOR, (stânga, sus, acoperire,BOXSIZE))218. Pygame.afişaj.actualizare()219. FPSCLOCK.tick(FPS)

Funcţia de drawBoxCovers() are trei parametri: Consiliul de structură de date, o lista a (X, Y) tuples pentru fiecare cutie care ar fi capacul elaborate şi apoi suma de acoperire pentru a desena pentru casete.

Pentru că ne dorim să folosiţi acelaşi cod de desen pentru fiecare cutie în casetele de parametru, vom utiliza o buclă de pe linia 211 astfel încât ne execute acelaşi cod de pe fiecare cutie în casetele listă. În interiorul acestui pentru , buclă codul trebuie sa faca trei lucruri: Desenaţi culoarea de fundal (a vopselei peste ceva care era acolo înainte), desenaţi pictograma, apoi trasaţi totusi mult de pe caseta albă peste pictograma de care este nevoie. Funcţia de leftTopCoordsOfBox() va reveni coordonatele punctelor de colţul din stânga sus al casetei. Declaratia de pe linia de dacă 216 asigură că dacă numărul de acoperire se întâmplă să fie mai mică de 0 , nu vom apela pygame.intocmeste.rect() .

Când parametrul este de acoperire 0 , nu există acoperire la toate. Când este setat la acoperire

20 , există o 20 pixel caseta albă largă acoperind pictograma. Cea mai mare dimensiune veţi dori să setaţi de acoperire este numărul în BOXSIZE , unde toată pictograma este complet acoperită.

DrawBoxCovers() va fi numit de la o buclă separată decât jocul buclă. Din aceasta cauza, are nevoie de a avea propriile apeluri la pygame.afişaj.actualizare() şi FPSCLOCK.tick(FPS) pentru a afişa animaţia. (Aceasta nu înseamnă că în timp ce în interiorul această buclă, nici un cod nu este executat pentru a trata orice evenimente fiind generate. Ca e bine, deoarece capacul şi dezvăluie numai un animaţii sau astfel încât să joace.)

Manipularea dezvaluiri si acoperind animaţie222. Def revealBoxesAnimation(boxesToReveal placa):223. # face caseta "dezvăluie" animaţie.224. Pentru acoperirea în gama(BOXSIZE, (-REVEALSPEED) - 1, - REVEALSPEED):225. Placa drawBoxCovers(, boxesToReveal, acoperire)226.227.228. Def coverBoxesAnimation(boxesToCover placa):

229. # face - capac cutie de animaţie".


230. Pentru gama de acoperire în alin. 0, BOXSIZE + REVEALSPEED, REVEALSPEED):231. Placa drawBoxCovers(, boxesToCover, acoperire)

Nu uitaţi că o animaţie este pur şi simplu doar afişarea de imagini diferite pentru scurte momente de timp şi, împreună, crea impresia că lucrurile sunt în mişcare de pe ecran. La revealBoxesAnimation() şi coverBoxesAnimation() trebuie numai să atragă o pictogramă cu o acoperire de variabil de pe caseta albă. Poate scrie o singură funcţie numită drawBoxCovers() care pot face acest lucru şi apoi au animaţia noastră apelul funcţiei drawBoxCovers() pentru fiecare cadru de animaţie. Asa cum am vazut in ultima secţiune, drawBoxCovers() face un apel la pygame.afişaj.actualizare() şi FPSCLOCK.tick(FPS) în sine.

Pentru a face acest lucru, vom configura o buclă pentru a face scăderea (în cazul revealBoxesAnimation() ) sau creşterea (în cazul coverBoxesAnimation() ) numerele furnizorului de parametru. Suma de acoperire variabilă va scădea/creşte prin este numărul în REVEALSPEED constantă. Pe linia 12 am stabilit această constantă la 8 , in sensul ca pe fiecare apel la drawBoxCovers() , caseta albă va scădea/creşte cu 8 pixeli pe fiecare iteraţie. Dacă vom creşte acest număr, apoi mai mulţi pixeli va fi trasată pe fiecare apel, in sensul ca pe caseta albă va scădea/creştere în mărime mai repede. Dacă am setat la 1 , apoi pe caseta albă va apărea numai pentru a reduce sau creşte de 1 pixel de pe fiecare iteraţie, întregul dezvăluie sau acoperiţi animaţie ia mai.

Gandesc ca urcatul scarilor. Dacă pe fiecare pas vă luaţi, vă urca una treapta, atunci ar lua o perioada de timp normală pentru a urca scara intreaga. Dar dacă vă urcă scările două o dată la fiecare pas (şi paşii au luat doar cât timp înainte), ai putea să urce scara intreaga de două ori mai rapid. Dacă aţi putea să urce scara 8 scara la un timp, atunci ai sa urce scara intreaga de 8 ori mai repede.

Desenul intregul consiliu de administratie234. Def drawBoard(, dezvăluit plăcii):235. # Trage toate rubricile in acoperite sau arătat stat.236. Pentru boxx în gama(BOARDWIDTH):237. Pentru designerilor în gama(BOARDHEIGHT):238. Stânga, sus = leftTopCoordsOfBox(boxx, patrat)239. Dacă nu este arătat[boxx][designerilor]:240. # Trage o acoperite caseta.

241. Pygame.intocmeste.rect(DISPLAYSURF, BOXCOLOR, (stânga, sus, BOXSIZE, BOXSIZE))242. Altceva:243. # Trage (arătat) pictograma.244. forma, culoare = getShapeAndColor(bord, boxx, patrat)



245. drawIcon(forma, culoare, boxx, patrat)

Funcţia de drawBoard() face un apel la drawIcon() pentru fiecare dintre casetele de pe placa. Pentru bucle imbricate de pe liniile 236 şi 237 va în buclă la fiecare posibil X şi coordonata Y pentru cutii, si fie va elabora pictograma de la acea locaţie sau desenaţi un pătrat în loc de alb (de a reprezenta o acoperite cutie).

Trasarea evidenţiaţi248. Def drawHighlightBox(boxx, patrat):249. Stânga, sus = leftTopCoordsOfBox(boxx, patrat)

250. Pygame.intocmeste.rect(DISPLAYSURF, HIGHLIGHTCOLOR, (stânga - 5, partea superioară - 5, BOXSIZE + 10, BOXSIZE + 10), 4)

Pentru a ajuta jucătorul recunoaşte că acestea pot face clic pe o casetă pentru a dezvălui acoperite, vom face un contur albastru în jurul unei apar caseta pentru a o evidenţia. Aceasta schita este trasată cu un apel la pygame.intocmeste.rect() pentru a face un dreptunghi cu o lăţime de 4 pixeli.

"Start joc" Animaţie253. Def startGameAnimation(bord):254. # aleatoriu dezvăluie casetele de 8 la un moment dat.255. CoveredBoxes = generateRevealedBoxesData(Fals)256. Rubricile = []257. Pentru x în gama(BOARDWIDTH):258. Pentru y în gama(BOARDHEIGHT):259. Rubricile.append( (x, y) )260. Random.aleator(cutii)261. BoxGroups = splitIntoGroupsOf(8, cutii)

Animaţia care redă la începutul jocului dă player rapid o idee unde toate pictogramele sunt situate. Pentru a face această animaţie, avem de a dezvălui şi capacul grupuri de cutii de un grup după un alt. Pentru a face acest lucru, mai întâi vom crea o listă de fiecare spaţiu de pe placa. Pentru bucle imbricate de pe liniile 257 şi 258 va adăuga (X, Y) tuples la o listă în casetele de variabilă.

Vom dezvălui şi capacul până la prima 8 cutii în această listă, apoi următoarea 8, apoi următoarea 8 după asa si pe. Totuşi, deoarece ordinea (X, Y) tuples în cutii ar fi acelaşi de fiecare dată, apoi aceeaşi ordine de cutii va fi afişat. (Încercaţi comentând linie 260 şi apoi pornit la program de câteva ori pentru a vedea acest efect.)

Pentru a schimba casetele de fiecare dată de un joc începe, vom apela la

întâmplare.aleator() la întâmplare aleator ordinea tuples în casetele listă. Atunci când vom dezvălui şi capacul în sus


Primele 8 cutii în această listă (şi fiecare grup de 8 cutii ulterior), va fi aleatorie grup de 8 cutii.

Pentru a obţine listele de 8 cutii, noastre splitIntoGroupsOf() , trecând 8 şi lista in cutii . Lista de liste ca funcţia revine vor fi stocate în o variabilă numită boxGroups .

Dezvaluiri si acoperind grupuri de cutii263. Placa drawBoard(, coveredBoxes)264. Pentru boxGroup în boxGroups:265. Placa revealBoxesAnimation(, boxGroup)266. Placa coverBoxesAnimation(, boxGroup)

Prima, ne trage placa. Deoarece fiecare valoare în coveredBoxes este setat la , acest apel la false drawBoard() va termina trasarea acoperită numai până cutii albe. La revealBoxesAnimation() şi coverBoxesAnimation() funcţii vor elabora peste spaţiile dintre aceste cutii albe.

Buclă pentru a va trece prin fiecare din listele de interior în listele boxGroups. Ne trece de aceste la revealBoxesAnimation() , care va efectua animaţia de cutii albe tras inapoi pentru a dezvălui pictograma de dedesubt. Apoi apelul la coverBoxesAnimation() va animaţi de cutii albe pentru extinderea acoperirii pictograme. Apoi se stinge cu buclă pentru la următoarea iteraţie să realizaţi animaţii următorul set de 8 cutii.

"Joc câştigat" Animaţie269. Def gameWonAnimation(bord):270. # flash de culoare de fundal când player a câştigat271. CoveredBoxes = generateRevealedBoxesData(adevarat)272. Culoare1 = LIGHTBGCOLOR273. Culoare2 = BGCOLOR274.275. Pentru i în gama(13):

276. Culoare1, culoare2 = culoare2, culoare1 # Culorile swap 277. DISPLAYSURF.umpleţi(culoare1)278. Placa drawBoard(, coveredBoxes)279. Pygame.afişaj.actualizare()280. Pygame.timp.aşteptaţi(300)

Când player a fără capac toate rubricile de aliniere la fiecare pereche de pe bord, vrem să le felicite prin clipirea culoarea de fundal. Buclă pentru a va trage pe culoare în culoarea 1 variabilă pentru culoarea de fundal şi apoi trasaţi bordul peste ea. Cu toate acestea, pe fiecare bucla de iteraţie pentru, valorile în culori1 şi culoare2 va fi interschimbate cu fiecare alte



Pe linia 276. Acest mod de programul va alterna între cele două diferite culori de fundal de desen.

Reţineţi că această funcţie trebuie să apelaţi pygame.afişaj.actualizare() pentru a face chiar la suprafaţa DISPLAYSURF apar pe ecran.

Spune dacă Jucătorul a câştigat283. Def hasWon(revealedBoxes):284. # Revine Adevărat dacă toate casetele au fost dezvăluit, în caz contrar fals285. Pentru i în revealedBoxes:286. Dacă falsă în i:

287. Retur # false de retur de fals dacă toate casetele sunt acoperite. 288. Adevarat de retur

Jucătorul a câştigat jocul când toate pictograma de perechi au fost alese. Deoarece -arătat‖ structura datelor primeste valorile în ea setată la adevarat ca simboluri au fost împerecheate, putem pur şi simplu în buclă la fiecare spaţiu în revealedBoxes caută o valoare false. Dacă valoarea este falsă chiar una în revealedBoxes , apoi ştim există încă de neegalat pictograme de pe placa.

Reţineţi că deoarece revealedBoxes este o listă de liste, buclă pentru pe linia 285 va seta Lista de interior ca valorile i . Dar putem utiliza în operator pentru a căuta o valoare false în întreaga listă de interior. In acest fel nu avem nevoie de a scrie o linie suplimentară de cod şi au două bucle imbricate pentru ca aceasta:

Pentru x în revealedBoxes: Pentru y în revealedBoxes [x]:

Dacă revealedBoxes false ==[X][y]:

retur fals

De ce deranjez având un principal() ?291. Dacă __name__ == "__main__":292. Principalele()

Pare inutil sa aiba un principal() , deoarece aţi putea pune doar ca organ în domeniul global de la partea inferioară a programului în loc şi cod va rula exact acelaşi. Cu toate acestea, există două motive bune pentru a le pune în interiorul de un principal() .

Prima, aceasta vă permite să aibă variabilelor locale întrucât altfel variabilele locale în principalele() ar trebui sa devina variabile globale. Limitarea numărului de variabile globale este o modalitate bună de a păstra codul de simplă şi mai uşor de depanare. (Consultaţi -De ce Variabile globale sunt rele‖ secţiunea în acest capitol.)


Al doilea, aceasta vă permite de asemenea să importe programul astfel încât să puteţi suna şi test funcţii individuale. Dacă memorypuzzle.py fişier este în C:\Python32 dosar, apoi puteţi importa din coaja interactive. Tastaţi următorul test afară splitIntoGroupsOf() şi getBoxAtPixel() funcţii pentru a reveni la valorile de retur corectă:

>>> import memorypuzzle

>>> memorypuzzle.splitIntoGroupsOf(3), [0,1,2,3,4,5,6,7,8,9])

[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]] >>> memorypuzzle.getBoxAtPixel(0, 0).

(Nici unul, nici una)

>>> memorypuzzle.getBoxAtPixel(150, 150) (1, 1)

Când un modul este importat, toate in cod. Dacă nu am fi principalele() , şi avea codul său în domeniul global, apoi jocul ar fi automat imediat ce am importat, care de fapt nu ar să ne apelaţi funcţiile individuale în ea.

De aceea, codul este în funcţie separată ca am numit principalele() . Apoi vom verifica încorporată Python variabila __name__ pentru a vedea dacă ar trebui să principalele() sau nu. Această variabilă este setată automat de către Python interpret de string '__main__" dacă Programul însuşi este executat şi 'memorypuzzle" dacă este importate. De aceea principalele() nu este executată când am executat memorypuzzle declaratia de import în cochilia interactive.

Aceasta este o tehnica de la îndemână pentru a putea importa program lucraţi pe din coaja interactive şi asiguraţi-vă că funcţiile individuale care se intoarce la valorile corecte prin testarea lor un apel la un moment dat.

De ce deranjez cu lizibilitate îmbunătăţită?O mulţime de sugestii în acest capitol nu au fost despre cum să scrie programe care calculatoare pot rula atât de mult ca cum să scrie programe care programatorii pot citi. Este posibil să nu intelege de ce este important. După toate, atât timp cât codul lucrări, cui ii pasa daca este greu sau uşor pentru programatori pentru a citi? umane

Cu toate acestea, singurul lucru important de a da seama despre software este că aceasta este rareori singur vreodata. Când creaţi propriile jocuri, rareori va fi -adoptată‖ cu programul. Veţi obţine întotdeauna idei noi pentru joc caracteristici doriţi adăugarea, sau gasim noi bugs cu programul. Din aceasta cauza, este important ca programul dumneavoastră este lizibil, astfel încât vă puteţi uita la cod si o inteleg. Şi de înţelegere a codului este primul pas pentru a o modifica pentru a adăuga mai multe cod sau repara bug.

Ca un exemplu, aici este o baza obfuscated versiune a programului care era de puzzle memorie făcute în întregime de necitit. Dacă introduceţi în (sau descărca de


Http://invpy.com/memorypuzzl e _baza obfuscated.p y ) şi veţi găsi se ruleaza exact ca şi codul de la începutul acestui capitol. Dar dacă ar exista un bug cu acest cod, ar fi imposibil să citiţi codul si intelege ce se intimpla, mult mai repara bug.

Calculatorul nu minte drept cod de necitit ca aceasta. Este acelasi lucru.

Import, pygame aleatorie, sys De la pygame.localnicii import *

Def hhh(): Global a, b Pygame.init() A = pygame.timp.Ceas() B = pygame.afişaj.set_mode((640, 480)) J = 0 K = 0 Pygame.afişaj.set_Titlul(Litiu-Ion fără "Joc") I = c() Hh = d(Fals) H = None B.umpleţi((60, 60, 100)) G(i)) În timp ce adevarat:

E = fals B.umpleţi((60, 60, 100)) F(i, hh) Pentru eee in pygame.caz.obţineţi():

Dacă eee.tip == QUIT sau (eee.tip == KEYUP şi eee.== K_IASĂ): Pygame.quit() Sys.exit()

Elif eee.tip == MOUSEMOTION: J, K = eee.pos

Elif eee.tip == MOUSEBUTTONUP: J, K = eee.pos E = adevărat

Bb, ee = m(j, k) Dacă bb != nici unul şi ee != fără:

Dacă nu hh[bb][ee]: N(bb, ee)

Dacă nu hh[bb][ee] şi e: O(i, [(bb, ee)]) Hh[bb][ee] = adevărat Dacă h == fără:

H = (bb, ee) Altceva:

Q, fff = s(i, h[0], h[1]) r, ggg = s(i, bb, ee)


Dacă q != r sau fff != ggg: Pygame.timp.aşteptaţi(1000) P(i, [(h[0], h[1]), (bb, ee)]) Hh[h[0]][h[1]] = fals Hh[bb][ee] = fals

Elif ii(hh): Jj(i)) Pygame.timp.aşteptaţi (2000) I = c() Hh = d(Fals) F(i, hh) Pygame.afişaj.actualizare() Pygame.timp.aşteptaţi(1000) G(i))

H = None Pygame.afişaj.actualizare() O.tick(30)

Def d(cvc): Hh = [] Pentru i în gama(10):

Hh.append ([cvc] * 7) Reveni hh

Def c(): Rr = [] Pentru tt în ((255, 0, 0), 0, 255, 0), (0, 0, 255), (255, 255, 0, 255, 128,

0), 255, 0, 255), (0, 255, 255)): Pentru ss în ('a', "b", "c", "d", "e"):

Rr.append( (SS, tt) ) Random.Shuffle (RR) Rr = rr[:35] * 2 Random.Shuffle (RR) Bbb = [] Pentru x în gama(10):

V = [] Pentru y în gama(7):

V.append(rr[0]) Del rr[0]

Bbb.append(v) Reveni bbb

Def t(vv, uu): Ww = [] Pentru i în gama(0, len(uu), vv):

Ww.append(uu[i:i + vv]) Reveni ww

Def aa bb, ee):

Retur (bb * 50 + 70, ee * 50 + 65) def m(x, y):



Pentru bb în gama(10): Pentru ee în gama(7):

Oo, ddd = aa bb, ee) Aaa = pygame.Rect(oo, ddd, 40, 40) Dacă aaa.collidepoint(x, y):

Retur (bb, ee) Retur (Nici unul, nici una)

Def w(ss, tt, bb, ee): Oo, ddd = aa bb, ee) Dacă ss == "a":

Pygame.intocmeste.cerc(b, tt (oo + 20, ddd + 20), 15) Pygame.intocmeste.cerc(b, 60, 60, 100), (oo + 20, ddd + 20), 5)

Elif ss == "b": Pygame.intocmeste.rect(b, tt (oo + 10, ddd + 10, 20, 20))

Elif ss == de "c": Pygame.intocmeste.liniei poligonale(b, tt, ((oo + 20, ddd), (oo + 40 - 1, ddd + 20),

(oo + 20, ddd + 40 - 1), (oo, ddd + 20))) Elif ss == 'D':

Pentru i în gama(0, 40, 4): Pygame.intocmeste.linie(b, tt (oo, ddd + (i), (oo + i, ddd)) Pygame.intocmeste.linie(b, tt (oo + i, ddd + 39), (oo + 39, ddd + i))

Elif ss == "e": Pygame.intocmeste.elipsă(b, tt (oo, ddd + 10, 40, 20))

Def s(bbb, bb, ee): Reveni bbb[bb][ee][0], bbb[bb][ee][1]

Def dd(bbb, cutii, gg): Pentru rubrica in cutii:

Oo, ddd = aa(box[0], box[1]) Pygame.intocmeste.rect(b, 60, 60, 100), (oo, ddd, 40, 40)) Ss, Tt = s(bbb, box[0], box[1]) W(ss, tt, box[0], box[1]) Dacă gg > 0:

Pygame.intocmeste.rect(b, (255, 255, 255), (oo, ddd, gg, 40)) Pygame.afişaj.actualizare() O.tick(30)

Def o(bbb, cc): Pentru gg în gama(40, (-8) - 1, -8):

Dd(bbb, cc, gg)

Def p(bbb, ff): Pentru gg în gama(0, 48, 8):

Dd(bbb, ff, gg)

Def f(bbb, pp): Pentru bb în gama(10):

Pentru ee în gama(7): Oo, ddd = aa bb, ee) Dacă nu pp[bb][ee]:

Pygame.intocmeste.rect(b, (255, 255, 255), (oo, ddd, 40, 40))


Altceva: Ss, Tt = s(bbb, bb, ee) W(ss, tt, bb, ee)

Def n(bb, ee): Oo, ddd = aa bb, ee) Pygame.intocmeste.rect(b, (0, 0, 255), (oo - 5, ddd - 5, 50, 50), 4)

Def g(bbb): Mm = d(Fals) Rubricile = [] Pentru x în gama(10):

Pentru y în gama(7): Rubricile.append( (x, y) )

Random.aleator(cutii) Kk = t(8, cutii) F(bbb, mm) Pentru nn in kk:

O(bbb, nn) P(bbb, nn)

Def jj(bbb): Mm = d(adevarat) Tt1 = (100, 100, 100) Tt2 = (60, 60, 100) Pentru i în gama(13):

Tt1, TT2 = TT2, TT1 B.umpleţi(TT1) F(bbb, mm) Pygame.afişaj.actualizare() Pygame.timp.aşteptaţi(300)

Def ii(hh): Pentru i în hh:

Dacă falsă în i: Fals de retur

Adevarat de retur

Dacă __name__ == "__main__": hhh()

Niciodată nu scrie codul ca aceasta. Dacă program ca acest, cu fata la oglinda din baie cu lămpile de poziţie stinse, fantoma de Ada Lovelace vor veni din oglinda si te arunca în ghearele unui Jacquard asociat.

Sumar şi o sugestie de hackingAcest capitol acoperă întreaga explicaţie privind modul de memorie Puzzle programul funcţionează. Cititi capitolul şi codul sursă din nou pentru a intelege mai bine. Multe din alte programe de joc în această carte face uz de acelaşi conceptele de programare (ca procesul de nesting pentru bucle, syntactic zahăr,



Şi diferite sisteme de coordonate in acelasi program) astfel încât să nu fi explicat din nou pentru a păstra această carte scurtă.

O idee de a încerca pentru a înţelege cum funcţionează de cod este de a intenţionat limită prin comentarea liniilor aleatorii. Acest fel de unele din liniile probabil va cauza o eroare de syntactic că va împiedica script de pornit la toate. Dar comentând în alte linii va rezulta în chip ciudat bug-uri şi alte efecte interesante. Încercaţi să faceţi aceasta şi apoi figura de ce un program are plosnite are.

Este şi primul pas în posibilitatea de a adăuga propriile secret trucuri sau de hacking de program. Prin incalcarea programului din ce în mod normal nu puteţi învăţa cum să o schimbe ceva ordonat efect (ca în secret care vă sfaturi despre cum să rezolve puzzle). Nu ezitaţi să experimentaţi. Puteţi să salvaţi întotdeauna o copie a codului sursă neschimbate în alt fişier dacă doriţi să redaţi din nou joc regulat.

De fapt, dacă doriţi câteva practici de stabilire bug-uri, există mai multe versiuni de acest joc e codul sursă pe care au mici bug-uri în ele. Puteţi descărca versiuni de Http://invpy.com/buggy/memorypuzzle. aceste cărucior Încercaţi rularea programului pentru a intelege ce se bug este şi ce program actioneaza ca mod.

ionut-py

Documents

Transcript of ionut-py