Cum să programați jocurile pe Python folosind Biblioteca Pygame

Acest articol este destinat celor care sunt deja familiarizați cu limba de programare Python și vă permite să citiți Biblioteca Pygame pentru această limbă. Ca exemplu vizual, aici este prezentat un proces simplu de programare a jocurilor, în care jucătorul trebuie să doneze de la bile de sărituri.

Pași

Partea 1 din 8:

Instalarea Pygame

unu. Descărcați Pygame. Urmați linkul și găsiți versiunea bibliotecii potrivită pentru platforma dvs .: http: // Pygame.Org / Descărcare.Shtml .

2. Rulați instalatorul.

3. Asigurați-vă că instalarea sa terminat cu succes. Deschideți terminalul Python. Introduceți "Importați Pygame". Dacă nu apar mesaje de eroare, atunci Pygame a fost instalat cu succes.

Importați Pygame

Partea 2 din 8:

Crearea unei ferestre principale de joc

unu. Creați un fișier nou.

2. Importați Pygame. Pygame este o bibliotecă care implementează accesul la funcțiile grafice de programare de programare Python. Dacă doriți să aflați mai multe despre modul în care funcționează aceste funcții, informațiile sunt disponibile pe Pygame. https: // Pygame.Org / docs /

Importați Pygamefrom Pygame.O localnicii Import *

3. Specificați dimensiunea ferestrei jocului. Creați o variabilă globală pentru dimensiunile ferestrelor pentru a vă referi la acestea din diferite părți ale jocului. Pentru comoditate, acești parametri sunt mai bine să specificați la începutul fișierului, astfel încât, dacă este necesar, a fost mai ușor să se schimbe în viitor. Pentru proiecte mai complexe, va fi de preferat să se facă astfel de date într-un fișier separat.

Rezoluție = (400,300)

4. Determină mai multe culori. Culorile din Pygame sunt definite în format RGBA variind de la 0 la 255. Valoarea alfa (a) poate fi omisă, dar restul culorilor (roșu, verde și albastru) sunt necesare pentru umplere.

Alb = (255,255,255) negru = (0,0,0) roșu = (255,0,0)

cinci. Inițializați ecranul principal. Utilizați variabila de rezoluție definită mai devreme.

Ecran = Pygame.Afişa.Set_mode (rezoluție)

6. Creați un ciclu al jocului. Setați repetarea anumitor acțiuni în fiecare cadru al jocului. Creați un ciclu care va efectua în mod constant toate aceste acțiuni.

În timp ce este adevărat:

7. Determinați culoarea umplerii ecranului.

Ecran.Umpleți (alb)

opt. Afișați ecranul. Dacă porniți programul în această etapă, ecranul este vopsit cu alb, iar apoi programul va opri situația de urgență. Cauza eșecului va fi că sistemul de operare trimite evenimentele programului, iar programul pur și simplu nu procedează. Când programul acumulează prea multe evenimente netratate, apare eșecul.

În timp ce este adevărat:...Pygame.Afişa.Flip ()

nouă. Implementați prelucrarea evenimentelor. Obțineți o listă cu toate evenimentele care au apărut între cadrele de desen. În exemplul nostru trebuie să vă îngrijorați procesarea unui singur eveniment de ieșire (Quit). Apare când utilizatorul închide fereastra jocului. Procesarea evenimentului va împiedica eșecul programului de la apariția prea multor evenimente.

În timp ce este adevărat:...Pentru eveniment în Pygame.Eveniment.Obțineți (): Dacă evenimentul.Tip == Quit: Pygame.părăsi ()

Imagine intitulată programpygamepart1.jpg

10. Încercați programul! Acum codul programului ar trebui să arate astfel:

Importați Pygamefrom Pygame.O localnici Import * Rezoluție = (400,300) White = (255,255,255) Black = (0,0,0) Red = (255,0,0) Ecran = Pygame.Afişa.Set_mode (rezoluție) în timp ce este adevărat: ecran.Umpleți (alb) Pygame.Afişa.Flip () pentru eveniment în Pygame.Eveniment.Obțineți (): Dacă evenimentul.Tip == Quit: Pygame.părăsi ()

Partea 3 din 8:

