Hogyan programozza a játékokat a Python-on a Pygame Könyvtár segítségével

Ez a cikk azoknak szól, akik már ismerik a Python programozási nyelvet, és lehetővé teszik, hogy elolvassa a Pygame Library ehhez a nyelvhez. Vizuális példaként egy egyszerű játékprogramozási folyamat jelenik meg, amelyben a játékosnak meg kell adnia az ugró golyókat.

Lépések

8. rész:

A Pygame telepítése

egy. Töltse le a pygame-t. Kövesse a linket, és keresse meg az Ön platformjának megfelelő könyvtár verzióját: http: // Pygame.Org / letöltés.shtml .

2. Futtassa a telepítőt.

3. Győződjön meg róla, hogy a telepítés sikeresen befejeződött. Nyissa ki a Python terminált. Adja meg az "Import Pygame". Ha a hibaüzenetek nem jelennek meg, akkor a Pygame sikeresen telepítve volt.

Importálja a pygame-t

A 8. rész: 8:

Fő játék létrehozása

egy. Hozzon létre egy új fájlt.

2. Import pygame. A Pygame olyan könyvtár, amely hozzáférést biztosít Python programozási nyelv grafikus funkcióihoz. Ha többet szeretne megtudni arról, hogy ezek a funkciók hogyan működnek, az információ elérhető a Pygame-en. https: // Pygame.Org / Dokumentumok /

Import PygameFROM Pygame.Helyiek importálása *

3. Adja meg a játék ablak méretét. Hozzon létre egy globális változót az ablakméretekhez, hogy a játék különböző részeiről hivatkozzon. A kényelem érdekében ezek a paraméterek jobbak a fájl elején, így szükség esetén könnyebb változtatni a jövőben. A bonyolultabb projektekhez előnyösebb lesz az ilyen adatok külön fájlban.

Felbontás = (400,300)

4. Határozza meg több színt. A PyGame színeket RGBA formátumban definiálják, 0 és 255 között. Az alfa (a) értéke elhagyható, de a színek többi része (piros, zöld és kék) szükséges a töltéshez.

Fehér = (255,255,255) fekete = (0,0,0) piros = (255,0,0)

öt. Inicializálja a fő képernyőt. Használja a korábban megadott felbontási változót.

Képernyő = pygame.Kijelző.SET_MODE (felbontás)

6. Hozzon létre egy ciklust a játékról. Állítsa be bizonyos műveletek ismétlését a játék minden keretében. Hozzon létre egy ciklust, amely következetesen elvégzi ezeket a műveleteket.

Míg Igaz:

7. Határozza meg a képernyő kitöltésének színét.

Képernyő.Töltse ki (fehér)

nyolc. A képernyő megjelenítése. Ha ezt a programot elindítja ebben a szakaszban, akkor a képernyőt fehéren festjük, majd a program megállítja a vészhelyzetet. A hiba oka az, hogy az operációs rendszer elküldi a program eseményeit, és a program egyszerűen nem folytatja. Amikor a program túl sok kezeletlen eseményt hozott létre, a hiba felmerül.

Míg Igaz:...Pygame.Kijelző.Flip ()

kilenc. Végrehajtja az események feldolgozását. Szerezd meg a rajzkeretek között felmerülő összes esemény listáját. A példánkban csak egy kimeneti esemény (kilépés) feldolgozását kell aggódnia. Ez akkor fordul elő, amikor a felhasználó bezárja a játékablakot. Az eseményfeldolgozás megakadályozza a program kudarcát túl sok esemény megjelenésétől.

Míg Igaz:...A Pygame-i eseményre.Esemény.Get (): Ha az esemény.Típus == Quit: Pygame.Kilépés ()

10. Próbálja ki a programot! Most a programkódnak ezt kell kinéznie:

