Realizziamo il semplice gioco acchiappa il fantasma con pygame, utilizzando gli strumenti appresi finora.
Più avanti perfezioneremo il gioco utilizzando gli sprite e altri metodi, per il momento mi preme far vedere come, con semplici strumenti, si può realizzare il nostro giochino.
Gioco acchiappa il fantasma con pygame
Creiamo il nostro fantasma con sfondo trasparente e salviamo l’immagine con estensione .png nella cartella images.
Dopo impostiamo il colore di sfondo grigio scuro e la finestra di dimensione 800 x 600 pixel con il titolo Ghost.
Poi inseriamo l’immagine e la memorizziamo in una variabile di nome ghost.
Introduciamo due nuovi metodi convert() e convert_alpha() che trasformano il formato interno della Surface in un formato ottimizzato e più veloce per essere disegnato dalla blit().
Il metodo convert_alpha si usa con le immagini con lo sfondo trasparente, proprio come nel nostro caso.
Dopo utilizziamo il metodo get_rect() dell’oggetto Surface, per ottenere un Rect con le stesse dimensioni della Surface. Questo ci permette di utilizzare in seguito il metodo collidepoint che ci serve per verificare se abbiamo cliccato l’immagine.
Generiamo le coordinate x e y con la funzione random per generare una posizione a caso del nostro fantasma di volta in volta.
Utilizziamo il metodo Clock e impostiamo il frame rate (FPS) a 1, ovvero il numero di frame al secondo. Dunque useremo il metodo tick() come ultima istruzione del ciclo principale.
Ecco dunque il codice completo:
import pygame, sys, random
pygame.init()
GREY=(108, 108, 108)
screen=pygame.display.set_mode((800, 600))
pygame.display.set_caption('Ghost')
screen.fill(GREY)
ghost=pygame.image.load('images/fantasma.png').convert_alpha()
p=ghost.get_rect()
x=random.randint(0,700)
y=random.randint(0,500)
p.x=x
p.y=y
screen.blit(ghost,p)
FPS=1
cl=pygame.time.Clock()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
click = event.pos
if p.collidepoint(event.pos):
print("Hai cliccato l\'immagine")
else:
print ("Hai cliccato fuori")
screen.fill(GREY)
x=random.randint(0,700)
y=random.randint(0,500)
p.x=x
p.y=y
screen.blit(ghost,p)
pygame.display.update()
cl.tick(FPS)
Possiamo anche generare un sistema a punti, creando una variabile che si incrementa ogni volta che si clicca sul fantasma. Ad ogni clic sul fantasma incrementiamo anche l’FPS di 0.1, in modo da rendere il clic successivo più difficile.
Ecco quindi il codice modificato:
import pygame, sys, random
pygame.init()
GREY=(108, 108, 108)
screen=pygame.display.set_mode((800, 600))
pygame.display.set_caption('Ghost')
screen.fill(GREY)
ghost=pygame.image.load('images/fantasma.png').convert_alpha()
p=ghost.get_rect()
x=random.randint(0,700)
y=random.randint(0,500)
p.x=x
p.y=y
screen.blit(ghost,p)
punti=0
FPS=1
cl=pygame.time.Clock()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
click = event.pos
if p.collidepoint(event.pos):
punti+=1
print(punti)
FPS+=0.1
screen.fill(GREY)
x=random.randint(0,700)
y=random.randint(0,500)
p.x=x
p.y=y
screen.blit(ghost,p)
pygame.display.update()
cl.tick(FPS)
Abbiamo realizzato questo semplice gioco ‘acchiappa il fantasma con pygame‘, nella prossima lezione vedremo come scrivere nella finestra, in modo da visualizzare il punteggio ottenuto.
In questa lezione utilizzeremo alcuni metodi dell’oggetto Rect, al fine di implementare qualche esempio.
In particolare vedremo i metodi move, move_ip e collidepoint.
Metodi dell’oggetto Rect – move_ip
In questo primo esempio utilizzeremo il metodo move_ip() per spostare il rettangolo creato utilizzando i tasti della tastiera, ad esempio K_UP, K_DOWN, K_LEFT, K_RIGHT.
Quindi quando clicchiamo su K_UP, sposteremo il rettangolo verso l’alto, cioè imposteremo ad esempio move_ip(0,-5) . In questo modo sposteremo solo la y di -5.
Invece quando clicchiamo su K_DOWN, sposteremo il rettangolo verso il basso, cioè imposteremo ad esempio move_ip(0,5) . In questo modo sposteremo solo la y di 5.
Poi, quando clicchiamo su K_LEFT, sposteremo il rettangolo verso sinistra, cioè imposteremo ad esempio move_ip(-5,0) . In questo modo sposteremo solo la x di -5.
Infine, quando clicchiamo su K_RIGHT, sposteremo il rettangolo verso destra, cioè imposteremo ad esempio move_ip(5,0) . In questo modo sposteremo solo la x di 5.
Ecco dunque un esempio completo:
import pygame, sys
from pygame.locals import *
pygame.init()
screen=pygame.display.set_mode((800, 600))
pygame.display.set_caption('Oggetto Rect')
CYAN=(0,255,255)
RED=(255,0,0)
r1=pygame.Rect(20,20,30,30)
s=pygame.Surface((30,30))
s.fill(RED)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
r1.move_ip(0, -5)
elif event.key == pygame.K_DOWN:
r1.move_ip(0, 5)
elif event.key == pygame.K_LEFT:
r1.move_ip(-5, 0)
elif event.key == pygame.K_RIGHT:
r1.move_ip(5, 0)
screen.fill(CYAN)
screen.blit(s,r1)
pygame.display.update()
Move
Utilizziamo il metodo move() per spostare in maniera dinamica il nostro rettangolo rosso, di dimensione 30 x 30 pixel, al clic del mouse.
All’interno delle parentesi mettiamo le coordinate ottenute con il clic del mouse: event.pos.
Ecco quindi l’esempio completo:
import pygame, sys, random
pygame.init()
screen=pygame.display.set_mode((800, 600))
pygame.display.set_caption('Oggetto Rect')
CYAN=(0,255,255)
RED=(255,0,0)
w=30
l=30
r1=pygame.Rect(0,0,w,l)
s=pygame.Surface((w,l))
s.fill(RED)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
r1=pygame.Rect(0,0,w,l)
s=pygame.Surface((w,l))
s.fill(RED)
r1=r1.move(event.pos)
screen.fill(CYAN)
screen.blit(s,r1)
pygame.display.update()
Quindi, dopo aver avviato il programma, fate la prova a cliccare in un punto qualsiasi con il pulsante sinistro del mouse, vedrete che il rettangolo si sposterà nella nuova posizione.
Collidepoint
In questo secondo esempio utilizzeremo il metodo collidepoint per verificare se abbiamo fatto clic all’interno del rettangolo rosso.
L’attributo pos serve a determinare la posizione, cioè le coordinate x e y, del clic effettuato con il mouse. Infatti event.pos[0] mi restituisce la coordinata x, mentre event.pos[1] mi restituisce la y.
Ecco quindi l’esempio completo:
import pygame, sys
pygame.init()
screen=pygame.display.set_mode((800, 600))
pygame.display.set_caption('Oggetto Rect')
CYAN=(0,255,255)
RED=(255,0,0)
r1=pygame.Rect(20,20,30,30)
s=pygame.Surface((30,30))
s.fill(RED)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
click = event.pos
if r1.collidepoint(click):
print("Hai cliccato il quadrato rosso")
else:
print ("Hai cliccato fuori")
screen.fill(CYAN)
screen.blit(s,r1)
pygame.display.update()
In questa lezione studieremo l’oggetto Rect, un oggetto geometrico astratto caratterizzato dalla posizione e dalla lunghezza dei lati.
Per creare un Rect si utilizza il costruttore Rect():
pygame.Rect(x,y,w,h) – dove x e y sono le coordinate dell’angolo in alto a sinistra, mentre w ed h sono la larghezza e l’altezza del rettangolo
pygame.Rect((x,y),(w,h)) – i parametri hanno lo stesso significato dell’esempio sopra.
Quindi ad esempio:
pygame.Rect(0,0,250,120) – Avrò un rettangolo posizionato nel punto (0,0) di larghezza 250 pixel e altezza 120.
Attributi oggetto Rect
L’oggetto Rect ha tanti attributi che possono essere utilizzati per muovere o allineare il rettangolo.
Supponiamo quindi che r1=pygame.Rect(20,50,250,120):
.lefto anche .x – Indica la x del lato sinistro. Allora r1.left=20.
.right– Indica la x del lato destro. Allora r1.right=270 cioè x che è uguale a 20 + la larghezza del rettangolo 250.
.top o anche .y – Indica la y del lato superiore. Dunque r1.top=50.
.topleft – Indica le coordinate dell’angolo in alto a sinistra. Quindi r1.topleft=(20,50).
.topright – Indica le coordinate dell’angolo in alto a destra. Allora r1.topright=(270,50).
.bottom– Indica la y del lato inferiore. Dunque r1.bottom=50.
.bottomleft – Indica le coordinate dell’angolo in basso a sinistra. Allora r1.bottomleft=(20,170).
.bottomright – Indica le coordinate dell’angolo in basso a destra. Dunque r1.bottomright=(270,170).
.center – Indica le coordinate del centro del rettangolo. Allora x sarà la metà di 250 più 20, cioè 145, mentre y sarà la metà di 120 più 50, cioè 110. Dunque r1.center=(145,110).
.centerx – Indica la coordinata x del centro del rettangolo. Quindi per quanto spiegato prima r1.centerx=145.
.centery – Indica la coordinata y del centro del rettangolo. Allora r1.centery=110.
.midtop – Indica le coordinate al centro del lato superiore. Allora r1.midtop=(145, 50).
.midbottom – Indica le coordinate al centro del lato inferiore. Quindi r1.midbottom=(145, 170).
.midleft – Indica le coordinate al centro del lato sinistro. Dunque r1.midleft=(20, 110).
.midright– Indica le coordinate al centro del lato destro. Allora r1.midright=(270, 110).
.size – Indica le dimensioni, cioè la larghezza e l’altezza del rettangolo. Quindi r1.size=(250,120).
.width – Indica la larghezza del rettangolo. Allora r1.width=250.
.left – Indica l’altezza del rettangolo. Quindi r1.height=120.
Realizziamo un semplice programma che al clic del mouse mi restituisce i valori degli attributi di Rect.
Come detto Rect è un oggetto astratto, quindi abbiamo bisogno di un oggetto fisico come la Surface, che rappresenta la porzione di schermo sulla quale disegnare per visualizzare ad esempio un rettangolo.
Quindi: r1=pygame.Rect(20,50,250,120) è l’oggetto astratto.
Dopo utilizziamo s=pygame.Surface((250, 120)) e screen.blit(s,r1) per ottenere l’oggetto fisico.
In questa lezione impareremo ad inserire immagini in pygame.
Innanzitutto presentiamo la funzione che serve a caricare un’immagine, cioè la funzione load che si trova nel sotto modulo image: pygame.image.load().
All’interno delle parentesi si indica il nome dell’immagine, facendo attenzione ad indicare il percorso esatto se l’immagine non è nella stessa cartella del file che creeremo.
Ecco dunque un esempio:
auto=pygame.image.load('images/auto.png')
Possiamo invece utilizzare pygame.transform.scale per ridimensionare un’immagine, anche se non è la scelta migliore da fare. Infatti le immagini vanno scalate con appositi programmi prima di caricarle.
auto=pygame.transform.scale(auto,(300, 150))
Inserire immagini in pygame e muoverle
Realizziamo adesso un semplice esempio in cui carichiamo un’immagine e dopo la sposteremo dalla posizione iniziale.
Innanzitutto prendiamo un’immagine a piacere e la carichiamo con la funzione load. Dopo stabiliamo le coordinate iniziali x e y.
Poi realizziamo gli eventi legati ai pulsanti freccia su, freccia giù, freccia a sinistra e freccia a destra, variando di conseguenza le coordinate quando premiamo i tasti. Possiamo omettere il print che spiega cosa succede quando premiamo il pulsante specificato, l’ho inserito solo a scopo dimostrativo.
Per rendere effettive le modifiche inseriamo pygame.display.update().
Ecco dunque il codice completo.
import pygame, sys
from pygame.locals import *
pygame.init()
screen=pygame.display.set_mode((800, 600))
pygame.display.set_caption('Muovere immagini')
CYAN=(0,255,255)
car=pygame.image.load('images/car.png')
x=10
y=50
while True:
screen.fill(CYAN)
screen.blit(auto, (x,y))
for event in pygame.event.get():
if event.type==pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
print('Vai su')
y-=5
elif event.key == pygame.K_DOWN:
print('Vai giù')
y+=5
elif event.key == pygame.K_LEFT:
print('Vai a sinistra')
x-=5
elif event.key == pygame.K_RIGHT:
print('Vai a destra')
x+=5
pygame.display.update()
Immagini in movimento
Realizziamo adesso un esempio creando un’immagine in movimento.
Utilizziamo l’oggetto Clock, un oggetto utilizzato per misurare i millesimi di secondo.
Specifichiamo l’FPS, ovvero il numero di frame in un secondo, che verrà passato come argomento al metodo tick().
Il metodo tick lo chiameremo per ultimo e si occupa di arrestare il movimento per il tempo necessario ad ottenere la temporizzazione.
Utilizziamo una variabile d che sta per direzione a cui faremo assumere i valori tra 1 e 4. Il valore 1 sta ad indicare che l’oggetto si muoverà a destra, il valore 2 indica che l’oggetto si muoverà sotto, il valore 3 indica invece che l’oggetto si muoverà a sinistra, infine il valore 4 indica che l’oggetto si muoverà su.
Ecco dunque il codice completo:
import pygame, sys
pygame.init()
YELLOW=(255, 255, 0)
screen=pygame.display.set_mode((800, 600), 0, 32)
pygame.display.set_caption('Animation')
ball=pygame.image.load('images/palla.png')
x=0
y=0
d=1
FPS=20
cl=pygame.time.Clock()
while True:
screen.fill(YELLOW)
screen.blit(ball, (x, y))
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if d==1: #va a destra
x += 10
if x==300:
d=2 #imposta la direzione per andare giù
elif d==2: #va giù
y+=10
if y==300:
d=3 #imposta la direzione per andare a sinistra
elif d==3: #va a sinistra
x-=10
if x==0:
d=4 #imposta la direzione per andare sotto
elif d==4: #va su
y -= 10
if y==0:
d=1
pygame.display.update()
cl.tick(FPS)
In questa lezione studieremo gli eventi in pygame, necessari per interagire con il nostro programma.
Per capire come funzionano gli eventi facciamo un semplice esempio.
Quando lavoriamo al computer il sistema operativo gestisce e controlla tutto, se facciamo clic con il mouse, se premiamo un tasto sulla nostra tastiera, ecc.
Dunque, quando facciamo qualcosa, il sistema operativo genera un evento di sistema, cioè in poche parole crea un messaggio con le informazioni di ciò che è accaduto. Questi messaggi vengono poi messi in una coda, in ordine di arrivo, in quanto ci possono essere tanti eventi di sistema.
Le applicazioni che ricevono questi messaggi possono ignorarli oppure esaminarli per capire cosa fare.
Eventi in pygame con l’oggetto Event
Pygame ha l’oggetto Event, quindi registra gli eventi dell’utente in una coda di eventi che può essere ricevuta con il codice pygame.event.get().
Dunque ad esempio proviamo a scrivere questo semplice programma:
import pygame
pygame.init()
pygame.display.set_mode((800, 600))
#riceviamo gli eventi
for event in pygame.event.get():
print("Evento: ", event)
Adesso provate questo codice, potete notare che compariranno tutti gli eventi che si sono generati per aprire la finestra che abbiamo creato con set_mode.
Ma il programma così costruito non continua a registrare eventi.
Per fare ciò abbiamo bisogno di un altro ciclo esterno che quando termina gli eventi precedenti, registra quelli nuovi.
Quindi modificate il codice in questo modo:
import pygame
pygame.init()
pygame.display.set_mode((800, 600))
#riceviamo e rigeneriamo nuovi eventi
while True:
for event in pygame.event.get():
print('Evento: ', event)
In questo modo se ad esempio muoviamo il mouse noteremo che i nuovi eventi saranno stampati nella finestra di output.
Attributo type
L’attributo type contiene il tipo dell’evento, ad esempio:
QUIT – per indicare che è stato fatto clic sull’icona per chiudere la finestra.
MOUSEMOTION– è stato mosso il mouse.
MOUSEBUTTONDOWN– è stato premuto un bottone del mouse.
MOUSEBUTTONUP– è stato rilasciato il bottone del mouse.
KEYDOWN– è stato premuto un tasto della tastiera.
KEYUP– è stato rilasciato un tasto della tastiera.
Esempio con QUIT
Possiamo fare in modo di uscire dal programma utilizzando il type QUIT, cambiando la variabile t a False quando si clicca sull’icona per chiudere la finestra:
import pygame
pygame.init()
pygame.display.set_mode((800, 600))
t=True
while t:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
t=False
La funzione pygame.quit() serve per terminare il programma.
Si può anche importare il modulo sys ed utilizzare sys.exit():
import pygame, sys
pygame.init()
pygame.display.set_mode((800, 600))
while True:
for event in pygame.event.get():
if event.type==pygame.QUIT:
pygame.quit()
sys.exit()
Esempi con MOUSEBUTTONDOWN e MOUSEBUTTONUP
Button è un numero intero e rappresenta quindi il pulsante premuto.
Con 1 si indica il pulsante sinistro, con 3 il pulsante destro mentre con 2 la pressione sulla rotella del mouse, con 4 lo spostamento della rotellina verso l’alto e con 5 lo spostamento della rotellina verso il basso.
import pygame, sys
pygame.init()
pygame.display.set_mode((800, 600))
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
print('Left button')
elif event.button == 3:
print('Right button')
elif event.type == pygame.MOUSEBUTTONUP:
print('Pulsante rilasciato')
Facciamo adesso un secondo esempio d’uso di MOUSEBUTTONDOWN dove visualizzeremo le coordinate x e y al clic del mouse.
import pygame, sys
pygame.init()
pygame.display.set_mode((800, 600))
while True:
for event in pygame.event.get():
if event.type==pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
p_x = event.pos[0]
p_y = event.pos[1]
print('Hai fatto click in x =',p_x,' e y =',p_y)
Esempi con MOUSEMOTION
MOUSEMOTION viene ricevuto quando spostiamo il mouse sul display.
Ha gli attributi:
pos che rappresenta la posizione assoluta in pixel del cursore e
rel che è la posizione relativa a quella precedente.
Quindi se rel [0] è maggiore di zero vuol dire che ci siamo spostati a destra, invece se è minore a sinistra.
Se invece rel [1] è maggiore di zero vuol dire che ci siamo spostati in basso, al contrario se è minore in alto.
import pygame, sys
pygame.init()
pygame.display.set_mode((800, 600))
while True:
for event in pygame.event.get():
if event.type==pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEMOTION:
if event.rel[0] > 0:
print('Ti stai spostando a destra')
elif event.rel[0] < 0:
print('Ti stai spostando a sinistra')
elif event.rel[1] > 0:
print('Ti stai spostando sotto')
elif event.rel[1] < 0:
print('Ti stai spostando sopra')
Esempi con KEYDOWN
L’evento keydown ha un attributo key che è un numero intero e rappresenta un tasto della tastiera. Indica quindi quale tasto è stato premuto.
Ad esempio con:
k_UP si indica la freccia in alto,
k_DOWN la freccia in basso,
k_ESCAPE il tasto ESC,
k_TAB il pulsante TAB,
k_w la lettera w della tastiera, ecc…
Ecco dunque un semplice esempio:
import pygame, sys
pygame.init()
pygame.display.set_mode((800, 600))
while True:
for event in pygame.event.get():
if event.type==pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_w:
print('Vai su')
elif event.key == pygame.K_a:
print('Vai a sinistra')
elif event.key == pygame.K_s:
print('Vai giù')
elif event.key == pygame.K_d:
print('Vai a destra')
Facciamo adesso un altro esempio, stampando il carattere se l’attributo unicode contiene effettivamente un carattere.
import pygame, sys
pygame.init()
pygame.display.set_mode((800, 600))
while True:
for event in pygame.event.get():
if event.type==pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
if (len(event.unicode)) == 1:
print(event.unicode)
else:
print('Non stampabile')
In questa lezione vedremo come costruire altre Surface, cioè delle aree su cui disegnare.
Possiamo creare altre Surface con la funzione costruttore, ricordiamo che nei linguaggi OOP ogni oggetto ha una particolare funzione, chiamata costruttore, che è designata a creare un’istanza dell’oggetto.
Il costruttore ha il medesimo nome dell’oggetto e se è contenuto in un sotto modulo di pygame si chiama anteponendo pygame ed il nome del sotto modulo.
Se provate ad eseguire il programma otterrete questo risultato:
Per realizzare questo esempio innanzitutto abbiamo creato una nuova Surface quadrata di 100 x 100 pixel e abbiamo assegnato questa Surface alla variabile surf. Dopo la coloriamo di colore bianco con il metodo fill e disegniamo un cerchio utilizzando il sotto modulo draw.
Allo stesso modo abbiamo creato altre due Surface e le abbiamo assegnate alle variabili surf2 e surf3 . Quindi le abbiamo colorate e abbiamo disegnato dei poligoni dentro queste Surface.
Dopo abbiamo utilizzato il metodo blit, su surf, surf2 e surf3, dell’oggetto Surface, che serve a rendere visibile le Surface che abbiamo creato.