Crearea obiectelor de joc

unu. Creați o nouă clasă de obiecte și designerul său. Setați toate proprietățile obiectului. Definiți, de asemenea, valorile implicite pentru fiecare dintre proprietăți.

Ball Ball: Def __init __ (Self, Xpos = Rezoluție [0] / 2, YPOS = Rezoluție [1] / 2, Xvel = 1, Yvel = 1, Rad = 15): Sine.x = xposself.Y = yosself.Dx = xvelf.dy = yvelself.Radius = Radself.Tip = "Minge"

2. Determinați desenul obiectului. Utilizați proprietățile obiectului specificate în constructor pentru a portreca mingea ca un cerc de pe suprafața transmisă funcției la funcție. Suprafața va fi ecranul pe care l-ați creat mai devreme prin definirea dimensiunilor sale.

Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, negru, (sine.X, sine.y), sine.RAZĂ)

3. Creați o instanță de clasă și adăugați un loc de muncă la ciclul de joc pentru a desena o minge la fiecare iterație a ciclului.

Ball = Ball () În timp ce este adevărat:...Minge.Desenați (ecran)

4. Face ca obiectul să se miște. Creați o funcție care actualizează poziția obiectului. Apelați această caracteristică în fiecare iterație a ciclului.

Clasa Ball:...Def Update (Sine): Sine.X + = sine.Dx.Y + = sine.DY

cinci. Limitați frecvența cadrului. Mingea se va mișca foarte repede, deoarece ciclul de joc este repetat de sute de ori pe secundă. Utilizați timerul Pygame pentru a limita frecvența de schimbare a cadrului la 60 FPS.

Ceas = Pygame.Timp.Ceas () În timp ce este adevărat:...CEAS.Tick (60)

Păstrați un castron pe ecran. Adăugați verificări la funcția Actualizare stare pentru a schimba direcția de mișcare a mingii, dacă ajunge la limitele ecranului.

Clasa Ball:...Def Actualizare (sine):...dacă (de sine.X <= 0 or self.x >= Rezoluție [0]): Sine.Dx * = -1if (sine.Y <= 0 or self.y >= Rezoluție [1]): Sine.dy * = -1

Încercați programul! Acum codul programului ar trebui să arate astfel:

Imagine intitulată programpygamepart2.jpg

Importați Pygamefrom Pygame.O localnici Import * Rezoluție = (400,300) White = (255,255,255) Black = (0,0,0) Red = (255,0,0) Ecran = Pygame.Afişa.Set_mode (rezoluție) Ball Ball: Def __init __ (Self, Xpos = Rezoluție [0] / 2, Ypos = Rezoluție [1] / 2, xvel = 1, YVER = 1, Rad = 15): Sine.x = xposself.Y = yosself.Dx = xvelf.dy = yvelself.Radius = Radself.Tip = "Minge"Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, negru, (sine.X, sine.y), sine.RADIUS) DEF Actualizare: Sine.X + = sine.Dx.Y + = sine.Dyif (sine.X <= 0 or self.x >= Rezoluție [0]): Sine.Dx * = -1if (sine.Y <= 0 or self.y >= Rezoluție [1]): Sine.dy * = -1ball = minge () ceas = pygame.Timp.Ceas () În timp ce este adevărat: ecran.Mingea de umplere (alb).Remiză (ecran) mingea.Actualizați () Pygame.Afişa.Flip () ceas.Bifați (60) pentru eveniment în Pygame.Eveniment.Obțineți (): Dacă evenimentul.Tip == Quit: Pygame.părăsi ()

Partea 4 din 8:

Structurarea jocurilor

unu. Utilizați clase de structurare. În viitor, jocul va deveni mai complex. Utilizați tehnici de programare orientate pe obiecte pentru a structura codul.

2. Conversia ciclului de joc în clasă. Din moment ce jocul include deja date, inclusiv obiecte și funcții de joc, este logic să înlocuiți ciclul de joc în clasă.

Joc de clasă ():

3. Adăugați designerul. Cu aceasta, vă refuzați mai multe obiecte folosite în joc, creați un ecran, cronometru și inițializați Pygame. Pygame trebuie inițializată pentru a utiliza în continuare astfel de capabilități ca text sau sunet.

