Vuoi scrivere il tuo primo gioco ma non sai da dove cominciare con lo sviluppo? Pygame rimuove questa barriera. Scrivi in puro Python e vedi subito il risultato sullo schermo: uno sprite che si muove, la risposta agli input da tastiera, meccaniche vive. Niente motori pesanti, niente migliaia di righe di codice boilerplate.

Il problema della maggior parte dei tutorial è che o ti seppelliscono con 40 pagine di teoria o ti lasciano con un «completa tu». Qui prenderemo la via di mezzo: spiegheremo quanto basta per farti capire ogni riga e costruiremo subito un gioco funzionante con un personaggio che si muove sullo schermo usando WASD. L'intero codice sta in 60 righe.

💡 Panoramica rapida:

• Installa Pygame via pip e crea un file di gioco, ci vogliono un paio di minuti
• Comprendi il game loop: eventi, calcoli, rendering, tre fasi che vivono in un while True infinito
• Scrivi una classe giocatore e portala in vita: i tasti WASD muovono lo sprite, lo schermo si ridisegna 60 volte al secondo
• Comprendi il sistema di coordinate e la gestione dei colori, due pilastri che sorreggono qualsiasi grafica 2D

Cos'è Pygame e perché sceglierlo

Pygame è una libreria per Python che incapsula il multimedia SDL (Simple DirectMedia Layer) in una comoda API Python. SDL gestisce il lavoro di basso livello su grafica, audio e dispositivi di input, mentre Pygame fornisce l'accesso tramite classi e metodi familiari. La versione attuale, 2.6.0, è mantenuta attivamente e funziona su Windows, macOS e Linux.

Per i principianti, Pygame ha tre vantaggi innegabili. Primo, bassa barriera d'ingresso: usi normale codice Python, nessun nuovo linguaggio o editor visuale. Secondo, feedback immediato: scrivi pygame.draw.rect(...) e un rettangolo appare sullo schermo, nessuna magia. Terzo, comprensione delle fondamenta: Pygame non ti nasconde il game loop e la coda degli eventi, vedi come funziona dentro qualsiasi gioco. Dopo Pygame, passare a Godot o Unity sarà più facile perché sai già cosa sono il delta time e il polling degli eventi.

La libreria non cerca di essere un motore di gioco. Non ha un sistema di scene, fisica o un editor di livelli integrato, ed è una scelta deliberata. Controlli ogni pixel e ogni tick, il che significa che impari a pensare come uno sviluppatore di giochi, non come un operatore dello strumento di qualcun altro.

Installare Pygame in due minuti

Hai già Python 3.9 o più recente? Allora apri un terminale ed esegui un comando:

1
pip install pygame

Per l'isolamento del progetto, è meglio creare un ambiente virtuale:

1
python -m venv game_env
2
game_env\Scripts\activate     # Windows
3
source game_env/bin/activate  # macOS / Linux
4
pip install pygame

Verifica che la libreria sia installata:

1
import pygame
2
print(pygame.version.ver)

Se in risposta ottieni 2.6.0 (o più recente, puoi controllare la versione attuale su pygame.org), sei pronto. Crea una cartella di progetto, mettici dentro un'immagine sprite di 80×80 pixel chiamata player.png e un file di testo game.py, inizieremo da lì.

Come funziona il game loop: eventi, calcoli, rendering

Il cuore di qualsiasi gioco è il loop principale. Mentre il gioco è in esecuzione, dentro un while True infinito, si alternano tre fasi:

• Elaborazione degli eventi, cos'è successo dall'ultimo fotogramma? Tasto premuto? Mouse mosso? Finestra chiusa? Pygame raccoglie tutti gli eventi in una coda e noi la iteriamo con for event in pygame.event.get().

• Calcolo della logica, come è cambiato il mondo in risposta agli eventi? Il giocatore ha premuto W, incrementa la coordinata Y. Il proiettile ha colliso con l'asteroide, segna entrambi per la rimozione.

• Rendering, disegna tutto ciò che dovrebbe essere sullo schermo. Riempi lo sfondo, posiziona gli sprite alle nuove coordinate, chiama pygame.display.update() e il giocatore vede un fotogramma.

Questi tre passaggi si ripetono 60 volte al secondo, esattamente il framerate (FPS) che imposteremo sul timer. L'illusione del movimento si basa sullo sprite che si sposta di un paio di pixel tra un fotogramma e l'altro, mentre l'occhio percepisce questo come animazione continua.

Scrivere il primo codice: muovere uno sprite sullo schermo

Ecco il codice completo del gioco. Salvalo come game.py e metti player.png nella stessa cartella:

1
#!/usr/bin/env python3
2
 
3
import pygame
4
import sys
5
 
6
WIDTH, HEIGHT = 360, 480
7
WHITE = (255, 255, 255)
8
 
9
class Player(pygame.sprite.Sprite):
10
 
11
    def __init__(self, image_path):
12
        super().__init__()
13
        self.image = pygame.image.load(image_path)
