Detta är en introduktion till Pygame för personer som redan känner till Python. Denna artikel kommer att lära dig stegen för att bygga ett enkelt spel som har spelaren som undviker studsande bollar.
Steg
Del 1 av 8: Installera Pygame
Steg 1. Ladda ner Pygame
Hitta den för din plattform från
Steg 2. Kör installationsprogrammet
Steg 3. Kontrollera att installationen fungerade
Öppna en Python -terminal. Skriv "importera pygame". Om du inte ser några fel installerades Pygame.
importera pygame
Del 2 av 8: Konfigurera ett grundläggande fönster
Steg 1. Öppna en ny fil
Steg 2. Importera Pygame
Pygame är ett bibliotek som ger åtkomst till grafikfunktioner. Om du vill ha mer information om hur dessa funktioner fungerar kan du leta upp dem på Pygames webbplats.
importera pygame från pygame.locals importera *
Steg 3. Ställ in fönsterupplösningen
Du kommer att göra en global variabel för skärmupplösningen så att det kan refereras till i flera delar av spelet. Det är också lätt att hitta högst upp i filen så att den kan ändras senare. För avancerade projekt är det bättre att lägga denna information i en separat fil.
upplösning = (400, 300)
Steg 4. Definiera några färger
Färger i pygame är (RBGA som ligger i värden mellan 0 och 255. Alfa -värdet (A) är valfritt men de andra färgerna (rött, blått och grönt är obligatoriska).
vit = (255, 255, 255) svart = (0, 0, 0) röd = (255, 0, 0)
Steg 5. Initiera skärmen
Använd upplösningsvariabeln som definierades tidigare.
skärm = pygame.display.set_mode (upplösning)
Steg 6. Gör en spelslinga
Upprepa vissa åtgärder i varje spelram. Gör en loop som alltid kommer att upprepas för att bläddra igenom alla dessa åtgärder.
medan det är sant:
Steg 7. Färga skärmen
skärm. fyllning (vit)
Steg 8. Visa skärmen
Om du kör programmet blir skärmen vit och sedan kraschar programmet. Detta beror på att operativsystemet skickar händelser till spelet och spelet inte gör något med dem. När spelet får för många ohandterade händelser kommer det att krascha.
medan det är sant: … pygame.display.flip ()
Steg 9. Hantera händelser
Få en lista över alla händelser som har inträffat i varje ram. Du kommer bara att bry dig om en händelse, avsluta händelsen. Detta inträffar när användaren stänger spelfönstret. Detta förhindrar också att vårt program kraschar på grund av för många händelser.
medan True: … för händelse i pygame.event.get (): if event.type == QUIT: pygame.quit ()
Steg 10. Prova
Så här ska koden se ut nu:
importera pygame från pygame.locals import * upplösning = (400, 300) vit = (255, 255, 255) svart = (0, 0, 0) röd = (255, 0, 0) skärm = pygame.display.set_mode (upplösning) medan True: screen.fill (vit) pygame.display.flip () för händelse i pygame.event.get (): if event.type == QUIT: pygame.quit ()
Del 3 av 8: Gör ett spelobjekt
Steg 1. Gör en ny klass och konstruktör
Ange alla egenskaper för objektet. Du anger också standardvärden för alla egenskaper.
klass Boll: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "boll"
Steg 2. Definiera hur du ritar objektet
Använd egenskaperna som definierades i konstruktören för att rita bollen som en cirkel samt för att passera en yta in i funktionen för att dra objektet på. Ytan blir skärmobjektet som skapades med upplösningen tidigare.
def draw (själv, yta): pygame.draw.cirkel (yta, svart, (self.x, self.y), self.radius)
Steg 3. Gör en instans av klassen samt berätta för spelslingan att dra bollen i varje slinga
ball = Ball () medan True: … ball.draw (skärm)
Steg 4. Gör objektet rörligt
Skapa en funktion som uppdaterar objektets position. Kalla den här funktionen i varje spelslinga.
klass Boll: … def uppdatering (self): self.x += self.dx self.y += self.dy
Steg 5. Begränsa bildhastigheten
Bollen kommer att röra sig riktigt snabbt eftersom spelslingan går hundratals gånger i sekunden. Använd Pygames klocka för att begränsa bildhastigheten till 60 fps.
clock = pygame.time. Clock () medan True: … clock.tick (60)
Steg 6. Håll bollen på skärmen
Lägg till kontroller i uppdateringsfunktionen för att vända bollens riktning om den träffar en av skärmkanterna.
klass Boll: … def uppdatering (själv): … om (self.x <= 0 eller self.x> = upplösning [0]): self.dx *= -1 if (self.y <= 0 eller self.y > = upplösning [1]): self.dy *= -1
Steg 7. Prova
Så här ska koden se ut nu:
importera pygame från pygame.locals import * upplösning = (400, 300) vit = (255, 255, 255) svart = (0, 0, 0) röd = (255, 0, 0) skärm = pygame.display.set_mode (upplösning) klass Boll: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw (self, surface): pygame.draw.circle (yta, svart, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 if (self.y <= 0 eller self.y> = resolution [1]): self.dy *= -1 ball = Ball () klocka = pygame.time. Clock () medan True: skärm. fyll (vit) ball.draw (skärm) ball.update () pygame.display.flip () clock.tick (60) för händelse i pygame.event.get (): if event.type == QUIT: pygame.quit ()
Del 4 av 8: Organisera spelet
Steg 1. Använd klasser för att organisera allt
Spelet kommer att bli mer komplicerat. Använd objektorienterade tekniker för att organisera din kod.
Steg 2. Gör spelslingan till en klass
Eftersom vårt spel nu har data inklusive dina spelobjekt och funktioner, är det vettigt att göra din spelslinga till en klass.
klassspel ():
Steg 3. Lägg till en konstruktör
Här kommer du att instansiera några spelobjekt, skapa vår skärm och klocka och initiera Pygame. Pygame måste initieras för att använda vissa funktioner som text eller ljud.
klassspel (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolution) self.clock = pygame.time. Clock ()
Steg 4. Hantera händelser i en funktion
klassspel (): … def handleEvents (self): för händelse i pygame.event.get (): if event.type == QUIT: pygame.quit ()
Steg 5. Gör spelslingan till en funktion
Ring händelsehanteringsfunktionen varje loop.
klassspel (): … def run (self): medan True: self.handleEvents () self.screen.fill (vit) self.clock.tick (60) pygame.display.flip ()
Steg 6. Hantera flera spelobjekt
Just nu måste denna kod kalla draw och uppdatera på vårt objekt varje ram. Detta skulle bli rörigt om du hade många föremål. Låt oss lägga till vårt objekt i en array och sedan uppdatera och rita alla objekt i arrayen varje loop. Nu kan du enkelt lägga till ett annat objekt och ge det ett annat utgångsläge.
klassspel (): def _init _ (self): … self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) … def run (self): medan True: self.handleEvents () för gameObj i self.gameObjects: gameObj.update () self.screen.fill (vit) för gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip()
Steg 7. Prova
Så här ska koden se ut nu:
importera pygame från pygame.locals import * upplösning = (400, 300) vit = (255, 255, 255) svart = (0, 0, 0) röd = (255, 0, 0) skärm = pygame.display.set_mode (upplösning) klass Boll: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw (self, surface): pygame.draw.circle (yta, svart, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 if (self.y <= 0 or self.y> = resolution [1]): self.dy *= -1 class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (upplösning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): för händelse i pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvent s () för gameObj i self.gameObjects: gameObj.update () self.screen.fill (white) för gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. flip () game (). run ()
Del 5 av 8: Lägga till ett spelarobjekt
Steg 1. Gör en spelarklass och konstruktör
Du kommer att göra en annan cirkel som styrs av musen. Initiera värdena i konstruktorn. Radien är det enda viktiga värdet.
klass Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Steg 2. Definiera hur man ritar spelarens föremål
Det kommer att bli på samma sätt som du ritade de andra spelobjekten.
klassspelare: … def draw (själv, yta): pygame.draw.cirkel (yta, röd, (self.x, self.y), self.radius)
Steg 3. Lägg till muskontroll för spelarens objekt
Kontrollera musens placering i varje bildruta och ställ in spelarnas föremåls plats till den punkten.
klass Player: … def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
Steg 4. Lägg till ett spelarobjekt i gameObjects
Skapa en ny spelareinstans och lägg till den i listan.
klassspel (): def _init _ (self): … self.gameObjects.append (Player ())
Steg 5. Prova
Så här ska koden se ut nu:
importera pygame från pygame.locals import * upplösning = (400, 300) vit = (255, 255, 255) svart = (0, 0, 0) röd = (255, 0, 0) skärm = pygame.display.set_mode (upplösning) klass Boll: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw (self, surface): pygame.draw.circle (yta, svart, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 if (self.y <= 0 eller self.y> = resolution [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, surface): pygame.draw.circle (surface, red, (self.x, self.y), self.radius) def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_ läge (upplösning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))) def handleEvents (self): för händelse i pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): medan True: self.handleEvents () för gameObj i self.gameObjects: gameObj.update () self.screen.fill (vit) för gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). springa()
Del 6 av 8: Få objekt att interagera med spelaren
Steg 1. Ändra uppdateringsfunktionerna
För att objekt ska interagera måste de ha åtkomst till varandra. Låt oss lägga till en annan parameter till Uppdatera för att passera i listan med GameObjects. Du måste lägga till den i både spelarobjektet och bollobjekten. Om du har många spelobjekt kan arv hjälpa dig att hålla alla dina metodunderskrifter densamma.
klassboll:… def -uppdatering (self, gameObjects):… class Player:… def update (self, gameObjects):
Steg 2. Kontrollera om det finns kollisioner mellan spelaren och bollarna
Gå igenom alla spelobjekt och kontrollera om objektets typ är boll. Använd sedan de två objektens radier och avståndsformeln för att kontrollera om de kolliderar. Cirklar är verkligen enkla att kontrollera kollisioner på. Detta är den största anledningen till att du inte använde någon annan form för det här spelet.
klass Player:… def update (self, gameObjects):… för gameObj i gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Steg 3. Avsluta spelet om spelaren får "träff"
Låt oss bara avsluta spelet för tillfället.
if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Steg 4. Prova
Så här ska koden se ut nu:
importera pygame från pygame.locals import * upplösning = (400, 300) vit = (255, 255, 255) svart = (0, 0, 0) röd = (255, 0, 0) skärm = pygame.display.set_mode (upplösning) klass Boll: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw (self, surface): pygame.draw.circle (yta, svart, (self.x, self.y), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 if (self.y <= 0 or self.y> = resolution [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, surface): pygame.draw.circle (surface, red, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] för gameObj i gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () klassspel (): 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): för händelse i pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () för gameObj i self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (vit) för gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Del 7 av 8: Lägga till en spelkontroll för att skapa objekt
Steg 1. Skapa en spelkontrollklass
Spelkontrollanter är ansvariga för att "köra" spelet. Det skiljer sig från vår spelklass som ansvarar för att rita och uppdatera alla våra objekt. Kontrollen lägger regelbundet till en annan boll på skärmen för att göra spelet svårare. Lägg till en konstruktör och initiera några grundläggande värden. Intervallet är tiden innan ytterligare en boll läggs till.
klass GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "game controller"
Steg 2. Lägg till uppdateringsfunktionen
Detta kommer att kontrollera hur lång tid som har gått sedan tiden en boll tillsattes eller från spelets början. Om tiden är mer än intervallet återställer du tiden och lägger till en boll.
class GameController: … def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ()))
Steg 3. Ge bollarna slumpmässiga hastigheter
Du måste använda slumpmässiga nummer för att göra spelet annorlunda varje gång. Bollarnas hastigheter är emellertid nu ett flyttal i stället för ett heltal.
class GameController: … 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))
Steg 4. Fixa dragfunktionen
Draw -funktionen accepterar inte floats. Låt oss konvertera bollens position till heltal innan bollarna dras.
klass Boll: … def draw (själv, yta): pygame.draw.cirkel (yta, svart, (int (self.x), int (self.y)), self.radius)
Steg 5. Definiera en dragningsmetod för spelkontrollen
Eftersom det är ett spelobjekt kommer huvudslingan att försöka rita det. Du måste definiera en dragfunktion som inte gör något så att spelet inte kraschar.
klass GameController: … def draw (själv, skärm): pass
Steg 6. Lägg till spelkontrollen i gameObjects och ta bort de 2 bollarna
Spelet ska nu ge en boll var femte sekund.
klassspel (): def _init _ (self): … self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Steg 7. Prova
Så här ska koden se ut nu:
importera pygame från slumpmässig import slumpmässigt från pygame.locals import * upplösning = (400, 300) vit = (255, 255, 255) svart = (0, 0, 0) röd = (255, 0, 0) skärm = pygame. display.set_mode (upplösning) klass Boll: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw (self, surface): pygame.draw.circle (yta, svart, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self. x> = upplösning [0]): self.dx *= -1 if (self.y <= 0 eller self.y> = resolution [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, surface): pygame.draw.circle (yta, röd, (self.x), self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] for gameObj in game Objekt: if gameObj.type == "boll": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () klass GameController: def _init _ (self, interval = 5): self.inter = interval self.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 (själv, skärm): pass klassspel (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (upplösning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): för händelse i 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 (vit) för gameObj i self.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Del 8 av 8: Lägga till en poäng och ett spel över
Steg 1. Lägg till en poäng i spelkontrollklassen
Skapa ett teckensnittsobjekt och en poängvariabel. Du kommer att rita teckensnittet i varje ram för att visa poängen och öka poängen för varje bildruta i uppdateringen.
klass GameController: def _init _ (self, interval = 5):… self.score = 0 self.scoreText = pygame.font. Font (None, 12) def update (self, gameObjects):… self.score += 1 def draw (self, screen): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5))
Steg 2. Ändra hur spelet slutar
Låt oss bli av med avslutningen när spelaren upptäcker en kollision. Istället ställer du in en variabel i spelaren som spelet kan kontrollera. När gameOver är inställt, sluta uppdatera objekt. Detta kommer att frysa allt på plats så att spelaren kan se vad som hände och kontrollera deras poäng. Observera att objekten fortfarande ritas, bara inte uppdaterade.
klass Player: def _init _ (self, rad = 20):… self.gameOver = Falsk def update (self, gameObjects):… för gameObj i gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = True class game (): def _init _ (self): … self.gameOver = Falsk def run (self): medan True: self.handleEvents () om inte self.gameOver: för gameObj i self.gameObjects: gameObj.update (self.gameObjects) if gameObj.type == "player": self.gameOver = gameObj.gameOver
Steg 3. Prova
Så här ska den färdiga koden se ut nu:
importera pygame från slumpmässig import slumpmässigt från pygame.locals import * upplösning = (400, 300) vit = (255, 255, 255) svart = (0, 0, 0) röd = (255, 0, 0) skärm = pygame. display.set_mode (upplösning) klass Boll: def _init _ (self, xPos = resolution [0] / 2, yPos = resolution [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw (self, surface): pygame.draw.circle (yta, svart, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 eller self. x> = upplösning [0]): self.dx *= -1 if (self.y <= 0 eller self.y> = resolution [1]): self.dy *= -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = Falsk def draw (jag, yta): pygame.draw.cirkel (yta, röd, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] för gameObj i gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = TrueClass GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2*1000) self. type = "game controller" self.score = 0 self.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 + = 1 def draw (self, screen): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) klassspel (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (upplösning) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = False def handleEvents (self): för händelse i pygame.event.get (): om ev ent.type == QUIT: pygame.quit () def run (self): medan True: self.handleEvents () om inte self.gameOver: för gameObj i self.gameObjects: gameObj.update (self.gameObjects) if gameObj. typ == "spelare": self.gameOver = gameObj.gameOver self.screen.fill (vit) för gameObj i self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () spel (). kör ()