Joc de clasă (): def __init __ (sine): Pygame.IN SINEA LUI.Ecran = Pygame.Afişa.Set_mode (rezoluție) sine.Ceas = Pygame.Timp.Ceas ()

4. Setați prelucrarea evenimentelor în funcție.

Joc de clasă ():...Def Galerievents (Sine): Pentru eveniment în Pygame.Eveniment.Obțineți (): Dacă evenimentul.Tip == Quit: Pygame.părăsi ()

cinci. Faceți un ciclu de joc cu o funcție. Funcția de procesare a evenimentului apelurilor în fiecare iterație a ciclului.

Joc de clasă ():...Def run (sine): în timp ce este adevărat: sine.Gândiți-vă () de sine.Ecran.Umpleți (alb) de sine.CEAS.Tick (60) Pygame.Afişa.Flip ()

6. Setați prelucrarea obiectelor multiple de joc. În acest stadiu, codul de joc determină o actualizare și redredire a obiectelor individuale în fiecare cadru. Cu această abordare, codul jocului va fi destul de voluminos și dezordonat, mai ales dacă există multe obiecte în joc. Este mai înțelept să adăugați mai întâi obiecte într-o matrice, apoi să actualizați și să reproduceți toate obiectele din matricea la fiecare iterație a ciclului. Acum puteți face cu ușurință un obiect nou în joc și determinați o altă poziție de pornire pentru aceasta.

Joc de clasă (): def __init __ (auto):...De sine.GameObjects = [] sine.GameObjects.Apend (minge ()).GameObjects.Apend (mingea (100))...Def run (sine): în timp ce este adevărat: sine.Galerievents () pentru Gameobj în sine.GameObjects: Gameobj.Actualizați () Sine.Ecran.Umple (alb) pentru gameobj în sine.GameObjects: Gameobj.Trage (sine.Ecran) de sine.CEAS.Tick (60) Pygame.Afişa.Flip ()

Imagine intitulată programpygamepart3.jpg

7. Încercați programul! Acum codul programului ar trebui să arate astfel:

Importați Pygamefrom Pygame.O localnici Import * Rezoluție = (400,300) White = (255,255,255) Black = (0,0,0) Red = (255,0,0) Ecran = Pygame.Afişa.Set_mode (rezoluție) Ball Ball: Def __init __ (Self, Xpos = Rezoluție [0] / 2, Ypos = Rezoluție [1] / 2, xvel = 1, YVER = 1, Rad = 15): Sine.x = xposself.Y = yosself.Dx = xvelf.dy = yvelself.Radius = Radself.Tip = "Minge"Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, negru, (sine.X, sine.y), sine.RADIUS) DEF Actualizare: Sine.X + = sine.Dx.Y + = sine.Dyif (sine.X <= 0 or self.x >= Rezoluție [0]): Sine.Dx * = -1if (sine.y <= 0 or self.y >= Rezoluție [1]): Sine.DY * = -1Class joc (): def __init __ (sine): Pygame.IN SINEA LUI.Ecran = Pygame.Afişa.Set_mode (rezoluție) sine.Ceas = Pygame.Timp.Ceas () sine.GameObjects = [] sine.GameObjects.Apend (minge ()).GameObjects.APPACT (BALL (100)) Def Galerievent (Sine): Pentru eveniment în Pygame.Eveniment.Obțineți (): Dacă evenimentul.Tip == Quit: Pygame.Quit () def run (sine): în timp ce este adevărat: de sine.Galerievents () pentru Gameobj în sine.GameObjects: Gameobj.Actualizați () Sine.Ecran.Umple (alb) pentru gameobj în sine.GameObjects: Gameobj.Trage (sine.Ecran) de sine.CEAS.Tick (60) Pygame.Afişa.Flip () joc ().ALERGA ()

Partea 5 din 8:

Adăugarea unui obiect "Player"

unu. Creați o clasă de jucători și designerul său. Trebuie să creați un alt cerc controlat de mișcarea mouse-ului. Inițializați parametrii săi în designer. Singura valoare importantă va fi raza.

Player de clasă: Def __init __ (Self, Rad = 20): Sine.X = 0.Y = 0.Raza = rad