Import PygameFROM Pygame.Helyek importálása * Felbontás = (400,300) fehér = (255,255,255) fekete = (0,0,0) piros = (255,0,0) képernyő = pygame.Kijelző.SET_MODE (felbontás) TRUE: SCREEN.Töltse ki (fehér) pygame.Kijelző.Flip () az eseményen a Pygame-ben.Esemény.Get (): Ha az esemény.Típus == Quit: Pygame.Kilépés ()

A 8. rész:

Játéktárgyak létrehozása

egy. Hozzon létre egy új objektumot és tervezőjét. Állítsa be az objektum összes tulajdonát. Határozza meg az alapértelmezett értékeket az egyes tulajdonságokhoz.

CLASS BALL: DEF __INIT __ (SELF, XPOS = felbontás [0] / 2, ypos = felbontás [1] / 2, XVEL = 1, YGEL = 1, rad = 15): én.x = xpossel.Y = ypossel.DX = XVelself.DY = YVELSELF.RADIUS = Radself.Típus = "Labda"

2. Határozza meg az objektum rajzát. Használja a konstruktorban megadott objektum tulajdonságait, hogy a labdát a funkcióhoz továbbított felületként ábrázolja. A felület lesz a képernyő, amelyet korábban hoztál létre a méretei meghatározásával.

Def rajz (ön, felület): Pygame.Húz.Kör (felület, fekete, (én).X, én.y), én.SUGÁR)

3. Hozzon létre egy osztálypéldányt, és adjon hozzá munkát a játékciklushoz, hogy rajzoljon egy labdát a ciklus minden iterációjára.

Labda = labda (), míg igaz:...Labda.Rajzolás (képernyő)

4. Tegye az objektumot. Hozzon létre egy funkciót, amely frissíti az objektum helyzetét. Hívja ezt a funkciót a ciklus minden iterációjában.

Osztály labda:...Def frissítés (önmaga): én.X + = én.Dxself.Y + = én.Dy

öt. Limit keretfrekvencia. A labda nagyon gyorsan mozog, mert a játékciklus másodpercenként több százszor ismételhető. Használja a Pygame időzítőt a keretváltozás gyakoriságának korlátozásához 60 fpsig.

Óra = Pygame.Idő.Óra (), míg igaz:...ÓRA.Tick (60)

Tartson egy tálat a képernyőn. Adja hozzá az állapotfüggvény funkciót a labda mozgásának irányának megváltoztatásához, ha eléri a képernyőhatárokat.

Osztály labda:...DEF frissítés (önmaga):...Ha (én.X <= 0 or self.x >= Felbontás [0]): Én.Dx * = -1f (én).y <= 0 or self.y >= Felbontás [1]): Én.dy * = -1

Próbálja ki a programot! Most a programkódnak ezt kell kinéznie:

Import PygameFROM Pygame.Helyek importálása * Felbontás = (400,300) fehér = (255,255,255) fekete = (0,0,0) piros = (255,0,0) képernyő = pygame.Kijelző.SET_MODE (felbontás) osztály labda: def __INIT __ (önálló, xpos = felbontás [0] / 2, ypos = felbontás [1] / 2, xvel = 1, yvel = 1, rad = 15).x = xpossel.Y = ypossel.DX = XVelself.DY = YVELSELF.RADIUS = Radself.Típus = "Labda"Def rajz (ön, felület): Pygame.Húz.Kör (felület, fekete, (én).X, én.y), én.RADIUS) DEF frissítés: én.X + = én.Dxself.Y + = én.Dyif (én.X <= 0 or self.x >= Felbontás [0]): Én.Dx * = -1f (én).y <= 0 or self.y >= Felbontás [1]): Én.dy * = -1ball = labda () óra = pygame.Idő.Óra (), míg igaz: képernyő.Töltse ki (fehér) labdát.Rajzoljon (képernyőt) labdát.Frissítés () pygame.Kijelző.Flip () óra.Tick (60) az eseményen a Pygame-ben.Esemény.Get (): Ha az esemény.Típus == Quit: Pygame.Kilépés ()

