Cheat sheet pygame
Ultimo aggiornamento
Setup e game loop
Ogni programma pygame apre una finestra e poi ripete un ciclo finché il giocatore non esce.
| Operazione | Codice |
|---|---|
| Installare pygame-ce | python3 -m pip install pygame-ce |
| Importare e avviare pygame | import pygame
pygame.init() |
| Aprire una finestra | screen = pygame.display.set_mode((640, 480)) |
| Impostare il titolo della finestra | pygame.display.set_caption("My Game") |
| Creare un clock | clock = pygame.time.Clock() |
| Il game loop | running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
screen.fill("black")
pygame.display.flip()
clock.tick(60) |
| Chiudere pygame dopo il ciclo | pygame.quit() |
Display
Lo schermo è una Surface; non si vede nulla finché non chiami flip.
| Operazione | Codice |
|---|---|
| Mostrare il frame completo | pygame.display.flip() |
| Mostrare solo alcune aree | pygame.display.update([rect1, rect2]) |
| Pulire lo schermo | screen.fill((30, 30, 46)) |
| Dimensioni della finestra | screen.get_size(), screen.get_width() |
| Lo schermo come Rect | screen.get_rect() |
| Finestra ridimensionabile | pygame.display.set_mode((640, 480), pygame.RESIZABLE) |
| Schermo intero alla risoluzione del desktop | pygame.display.set_mode((0, 0), pygame.FULLSCREEN) |
Colori e disegno
Le funzioni di pygame.draw prendono una superficie, un colore e una posizione. width=0 riempie.
| Operazione | Codice |
|---|---|
| Colore in RGB | (255, 140, 0) |
| Colore per nome o in esadecimale | "tomato", "#ff8c00", pygame.Color("gold") |
| Rettangolo | pygame.draw.rect(screen, "red", (x, y, w, h)) |
| Contorno e angoli arrotondati | pygame.draw.rect(screen, "red", rect, width=2, border_radius=8) |
| Cerchio (dal centro) | pygame.draw.circle(screen, "blue", (cx, cy), radius) |
| Linea | pygame.draw.line(screen, "white", (x1, y1), (x2, y2), 3) |
| Poligono | pygame.draw.polygon(screen, "green", [(0, 0), (40, 0), (20, 30)]) |
| Ellisse in un riquadro | pygame.draw.ellipse(screen, "purple", (x, y, w, h)) |
Rect
Un Rect memorizza una posizione e una dimensione come numeri interi.
| Operazione | Codice |
|---|---|
| Creare un Rect | player = pygame.Rect(x, y, width, height) |
| Posizionare da qualsiasi punto | player.center = (320, 240), player.bottom = 400 |
| Lati e angoli | left, right, top, bottom, topleft, midbottom |
| Spostare sul posto | player.move_ip(dx, dy) |
| Copia spostata | moved = player.move(dx, dy) |
| Tenere dentro lo schermo | player.clamp_ip(screen.get_rect()) |
| Ingrandire attorno al centro | bigger = player.inflate(20, 20) |
| Posizioni decimali (pygame-ce) | pygame.FRect(10.5, 20.25, 40, 40) |
Immagini, Surface e blit
Carica le immagini una volta, prima del ciclo, poi fai il blit a ogni frame.
| Operazione | Codice |
|---|---|
| Caricare un'immagine con trasparenza | img = pygame.image.load("player.png").convert_alpha() |
| Caricare un'immagine opaca | bg = pygame.image.load("sky.png").convert() |
| Disegnare un'immagine | screen.blit(img, (x, y)) |
| Disegnare centrata | screen.blit(img, img.get_rect(center=(320, 240))) |
| Nuova Surface vuota | panel = pygame.Surface((200, 100)) |
| Surface trasparente | layer = pygame.Surface((200, 100), pygame.SRCALPHA) |
| Rendere semitrasparente una Surface intera | img.set_alpha(128) |
| Ritagliare un frame da uno sprite sheet | frame = sheet.subsurface((0, 0, 32, 32)) |
| Salvare uno screenshot | pygame.image.save(screen, "shot.png") |
Trasformazioni
Ogni funzione restituisce una nuova Surface; trasforma l'originale, non l'ultimo risultato.
| Operazione | Codice |
|---|---|
| Ridimensionare | pygame.transform.scale(img, (64, 64)) |
| Scalare di un fattore | pygame.transform.scale_by(img, 2) |
| Ridimensionare con smussatura | pygame.transform.smoothscale(img, (64, 64)) |
| Ruotare (senso antiorario, in gradi) | pygame.transform.rotate(img, 45) |
| Ruotare attorno al centro | rotated = pygame.transform.rotate(original, angle)
rect = rotated.get_rect(center=rect.center) |
| Specchiare in orizzontale | pygame.transform.flip(img, True, False) |
Eventi e tastiera
Usa gli eventi per le singole pressioni e get_pressed() per i tasti tenuti premuti.
| Operazione | Codice |
|---|---|
| Leggere gli eventi del frame | for event in pygame.event.get(): |
| Finestra chiusa | event.type == pygame.QUIT |
| È stato premuto un tasto | event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE |
| È stato rilasciato un tasto | event.type == pygame.KEYUP |
| Carattere digitato | event.unicode |
| Tasti premuti ora | keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
x -= 5 |
| Direzione da due tasti | dx = keys[pygame.K_RIGHT] - keys[pygame.K_LEFT] |
| Tasti premuti in questo frame (pygame-ce) | pygame.key.get_just_pressed()[pygame.K_SPACE] |
| Costanti dei tasti | K_a...K_z, K_0...K_9, K_UP, K_RETURN, K_ESCAPE, K_LSHIFT |
| Nome di un tasto | pygame.key.name(event.key) |
| Evento personalizzato | HIT = pygame.event.custom_type()
pygame.event.post(pygame.event.Event(HIT)) |
Mouse
Pulsanti: 1 sinistro, 2 centrale, 3 destro.
| Operazione | Codice |
|---|---|
| È stato premuto un pulsante | event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 |
| Dove è stato premuto | event.pos |
| Posizione attuale del puntatore | x, y = pygame.mouse.get_pos() |
| Pulsanti premuti ora | left, middle, right = pygame.mouse.get_pressed() |
| Il mouse si è mosso | event.type == pygame.MOUSEMOTION, event.rel |
| La rotella è girata | event.type == pygame.MOUSEWHEEL, event.y |
| Clic dentro un pulsante | button_rect.collidepoint(event.pos) |
| Nascondere il puntatore | pygame.mouse.set_visible(False) |
Sprite e gruppi
Uno sprite contiene una image e un rect; un gruppo ne aggiorna e disegna molti.
| Operazione | Codice |
|---|---|
| Classe sprite | class Coin(pygame.sprite.Sprite):
def __init__(self, pos):
super().__init__()
self.image = coin_img
self.rect = self.image.get_rect(center=pos) |
| Creare un gruppo | coins = pygame.sprite.Group() |
| Aggiungere a un gruppo | coins.add(Coin((100, 50))) |
| Aggiornare tutti gli sprite | coins.update() |
| Disegnare tutti gli sprite | coins.draw(screen) |
| Togliere uno sprite da tutti i gruppi | coin.kill() |
| Gruppo con un solo sprite | player = pygame.sprite.GroupSingle(Player()) |
Collisioni
Due Rect collidono quando si sovrappongono; i bordi che si toccano soltanto non contano.
| Operazione | Codice |
|---|---|
| Due rettangoli | a.colliderect(b) |
| Punto all'interno | rect.collidepoint(x, y) |
| Il primo di una lista | rect.collidelist(walls) # index or -1 |
| Sprite contro un gruppo | hits = pygame.sprite.spritecollide(player, coins, True) |
| Almeno una collisione | pygame.sprite.spritecollideany(player, enemies) |
| Gruppo contro gruppo | pygame.sprite.groupcollide(bullets, enemies, True, True) |
| Al pixel | pygame.sprite.spritecollide(a, group, False, pygame.sprite.collide_mask) |
| Cerchi | pygame.Vector2(a).distance_to(b) < r1 + r2 |
Testo e font
Esegui il render del testo su una Surface, poi fai il blit.
| Operazione | Codice |
|---|---|
| Font predefinito | font = pygame.font.Font(None, 36) |
| Font di sistema | font = pygame.font.SysFont("arial", 24) |
| File di font | font = pygame.font.Font("pixel.ttf", 32) |
| Render del testo | text = font.render("Score: 10", True, "white") |
| Disegnarlo centrato | screen.blit(text, text.get_rect(center=(320, 40))) |
| Andare a capo nei testi lunghi (pygame-ce) | font.render(story, True, "white", None, 400) |
| Dimensioni senza render | font.size("Hello") |
| Font installati | pygame.font.get_fonts() |
Suoni e musica
Carica i suoni una volta. La musica riproduce una traccia in streaming dal suo file.
| Operazione | Codice |
|---|---|
| Caricare un suono | jump = pygame.mixer.Sound("jump.ogg") |
| Riprodurlo | jump.play() |
| Volume del suono | jump.set_volume(0.5) |
| Caricare la musica | pygame.mixer.music.load("theme.ogg") |
| Musica in loop infinito | pygame.mixer.music.play(-1) |
| Pausa e ripresa | pygame.mixer.music.pause(), pygame.mixer.music.unpause() |
| Fermare la musica | pygame.mixer.music.stop() |
Tempo e timer
I tick sono in millisecondi.
| Operazione | Codice |
|---|---|
| Limitare il frame rate | clock.tick(60) |
| Delta time in secondi | dt = clock.tick(60) / 1000 |
| Frame rate attuale | clock.get_fps() |
| Millisecondi da init | pygame.time.get_ticks() |
| Evento timer ripetuto | SPAWN = pygame.event.custom_type()
pygame.time.set_timer(SPAWN, 1000) |
| Timer singolo | pygame.time.set_timer(SPAWN, 2000, loops=1) |
| Fermare un timer | pygame.time.set_timer(SPAWN, 0) |
Vector2
Numeri decimali per posizioni e velocità.
| Operazione | Codice |
|---|---|
| Creare un vettore | pos = pygame.Vector2(100, 200) |
| Muovere in base a una velocità | pos += velocity * dt |
| Lunghezza | velocity.length() |
| Stessa velocità in diagonale | if direction.length() > 0:
direction = direction.normalize() |
| Distanza tra due punti | pos.distance_to(target) |
| Ruotare | velocity.rotate(90) |
| Avanzare verso un punto (pygame-ce) | pos.move_towards_ip(target, 5) |
Il codice pygame che ti serve mentre crei un gioco 2D in Python, diviso per attività: il game loop, il display, colori e disegno, Rect, immagini e blit, ridimensionamento e rotazione, input da tastiera e mouse, sprite e gruppi, collisioni, testo, suoni, timer e Vector2. Ogni riga è un breve frammento da incollare, accanto a quello che fa.
Tutto è scritto per pygame-ce 2.5, l'edizione della community di pygame, che si importa sempre con import pygame. Le righe con pygame-ce usano le sue aggiunte; tutte le altre funzionano anche nel pygame originale. Prova qualsiasi frammento nel playground di pygame, che esegue pygame nel browser senza installare nulla. Sei alle prime armi con Python? Parti dal cheat sheet di Python.
Domande frequenti sul cheat sheet di pygame
Questo cheat sheet di pygame è gratuito?
Sì. È gratuito e non serve registrarsi. Salvalo nei preferiti, o stampalo in PDF dal browser, e torna quando ti serve la chiamata esatta per un gruppo di sprite, un suono o un controllo di collisione.
Questo cheat sheet funziona con pygame e pygame-ce?
Sì. Entrambi si importano con
import pygame e condividono quasi tutta l'API. Le righe con pygame-ce (FRect, scale_by, get_just_pressed, l'a capo del testo e move_towards_ip) richiedono pygame-ce, e tutto il resto funziona con entrambi.Perché la mia finestra pygame non risponde?
Il game loop non legge gli eventi. Chiama
pygame.event.get() una volta a ogni frame, anche se ignori gli eventi, e chiudi ogni frame con pygame.display.flip() e clock.tick(60).Meglio usare gli eventi o key.get_pressed() per l'input?
Usa un evento
KEYDOWN per le azioni che avvengono una volta per pressione, come saltare o aprire un menu. Usa pygame.key.get_pressed() per le azioni che durano finché un tasto resta premuto, come camminare.Risorse correlate
Altre cheat sheet