14
        self.x = WIDTH / 2
15
        self.y = HEIGHT / 2
16
        self.speed = 5
17
 
18
    def move(self, dx, dy):
19
        self.x += dx
20
        self.y += dy
21
 
22
def main():
23
    pygame.init()
24
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
25
    pygame.display.set_caption("First Game on Pygame")
26
 
27
    clock = pygame.time.Clock()
28
    fps = 60
29
 
30
    player = Player("player.png")
31
    dx, dy = 0, 0
32
 
33
    running = True
34
    while running:
35
        for event in pygame.event.get():
36
            if event.type == pygame.QUIT:
37
                running = False
38
 
39
            elif event.type == pygame.KEYDOWN:
40
                if event.key == pygame.K_d:
41
                    dx = player.speed
42
                elif event.key == pygame.K_a:
43
                    dx = -player.speed
44
                elif event.key == pygame.K_w:
45
                    dy = -player.speed
46
                elif event.key == pygame.K_s:
47
                    dy = player.speed
48
 
49
            elif event.type == pygame.KEYUP:
50
                if event.key in (pygame.K_d, pygame.K_a):
51
                    dx = 0
52
                elif event.key in (pygame.K_w, pygame.K_s):
53
                    dy = 0
54
 
55
        player.move(dx, dy)
56
        screen.fill(WHITE)
57
        screen.blit(player.image, (player.x, player.y))
58
        pygame.display.update()
59
        clock.tick(fps)
60
 
61
    pygame.quit()
62
    sys.exit()
63
 
64
if __name__ == "__main__":
65
    main()

Esegui python game.py, si aprirà una finestra con sfondo bianco e il tuo sprite al centro. Tieni premuto W, A, S o D, il personaggio si muove. Rilascia il tasto, si ferma. Questo è già un gioco reale, seppur minimale.

Cosa è migliorato rispetto ai tutorial classici: è stato aggiunto il gestore KEYUP per il rilascio del tasto. Senza, lo sprite viaggerebbe fuori dallo schermo per sempre dopo la prima pressione. E il codice è racchiuso nel costrutto if __name__ == "__main__", una buona pratica che permette di importare il file come modulo senza avviare il gioco.

Sistema di coordinate e gestione dei colori

In Pygame, le coordinate si contano dall'angolo in alto a sinistra: (0, 0), l'estremo in alto a sinistra. Spostarsi a destra incrementa X, spostarsi in basso incrementa Y. Questo differisce dal sistema di coordinate scolastico dove Y cresce verso l'alto, basta ricordarlo e verificarlo nelle prime due esecuzioni: premi S, lo sprite va giù, premi W, va su.

Il colore è specificato da una tupla di tre numeri (R, G, B), ciascuno da 0 a 255. Il bianco corrisponde a (255, 255, 255), il nero a (0, 0, 0), il rosso a (255, 0, 0). Il metodo screen.fill(WHITE) riempie l'intero schermo con il colore selezionato prima di renderizzare ogni fotogramma. Se non lo fai, lo sprite lascerà una scia delle posizioni precedenti.

Cosa succede sotto il cofano: analisi riga per riga

La classe Player eredita da pygame.sprite.Sprite, la classe integrata di Pygame per gli oggetti di gioco. Nel costruttore, carichiamo l'immagine via pygame.image.load() e impostiamo la posizione iniziale al centro dello schermo: WIDTH / 2 e HEIGHT / 2. Il metodo move(dx, dy) riceve lo spostamento e lo somma alle coordinate attuali, pura aritmetica, nessuna magia.

La funzione main() mette tutto insieme. pygame.init() avvia i sottosistemi interni. pygame.display.set_mode() crea una finestra e screen è una Surface su cui disegniamo. pygame.time.Clock() crea un timer: il suo metodo tick(fps) alla fine del loop dice a Pygame «aspetta finché non è passato 1/60 di secondo dall'ultimo fotogramma», è così che fissiamo il framerate e non sprechiamo CPU.

Il loop principale while running gira finché il flag running non diventa False. Dentro, le tre fasi di cui abbiamo parlato sopra:

Nel loop for event in pygame.event.get(), esaminiamo la coda degli eventi. pygame.QUIT è il segnale «l'utente ha cliccato il pulsante di chiusura della finestra»: imposta running = False e all'iterazione successiva il loop terminerà. pygame.KEYDOWN scatta quando un tasto viene premuto e KEYUP quando viene rilasciato. Per D e A cambiamo dx, per W e S cambiamo dy. Quando il tasto viene rilasciato, azzeriamo la corrispondente componente di velocità, lo sprite si ferma.

screen.blit(player.image, (player.x, player.y)), il metodo che «sovrappone» un'immagine su un'altra. Nel nostro caso, lo sprite del giocatore sulla superficie principale dello schermo alle coordinate attuali. pygame.display.update() aggiorna la finestra e il giocatore vede il fotogramma finito.