A 8. rész: 8:

Strukturáló játékok

egy. Használja az osztályokat a strukturáláshoz. A jövőben a játék összetettebb lesz. Használja az objektumorientált programozási technikákat a strukturáló kódhoz.

2. Konvertálja a játékciklust az osztályba. Mivel abban a pillanatban a játék már tartalmaz adatokat, beleértve a játékobjektumokat és funkciókat, érdemes helyettesíteni a játékciklust az osztályba.

Osztályjáték ():

3. Adja hozzá a tervezőt. Ezzel megtagadja a játékban használt objektumokat, létrehozhat egy képernyőt, időzítőt és inicializálja a Pygame-t. A PyGame-t inicializálni kell annak érdekében, hogy ezeket a képességeket szöveges vagy hangként használják.

Osztályjáték (): def __init __ (önmaga): Pygame.MAGÁBAN.Képernyő = pygame.Kijelző.Set_mode (felbontás) önmaga.Óra = Pygame.Idő.Óra ()

4. Állítsa be az események feldolgozását a funkcióban.

Osztályjáték ():...DEF Kezletek (Saját): Event a Pygame-ben.Esemény.Get (): Ha az esemény.Típus == Quit: Pygame.Kilépés ()

öt. Készítsen egy játékciklust egy funkcióval. Hívja az eseményfeldolgozási funkciót a ciklus minden iterációjában.

Osztályjáték ():...Def futás (önmaga): míg igaz: én.Kormányok () önmaga.Képernyő.Töltse ki (fehér) önmagát.ÓRA.Tick (60) pygame.Kijelző.Flip ()

6. Állítsa be a több játékobjektum feldolgozását. Ebben a szakaszban a játékkód minden keretben az egyes objektumok frissítését és újratelepítését okozza. Ezzel a megközelítéssel a játékkód meglehetősen terjedelmes és rendezetlen lesz, különösen, ha sok tárgy van a játékban. Bölcsebb, hogy először adjon hozzá objektumokat egy tömbhöz, majd frissítse és újratervezze az összes objektumot a tömbben a ciklus minden iterációjában. Most könnyen új objektumot készíthet a játékban, és meghatározhat egy másik kiindulási pozíciót.

Osztályjáték (): def __init __ (önmaga):...Maga.Gameobjects = [] én.GameObjects.Adjon hozzá (labda ()) önmaga.GameObjects.Adapend (labda (100))...Def futás (önmaga): míg igaz: én.() A gameobj számára az énben.GameObjects: GameOBJ.Frissítés () önmaga.Képernyő.Töltse ki (fehér) a játékot az énben.GameObjects: GameObj.Húzza (én.Képernyő) én.ÓRA.Tick (60) pygame.Kijelző.Flip ()

7. Próbálja ki a programot! Most a programkódnak ezt kell kinéznie:

Import PygameFROM Pygame.Helyek importálása * Felbontás = (400,300) fehér = (255,255,255) fekete = (0,0,0) piros = (255,0,0) képernyő = pygame.Kijelző.SET_MODE (felbontás) osztály labda: def __INIT __ (önálló, xpos = felbontás [0] / 2, ypos = felbontás [1] / 2, xvel = 1, yvel = 1, rad = 15).x = xpossel.Y = ypossel.DX = XVelself.DY = YVELSELF.RADIUS = Radself.Típus = "Labda"Def rajz (ön, felület): Pygame.Húz.Kör (felület, fekete, (én).X, én.y), én.RADIUS) DEF frissítés: én.X + = én.Dxself.Y + = én.Dyif (én.X <= 0 or self.x >= Felbontás [0]): Én.Dx * = -1f (én).y <= 0 or self.y >= Felbontás [1]): Én.DY * = -1Class játék (): def __INIT __ (önmaga): Pygame.MAGÁBAN.Képernyő = pygame.Kijelző.Set_mode (felbontás) önmaga.Óra = Pygame.Idő.Óra () önmaga.Gameobjects = [] én.GameObjects.Adjon hozzá (labda ()) önmaga.GameObjects.Hozzáadása (labda (100)) DEF kezelők (önmagában): Event a Pygame-ben.Esemény.Get (): Ha az esemény.Típus == Quit: Pygame.Kilép () def futás (önmaga): míg igaz: én.() A gameobj számára az énben.GameObjects: GameOBJ.Frissítés () önmaga.Képernyő.Töltse ki (fehér) a játékot az énben.GameObjects: GameOBJ.Húzza (én.Képernyő) én.ÓRA.Tick (60) pygame.Kijelző.Flip () játék ().FUSS ()