2. Determinați desenul obiectului jucătorului. Este desenat în mod similar cu privire la modul în care au fost desenate alte obiecte de joc.

Player de clasă:...Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, roșu, (sine.X, sine.y), sine.RAZĂ)

3. Adăugați controlul mouse-ului pentru obiectul playerului. În fiecare cadru al jocului, trebuie să verificați poziția indicatorului mouse-ului și să relaționați poziția obiectului jucătorului cu acest punct.

Player de clasă:...Def Update (Sine): Cord = Pygame.Mouse.get_pos () de sine.X = cablu [0] sine.Y = cord [1]

4. Adăugați obiectul jucătorului la matricea GameObjects. Creați o nouă instanță a obiectului și adăugați-o în lista GameObjects.

Joc de clasă (): def __init __ (auto):...De sine.GameObjects.Adăugați (jucător ())

Imagine intitulată programpygamepart4.jpg

cinci. Încercați programul! Acum codul programului ar trebui să arate astfel:

Importați Pygamefrom Pygame.O localnici Import * Rezoluție = (400,300) White = (255,255,255) Black = (0,0,0) Red = (255,0,0) Ecran = Pygame.Afişa.Set_mode (rezoluție) Ball Ball: Def __init __ (Self, Xpos = Rezoluție [0] / 2, Ypos = Rezoluție [1] / 2, xvel = 1, YVER = 1, Rad = 15): Sine.x = xposself.Y = yosself.Dx = xvelf.dy = yvelself.Radius = Radself.Tip = "Minge"Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, negru, (sine.X, sine.y), sine.RADIUS) DEF Actualizare: Sine.X + = sine.Dx.Y + = sine.Dyif (sine.X <= 0 or self.x >= Rezoluție [0]): Sine.Dx * = -1if (sine.y <= 0 or self.y >= Rezoluție [1]): Sine.Dy * = -1class player: def __init __ (sine, rad = 20): sine.X = 0.Y = 0.Radius = Radself.Tip = "Jucător"Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, roșu, (sine.X, sine.y), sine.Radius) Def Update (Sine): Cord = Pygame.Mouse.get_pos () de sine.X = cablu [0] sine.Y = cord [1] joc de clasă (): def __init __ (sine): Pygame.IN SINEA LUI.Ecran = Pygame.Afişa.Set_mode (rezoluție) sine.Ceas = Pygame.Timp.Ceas () sine.GameObjects = [] sine.GameObjects.Adăugați (jucător ()).GameObjects.Apend (minge ()).GameObjects.APPACT (BALL (100)) Def Galerievent (Sine): Pentru eveniment în Pygame.Eveniment.Obțineți (): Dacă evenimentul.Tip == Quit: Pygame.Quit () def run (sine): în timp ce este adevărat: de sine.Galerievents () pentru Gameobj în sine.GameObjects: Gameobj.Actualizați () Sine.Ecran.Umple (alb) pentru gameobj în sine.GameObjects: Gameobj.Trage (sine.Ecran) de sine.CEAS.Tick (60) Pygame.Afişa.Flip () joc ().ALERGA ()

Partea 6 din 8:

Crearea interacțiunii obiectului

unu. Schimbați funcțiile de actualizare a poziției. Pentru a implementa interacțiunea obiectelor, este necesar să le furnizați accesul la reciproc proprietăți. Adăugați un nou parametru în funcția de actualizare pentru a transfera datele listei GameObjects. Parametrul trebuie adăugat la clasele și funcțiile cu bile. Dacă aveți o mulțime de clase, moștenirea va ajuta la salvarea listei de parametri la fel.

Clasa Ball:...Def Update (Self, GameObjects):...Player de clasă:...Def Update (Self, GameObjects):

2. Introduceți cecuri de coliziune a jucătorului cu bile. Vedeți toate obiectele și definiți-le printre ele care se referă la bile. Apoi, folosind radiațiile obiectelor și formula pentru determinarea distanței, verificați dacă obiectele s-au ciocnit unul cu celălalt. Verificați coliziunile dintre cercuri este ușor. Acesta este motivul principal că, ca exemplu în acest joc, cifrele unei alte forme nu sunt utilizate.