Nota: player.move() viene chiamato prima di screen.fill(). Se li inverti, lo sprite verrà cancellato nello stesso millisecondo in cui appare, semplicemente non lo vedrai sullo schermo. L'ordine delle operazioni nel game loop è critico.

Clicca il pulsante di chiusura, pygame.quit() scarica correttamente i sottosistemi Pygame e sys.exit() termina il processo Python. Senza pygame.quit() la finestra può bloccarsi alla chiusura, un piccolo dettaglio, ma il codice dovrebbe essere pulito.

Breve video sull'argomento

Se l'istruzione testuale non ti è del tutto chiara, ecco un ottimo video corso in inglese dove costruiscono Space Invaders su Pygame passo dopo passo. Tutti i concetti dell'articolo sono mostrati dal vivo:

⁉️🤔 Domande frequenti

Devo conoscere la OOP per Pygame?

Sì, a un livello base. Classi, metodi, ereditarietà e self ti serviranno dal primo giorno: giocatore, nemici, proiettili e bonus si adattano naturalmente a un modello a oggetti. Se hai completato un qualsiasi corso introduttivo di Python che spiegava class e __init__, è sufficiente. Il resto lo imparerai strada facendo: Pygame non richiede design pattern, l'ereditarietà ordinaria da Sprite è sufficiente per dozzine di prototipi. Un oggetto di gioco in Pygame è una classe che eredita da pygame.sprite.Sprite. Nel costruttore, carichi lo sprite via pygame.image.load(), imposti coordinate e velocità iniziali. Il metodo update() (o uno tuo, come move()) cambia la posizione a ogni fotogramma. Il loop principale chiama update() su tutti gli oggetti, poi li renderizza via screen.blit(). Nessuna magia, solo chiamate a metodi nell'ordine giusto 60 volte al secondo.

Pygame rallenta con grafica 2D complessa?

Con un numero ragionevole di sprite, no. Le Surface in Pygame vivono nella RAM e blit è una veloce copia di pixel, non rendering software. Con un migliaio di oggetti in movimento simultaneo potresti raggiungere il limite di performance di Python, ma per un platform, uno sparatutto top-down o un tower defense c'è margine. Se hai bisogno di spremere il massimo delle performance, usa pygame.sprite.Group con rendering automatico e dirty rectangles per aggiornamenti parziali dello schermo.

Posso aggiungere audio e musica in Pygame?

Sì, nativamente. Il modulo pygame.mixer può riprodurre WAV e MP3. Un suono di sparo si lancia via pygame.mixer.Sound("shoot.wav").play() e la musica di sottofondo si carica con pygame.mixer.music.load("theme.mp3") e pygame.mixer.music.play(-1) (il flag -1 la manda in loop). Unica avvertenza: pygame.mixer.init() va chiamato prima di caricare i suoni e per gli MP3 su Linux potrebbe servire la libreria libmpg123.

Ha senso imparare Pygame nel 2026 quando esistono Godot e Unity?

Assolutamente sì. Pygame non è un concorrente di Godot, è uno strumento educativo e un layer leggero per prototipi 2D. Non impari C# solo per muovere un quadrato e non studi il sistema a nodi per Pong. Pygame ti dà la comprensione di come funzionano i giochi a un livello più basso: game loop, buffer dei fotogrammi, collisioni. I programmatori che hanno iniziato con Pygame trovano più facile Unity e Godot perché vedono le meccaniche vive dietro le astrazioni del motore. Progetti indie reali sono scritti in Pygame, inclusi quelli commerciali, un piccolo platform o puzzle può essere pubblicato su Steam senza toccare C++.

Cosa fare se lo sprite esce dallo schermo?

Aggiungi un controllo dei limiti al metodo move(): se self.x < 0, impostalo a 0; se self.x + sprite_width > WIDTH, impostalo a WIDTH - sprite_width. Lo stesso per Y. Questo si chiama clamping e senza di esso il personaggio finirà per viaggiare in un'area invisibile. Nei giochi più avanzati, i confini sono muri del livello definiti tramite una griglia di tile o un array di collisione.

Pronto a lanciare il tuo primo gioco?

Copia il codice dalla sezione «Scrivere il primo codice», salvalo come game.py, metti accanto un'immagine sprite qualsiasi e in pochi secondi vedrai una finestra con un personaggio in movimento. Questo è il punto d'ingresso nello sviluppo di giochi: non leggere, ma lanciare e iniziare a modificare i parametri.

Cambia WIDTH e HEIGHT, la finestra diventerà più grande. Imposta player.speed = 10, il personaggio accelererà. Sostituisci WHITE con (35, 35, 35), otterrai uno sfondo scuro. Sperimenta e capirai che un programma di gioco non è magia, ma una sequenza di passaggi che controlli tu.

Una volta padroneggiato il movimento, affronta le collisioni (pygame.sprite.collide_rect()), l'animazione (cambio di fotogramma dello sprite sheet) e la generazione procedurale dei livelli. Per iniziare bastano un file game.py e la voglia di capire come funziona.