Az 5. rész 8:

"Player" objektum hozzáadása

egy. Hozzon létre egy játékososztályt és tervezőjét. Egy másik köret kell létrehoznia az egér mozgása által vezérelt kör. Inicializálja paramétereit a tervezőben. Az egyetlen fontos érték lesz a sugár.

Oszter lejátszó: def __init __ (én, rad = 20): én.x = 0s.Y = 0s.RADIUS = RAD

2. Határozza meg a játékos tárgyának rajzát. Hasonlóan rajzolódik, hogy más játékobjektumokat rajzolták.

Oszter lejátszó:...Def rajz (ön, felület): Pygame.Húz.Kör (felület, piros, (én).X, én.y), én.SUGÁR)

3. Egérvezérlés hozzáadása a lejátszó objektumhoz. A játék minden keretében ellenőriznie kell az egérmutató pozícióját, és kapcsolja ki a játékos objektumának helyzetét ezzel a ponttal.

Oszter lejátszó:...DEF frissítés (önmaga): Cord = Pygame.Egér.get_pos () én.X = zsinór [0] én.Y = zsinór [1]

4. Adja hozzá a lejátszó objektumot a GameObjects Array számára. Hozzon létre egy új példányt az objektumhoz, és adja hozzá a GameObjects listához.

Osztályjáték (): def __init __ (önmaga):...Maga.GameObjects.Hozzáadása (játékos ())

öt. Próbálja ki a programot! Most a programkódnak ezt kell kinéznie:

Import PygameFROM Pygame.Helyek importálása * Felbontás = (400,300) fehér = (255,255,255) fekete = (0,0,0) piros = (255,0,0) képernyő = pygame.Kijelző.SET_MODE (felbontás) osztály labda: def __INIT __ (önálló, xpos = felbontás [0] / 2, ypos = felbontás [1] / 2, xvel = 1, yvel = 1, rad = 15).x = xpossel.Y = ypossel.DX = XVelself.DY = YVELSELF.RADIUS = Radself.Típus = "Labda"Def rajz (ön, felület): Pygame.Húz.Kör (felület, fekete, (én).X, én.y), én.RADIUS) DEF frissítés: én.X + = én.Dxself.Y + = én.Dyif (én.X <= 0 or self.x >= Felbontás [0]): Én.Dx * = -1f (én).y <= 0 or self.y >= Felbontás [1]): Én.DY * = -1CLASS PLAYER: DEF __INIT __ (SELF, RAD = 20): Én.x = 0s.Y = 0s.RADIUS = Radself.Típus = "Játékos"Def rajz (ön, felület): Pygame.Húz.Kör (felület, piros, (én).X, én.y), én.RADIUS) DEF frissítés (önmaga): Cord = Pygame.Egér.get_pos () én.X = zsinór [0] én.Y = zsinór [1] osztályú játék (): def __init __ (önmaga): pygame.MAGÁBAN.Képernyő = pygame.Kijelző.Set_mode (felbontás) önmaga.Óra = Pygame.Idő.Óra () önmaga.Gameobjects = [] én.GameObjects.Hozzáfűzése (játékos ()) önmaga.GameObjects.Adjon hozzá (labda ()) önmaga.GameObjects.Hozzáadása (labda (100)) DEF kezelők (önmagában): Event a Pygame-ben.Esemény.Get (): Ha az esemény.Típus == Quit: Pygame.Kilép () def futás (önmaga): míg igaz: én.() A gameobj számára az énben.GameObjects: GameObj.Frissítés () önmaga.Képernyő.Töltse ki (fehér) a játékot az énben.GameObjects: GameObj.Húzza (én.Képernyő) én.ÓRA.Tick (60) pygame.Kijelző.Flip () játék ().FUSS ()