Player de clasă:...Def Update (Self, GameObjects):...Pentru Gameobj în GameObjects: Dacă Gameobj.Tip == "Minge": Dacă (Gameobj.X - Sine.x) ** 2 + (Gameobj.Y-sine.y) ** 2 <= (gameObj.radius + self.radius)**2:

Imagine intitulată programpygamepart5.jpg

3. Stabiliți sfârșitul jocului atunci când un jucător coliziune cu o minge. În acest stadiu, pur și simplu puneți calea de ieșire din joc.

Dacă (Gameobj.X - Sine.x) ** 2 + (Gameobj.Y-sine.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()

4. Încercați programul! Acum codul programului ar trebui să arate astfel:

Importați Pygamefrom Pygame.LOCALS IMPORT * Rezolution = (400, 300) alb = (255,255,255) negru = (0,0,0) Red = (255,0,0,0) Ecran = Pygame.Afişa.Set_mode (rezoluție) Ball Ball: Def __init __ (Self, Xpos = Rezoluție [0] / 2, Ypos = Rezoluție [1] / 2, xvel = 1, YVER = 1, Rad = 15): Sine.x = xposself.Y = yosself.Dx = xvelf.dy = yvelself.Radius = Radself.Tip = "Minge"Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, negru, (sine.X, sine.y), sine.RADIUS) DEF Update (Self, GameObjects): Sine.X + = sine.Dx.Y + = sine.Dyif (sine.X <= 0 or self.x >= Rezoluție [0]): Sine.Dx * = -1if (sine.Y <= 0 or self.y >= Rezoluție [1]): Sine.Dy * = -1class player: def __init __ (sine, rad = 20): sine.X = 0.Y = 0.Radius = Radself.Tip = "Jucător"Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, roșu, (sine.X, sine.y), sine.Radius) Def Update (Self, GameObjects): Cord = Pygame.Mouse.get_pos () de sine.X = cablu [0] sine.Y = Cord [1] pentru Gameobj în GameObjects: Dacă Gameobj.Tip == "Minge": Dacă (Gameobj.X - Sine.x) ** 2 + (Gameobj.Y-sine.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()class game():def __init__(self):pygame.init()self.screen = pygame.display.set_mode(resolution)self.clock = pygame.time.Clock()self.gameObjects = []self.gameObjects.append(Player())self.gameObjects.append(Ball())self.gameObjects.append(Ball(100))def handleEvents(self):for event in pygame.event.get():if event.type == QUIT:pygame.quit()def run(self):while True:self.handleEvents()for gameObj in self.gameObjects:gameObj.update(self.gameObjects)self.screen.fill(white)for gameObj in self.gameObjects:gameObj.draw(self.screen)self.clock.tick(60)pygame.display.flip()game().run()

Partea 7 din 8:

Adăugarea unui controler de jocuri pentru a crea obiecte

unu. Creați o clasă de controler de jocuri. Controlerele de joc sunt responsabile pentru cursul jocului. Ei nu coincid cu clasa jocului în sine, care este responsabil pentru desenarea și actualizarea tuturor obiectelor de joc. Controlerul va adăuga periodic o nouă minge pe ecran și va complica jocul. Adăugați designerul și inițializați unele valori de pornire. Intervalul va însemna timpul prin care va fi adăugată o nouă minge.

Clasa GameController: Def __init __ (Self, Interval = 5): Sine.Inter = interval de interval.Apoi = Pygame.Timp.get_ticks () + (2 * 1000) de sine.Tip = "Controlor de joc"

2. Adăugați funcția de actualizare. Acesta va verifica cât de mult a trecut timpul de la adăugarea mingii anterioare sau de la începutul jocului. Dacă timpul depășește intervalul specificat, cronometrul va fi resetat și noua minge a fost adăugată.

Clasa GameController:...Def Update (Self, GameObjects): Dacă este de sine.Următorul < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball())

3. Montați viteze aleatorii pentru bile. Pentru a face ca jocul să se comporte diferit, este necesar să le permiteți să utilizeze numere aleatorii pentru parametrul de viteză. Acum, viteza bilelor va fi determinată de un număr zecimal plutitor, nu un număr întreg.

Clasa GameController:...Def Update (Self, GameObjects): Dacă este de sine.Următorul < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))

4. Corectați caracteristica desenului. Funcția de tragere nu funcționează cu punct și virgulă plutitoare (plutitor). Prin urmare, este necesar să se exprime poziția mingelor în numere întregi înainte de ao trage.

Clasa Ball:...Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, negru, (int (de sine.x), int (sine.y)), sine.RAZĂ)

cinci. Determinați metoda de desen pentru controlerul de jocuri. Deoarece acesta este, de asemenea, un obiect de joc, în ciclul principal al jocului va fi o încercare de ao trage. Prin urmare, pentru controler, este necesar să se determine funcția de desen, care nu face nimic pentru a evita eșecul jocului.

Clasa GameController:...Def trage (sine, ecran): trece

6. Adăugați un controler de joc în GameObjects și eliminați 2 bile. Jocul trebuie să adauge o minge nouă la fiecare 5 secunde.

Joc de clasă (): def __init __ (auto):...De sine.GameObjects = [] sine.GameObjects.Anexe (gamecontroller ()) sine.GameObjects.Adăugați (jucător ())

Imagine intitulată programpygamepart6.jpg

7. Încercați programul! Acum codul programului ar trebui să arate astfel:

Import Pygamefrom Import aleator Randomfrom Pygame.O localnici Import * Rezoluție = (400,300) White = (255,255,255) Black = (0,0,0) Red = (255,0,0) Ecran = Pygame.Afişa.Set_mode (rezoluție) Ball Ball: Def __init __ (Self, Xpos = Rezoluție [0] / 2, Ypos = Rezoluție [1] / 2, xvel = 1, YVER = 1, Rad = 15): Sine.x = xposself.Y = yosself.Dx = xvelf.dy = yvelself.Radius = Radself.Tip = "Minge"Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, negru, (int (de sine.x), int (sine.y)), sine.RADIUS) DEF Update (Self, GameObjects): Sine.X + = sine.Dx.Y + = sine.Dyif (sine.X <= 0 or self.x >= Rezoluție [0]): Sine.Dx * = -1if (sine.y <= 0 or self.y >= Rezoluție [1]): Sine.Dy * = -1class player: def __init __ (sine, rad = 20): sine.X = 0.Y = 0.Radius = Radself.Tip = "Jucător"Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, roșu, (sine.X, sine.y), sine.Radius) Def Update (Self, GameObjects): Cord = Pygame.Mouse.get_pos () de sine.X = cablu [0] sine.Y = Cord [1] pentru Gameobj în GameObjects: Dacă Gameobj.Tip == "Minge": Dacă (Gameobj.X - Sine.x) ** 2 + (Gameobj.Y-sine.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()class GameController:def __init__(self, interval = 5):self.inter = intervalself.next = pygame.time.get_ticks() + (2 * 1000)self.type = "game controller"def update(self, gameObjects):if self.next < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))def draw(self, screen):passclass game():def __init__(self):pygame.init()self.screen = pygame.display.set_mode(resolution)self.clock = pygame.time.Clock()self.gameObjects = []self.gameObjects.append(GameController())self.gameObjects.append(Player())def handleEvents(self):for event in pygame.event.get():if event.type == QUIT:pygame.quit()def run(self):while True:self.handleEvents()for gameObj in self.gameObjects:gameObj.update(self.gameObjects)self.screen.fill(white)for gameObj in self.gameObjects:gameObj.draw(self.screen)self.clock.tick(60)pygame.display.flip()game().run()

Partea 8 din 8:

Adăugarea unui cont și finalizarea jocului

unu. Adăugați un cont la clasa controlerului de jocuri. Creați un obiect de clasă de fonturi și un scor variabil. Obiectul de fonturi trebuie să fie tras în fiecare cadru pentru a afișa contul curent și o mărește în fiecare cadru atunci când actualizați.

Clasa GameController: Def __init __ (Self, Interval = 5):...De sine.Scor = 0seness.ScoreText = Pygame.Font.Font (nici unul, 12) Def Update (Self, GameObjects):...De sine.Scor + = 1DEF Draw (Self, Ecran): Ecran.Blit (sine.ScoreText.Render (STR (sine.Scor), TRUE, Negru), (5,5))