A 8. rész:

Objektum kölcsönhatás létrehozása

egy. A pozíció frissítési funkcióinak módosítása. Az objektumok kölcsönhatásának megvalósításához szükség van az egymáshoz való hozzáférésre. Adjon hozzá egy új paramétert a frissítési funkcióhoz a GameObjects listaadatok átviteléhez. A paramétert hozzá kell adni a lejátszóosztályokhoz és a labda funkciókhoz. Ha sok osztályod van, az öröklés segíteni fogja a paraméterek listáját ugyanazt.

Osztály labda:...DEF frissítés (én, gameobjects):...Oszter lejátszó:...DEF frissítés (én, gameobjects):

2. Adja meg a játékos ütközésellenőrzését a golyókkal. Tekintse meg az összes objektumot, és határozza meg őket, amelyek a golyókhoz kapcsolódnak. Ezután az objektumok sugara és a távolság meghatározására szolgáló képlet segítségével ellenőrizze, hogy az objektumok egymáshoz ütköztek-e. Ellenőrizze a körök közötti ütközéseket. Ez a fő oka annak, hogy példaként szerepel ebben a játékban, egy másik forma alakjait nem használják.

Oszter lejátszó:...DEF frissítés (én, gameobjects):...GameObj a GameBjects: Ha Gameobj.Típus == "Labda": ha (gameobj.X - Én.x) ** 2 + (gameobj.Y - Én.y) ** 2 <= (gameObj.radius + self.radius)**2:

3. Állítsa be a játék végét, amikor egy játékos ütközése labdával. Ebben a szakaszban egyszerűen állítsa be a játékot.

Ha (Gameobj.X - Én.x) ** 2 + (gameobj.Y - Én.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()

4. Próbálja ki a programot! Most a programkódnak ezt kell kinéznie:

Import PygameFROM Pygame.Helyek importálása * Felbontás = (400, 300) fehér = (255,25555) fekete = (0,0,0) piros = (255,0,0,0) képernyő = pygame.Kijelző.SET_MODE (felbontás) osztály labda: def __INIT __ (önálló, xpos = felbontás [0] / 2, ypos = felbontás [1] / 2, xvel = 1, yvel = 1, rad = 15).x = xpossel.Y = ypossel.DX = XVelself.DY = YVELSELF.RADIUS = Radself.Típus = "Labda"Def rajz (ön, felület): Pygame.Húz.Kör (felület, fekete, (én).X, én.y), én.RADIUS) DEF frissítés (én, gameobjects): én.X + = én.Dxself.Y + = én.Dyif (én.X <= 0 or self.x >= Felbontás [0]): Én.Dx * = -1f (én).y <= 0 or self.y >= Felbontás [1]): Én.DY * = -1CLASS PLAYER: DEF __INIT __ (SELF, RAD = 20): Én.x = 0s.Y = 0s.RADIUS = Radself.Típus = "Játékos"Def rajz (ön, felület): Pygame.Húz.Kör (felület, piros, (én).X, én.y), én.RADIUS) DEF frissítés (én, gameobjects): Cord = Pygame.Egér.get_pos () én.X = zsinór [0] én.Y = zsinór [1] a gameobj-hoz a GameObjects: Ha a GameOBJ.Típus == "Labda": ha (gameobj.X - Én.x) ** 2 + (gameobj.Y - Én.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()

A 8. rész 7. része:

Játékvezérlő hozzáadása objektumok létrehozásához

egy. Hozzon létre egy játékvezérlő osztályt. A játékvezérlők felelősek a játék folyamán. Nem egybeesnek a játék osztályával, ami felelős az összes játékobjektum rajzolásáért és frissítéséért. A vezérlő rendszeresen hozzáad egy új labdát a képernyőn, és bonyolítja a játékot. Adja hozzá a tervezőt, és inicializálja néhány kiindulási értéket. Az intervallum azt jelenti, hogy az új golyó hozzáadódik.

Osztály gamecontroller: def __init __ (én, intervallum = 5): én.Inter = Intervalast.Következő = Pygame.Idő.get_ticks () + (2 * 1000) önmaga.Típus = "Játékvezérlő"

2. Adja hozzá a frissítési funkciót. Meg fogja nézni, hogy mennyi idő telt el az előző labda hozzáadásával vagy a játék elejétől. Ha az idő meghaladja a megadott intervallumot, az időzítő visszaáll, és az új golyó hozzá lett adva.

Osztály gamecontroller:...Def frissítés (én, gameobjects): Ha én.Következő < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball())

3. Telepítse a véletlenszerűsebességeket a golyókhoz. Ahhoz, hogy a játék viselkedjen másképp, meg kell hagynia, hogy véletlenszerű számokat használjon a sebesség paraméterhez. Most a golyók sebességét egy lebegő decimális szám határozza meg, nem egész szám.

Osztály gamecontroller:...Def frissítés (én, gameobjects): Ha én.Következő < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))

4. Javítsa ki a rajz funkcióját. A Draw funkció nem működik lebegő pontosvolonokkal (úszó). Ezért szükség van a labda pozícióját az egész számokba, mielőtt rajzolnánk.

Osztály labda:...Def rajz (ön, felület): Pygame.Húz.Kör (felület, fekete, (int (én).x), int (én.y), önmaga.SUGÁR)

öt. Határozza meg a játékvezérlő rajzolásának módját. Mivel ez is egy játékobjektum, a fő játékciklusban megpróbálják felhívni. Ezért a vezérlő számára meg kell határozni a rajz funkcióját, amely nem tesz semmit, hogy elkerülje a játékhibát.

Osztály gamecontroller:...Def rajz (ön, képernyő): átadás

6. Adjon hozzá egy játékvezérlőt a GameObjects-ben és távolítsa el a 2 golyót. A játéknak 5 másodpercenként új labdát kell hozzáadnia.

Osztályjáték (): def __init __ (önmaga):...Maga.Gameobjects = [] én.GameObjects.Appendroller (gamecontroller ()) önmaga.GameObjects.Hozzáadása (játékos ())

7. Próbálja ki a programot! Most a programkódnak ezt kell kinéznie:

Import PygameFROM Random Import Randomfrom Pygame.Helyek importálása * Felbontás = (400,300) fehér = (255,255,255) fekete = (0,0,0) piros = (255,0,0) képernyő = pygame.Kijelző.SET_MODE (felbontás) osztály labda: def __INIT __ (önálló, xpos = felbontás [0] / 2, ypos = felbontás [1] / 2, xvel = 1, yvel = 1, rad = 15).x = xpossel.Y = ypossel.DX = XVelself.DY = YVELSELF.RADIUS = Radself.Típus = "Labda"Def rajz (ön, felület): Pygame.Húz.Kör (felület, fekete, (int (én).x), int (én.y), önmaga.RADIUS) DEF frissítés (én, gameobjects): én.X + = én.Dxself.Y + = én.Dyif (én.X <= 0 or self.x >= Felbontás [0]): Én.Dx * = -1f (én).y <= 0 or self.y >= Felbontás [1]): Én.DY * = -1CLASS PLAYER: DEF __INIT __ (SELF, RAD = 20): Én.x = 0s.Y = 0s.RADIUS = Radself.Típus = "Játékos"Def rajz (ön, felület): Pygame.Húz.Kör (felület, piros, (én).X, én.y), én.RADIUS) DEF frissítés (én, gameobjects): Cord = Pygame.Egér.get_pos () én.X = zsinór [0] én.Y = zsinór [1] a gameobj-hoz a GameObjects: Ha a GameOBJ.Típus == "Labda": ha (gameobj.X - Én.x) ** 2 + (gameobj.Y - Én.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()

8. rész: 8:

Fiók hozzáadása és befejezése a játék

egy. Adjon hozzá egy fiókot a Gaming Controller osztályhoz. Hozzon létre egy betűtípus-osztály objektumot és pontszámváltozót. A betűtípus objektumot minden keretben meg kell húzni, hogy megjelenítse az aktuális fiókot, és minden keretben növelje azt, hogy frissítse.

Osztály gamecontroller: def __init __ (én, intervallum = 5):...Maga.Pontszám = 0.Scoretext = Pygame.betűtípus.Betűtípus (nincs, 12) def frissítés (én, gameobjects):...Maga.Pontszám + = 1def rajz (ön, képernyő): képernyő.Blit (én.Smoretext.Render (STR (én).Pontszám), igaz, fekete), (5,5))

2. Változtassa meg a játék befejezésének folyamatát. Távolítson el egy egyszerű utat a játékból, amikor egy játékos ütközik egy labdával. Ehelyett hozzon létre egy változót a lejátszó osztályában, amelyet a játék segítségével ellenőrzik. Amikor a Gameover változó igaz lesz, meg kell állítania az objektumok frissítését. Minden objektum befagyott a helyén, így a játékos képes lesz megérteni, mi történt, és látni fogja a számláját. Az objektumok továbbra is megjelennek a képernyőn, de egyszerűen leállítják a frissítést.

Oszter lejátszó: def __init __ (én, rad = 20):...Maga.Gameover = Falsedef Update (Self, GameBjects):...GameObj a GameBjects: Ha Gameobj.Típus == "Labda": ha (gameobj.X - Én.x) ** 2 + (gameobj.Y - Én.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

3. Próbálja ki a programot! A program végső kódja így kell kinéznie:

Import PygameFROM Random Import Randomfrom Pygame.Helyek importálása * Felbontás = (400,300) fehér = (255,255,255) fekete = (0,0,0) piros = (255,0,0) képernyő = pygame.Kijelző.SET_MODE (felbontás) osztály labda: def __INIT __ (önálló, xpos = felbontás [0] / 2, ypos = felbontás [1] / 2, xvel = 1, yvel = 1, rad = 15).x = xpossel.Y = ypossel.DX = XVelself.DY = YVELSELF.RADIUS = Radself.Típus = "Labda"Def rajz (ön, felület): Pygame.Húz.Kör (felület, fekete, (int (én).x), int (én.y), önmaga.RADIUS) DEF frissítés (én, gameobjects): én.X + = én.Dxself.Y + = én.Dyif (én.X <= 0 or self.x >= Felbontás [0]): Én.Dx * = -1f (én).y <= 0 or self.y >= Felbontás [1]): Én.DY * = -1CLASS PLAYER: DEF __INIT __ (SELF, RAD = 20): Én.x = 0s.Y = 0s.RADIUS = Radself.Típus = "Játékos"Maga.Gameover = Falsedef Rajz (én, felület): Pygame.Húz.Kör (felület, piros, (én).X, én.y), én.RADIUS) DEF frissítés (én, gameobjects): Cord = Pygame.Egér.get_pos () én.X = zsinór [0] én.Y = zsinór [1] a gameobj-hoz a GameObjects: Ha a GameOBJ.Típus == "Labda": ha (gameobj.X - Én.x) ** 2 + (gameobj.Y - Én.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()