2. Schimbați procesul de completare a jocului. Îndepărtați o cale simplă din joc atunci când o coliziune a jucătorului cu o minge. În schimb, creați o variabilă în clasa jucătorului, care va fi verificată prin redare. Când variabila de gameover devine adevărată, trebuie să opriți actualizarea obiectelor. Toate obiectele sunt înghețate în loc, astfel încât jucătorul va fi capabil să înțeleagă ce sa întâmplat și va vedea contul său. Obiectele vor fi încă afișate pe ecran, dar vor înceta pur și simplu actualizate.

Clasa Player: Def __init __ (Self, Rad = 20):...De sine.Gameover = FalseDef Update (Self, GameObjects):...Pentru Gameobj în GameObjects: Dacă Gameobj.Tip == "Minge": Dacă (Gameobj.X - Sine.x) ** 2 + (Gameobj.Y-sine.y) ** 2 <= (gameObj.radius + self.radius)**2:self.gameOver = Trueclass game():def __init__(self):...self.gameOver = Falsedef run(self):while True:self.handleEvents()if not self.gameOver:for gameObj in self.gameObjects:gameObj.update(self.gameObjects)if gameObj.type == "player":self.gameOver = gameObj.gameOver

Imagine intitulată programpygamefinal.jpg

3. Încercați programul! Codul final al programului ar trebui să arate astfel:

Import Pygamefrom Import aleator Randomfrom Pygame.O localnici Import * Rezoluție = (400,300) White = (255,255,255) Black = (0,0,0) Red = (255,0,0) Ecran = Pygame.Afişa.Set_mode (rezoluție) Ball Ball: Def __init __ (Self, Xpos = Rezoluție [0] / 2, Ypos = Rezoluție [1] / 2, xvel = 1, YVER = 1, Rad = 15): Sine.x = xposself.Y = yosself.Dx = xvelf.dy = yvelself.Radius = Radself.Tip = "Minge"Def trage (sine, suprafață): Pygame.A desena.Cerc (suprafață, negru, (int (de sine.x), int (sine.y)), sine.RADIUS) DEF Update (Self, GameObjects): Sine.X + = sine.Dx.Y + = sine.Dyif (sine.X <= 0 or self.x >= Rezoluție [0]): Sine.Dx * = -1if (sine.y <= 0 or self.y >= Rezoluție [1]): Sine.Dy * = -1class player: def __init __ (sine, rad = 20): sine.X = 0.Y = 0.Radius = Radself.Tip = "Jucător"De sine.Gameover = FalseDef Draw (Self, Suprafata): Pygame.A desena.Cerc (suprafață, roșu, (sine.X, sine.y), sine.Radius) Def Update (Self, GameObjects): Cord = Pygame.Mouse.get_pos () de sine.X = cablu [0] sine.Y = Cord [1] pentru Gameobj în GameObjects: Dacă Gameobj.Tip == "Minge": Dacă (Gameobj.X - Sine.x) ** 2 + (Gameobj.Y-sine.y) ** 2 <= (gameObj.radius + self.radius)**2:self.gameOver = Trueclass GameController:def __init__(self, interval = 5):self.inter = intervalself.next = pygame.time.get_ticks() + (2 * 1000)self.type = "game controller"self.score = 0self.scoreText = pygame.font.Font(None, 12)def update(self, gameObjects):if self.next < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))self.score += 1def draw(self, screen):screen.blit(self.scoreText.render(str(self.score), True, black), (5,5))class game():def __init__(self):pygame.init()self.screen = pygame.display.set_mode(resolution)self.clock = pygame.time.Clock()self.gameObjects = []self.gameObjects.append(GameController())self.gameObjects.append(Player())self.gameOver = Falsedef handleEvents(self):for event in pygame.event.get():if event.type == QUIT:pygame.quit()def run(self):while True:self.handleEvents()if not self.gameOver:for gameObj in self.gameObjects:gameObj.update(self.gameObjects)if gameObj.type == "player":self.gameOver = gameObj.gameOverself.screen.fill(white)for gameObj in self.gameObjects:gameObj.draw(self.screen)self.clock.tick(60)pygame.display.flip()game().run()