pygame Tutorial
Iniziare con pygame

Osservazioni

Versioni

Un semplice 'gioco'

Importa e inizializza

Ogni modulo deve essere importato e pygame non fa eccezione. Sebbene sia necessario inizializzare correttamente la funzione pygame.init() per tutti i moduli importati in pygame. Se dimentichiamo che alcuni moduli non funzioneranno. La funzione restituisce anche una tupla di tutte le inizializzazioni riuscite e fallite (non genera un errore se un modulo non riesce a inizializzarsi).

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))

Crea necessità

Abbiamo anche bisogno di creare un display. Pygame ha già creato un display (nascosto), quindi tutto ciò che dobbiamo fare è impostare la modalità del display (in questo esempio impostiamo solo la risoluzione). È anche una buona idea creare un orologio per assicurarci che il nostro programma si aggiorni a una velocità fissa (altrimenti funzionerebbe a velocità diverse a seconda della velocità del computer).

screen = pygame.display.set_mode((720, 480))  # Notice the tuple! It's not 2 arguments.
clock = pygame.time.Clock()
FPS = 60  # This variable will define how many frames we update per second.

Per un po 'di leggibilità più avanti nel nostro codice creeremo due costanti di colore, che rappresentano una tupla di rosso, verde e blu (RGB). I valori vanno da 0 (nessuna luce) a 255 (luce piena).

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

In pygame usiamo solitamente una superficie per rappresentare l'aspetto di un oggetto e un rettangolo ( Rect ) per rappresentare la posizione di un oggetto. Una superficie è come un foglio di carta bianco che contiene colori o immagini. Se stai facendo una lezione dovresti nominare gli attributi image e rect poiché molte funzioni cercheranno e useranno quegli attributi. Tali classi trarrebbero vantaggio ereditando la classe pygame.sprite.Sprite per motivi che puoi leggere qui .

rect = pygame.Rect((0, 0), (32, 32))  # First tuple is position, second is size.
image = pygame.Surface((32, 32))  # The tuple represent size.
image.fill(WHITE)  # We fill our surface with a nice white color (by default black).

Il ciclo di gioco

Ora abbiamo tutto pronto per il nostro ciclo di gioco. Questo è un ciclo che verrà eseguito per l'intero gioco, dove gestiamo eventi e aggiorniamo lo schermo e le posizioni dei nostri oggetti.

Per prima cosa ci assicureremo che il nostro ciclo venga eseguito a un determinato FPS . Abbiamo definito l' FPS e creato il nostro orologio all'inizio del programma. Il seguente codice farà in modo che il nostro programma abbia abbastanza tempo per fare in modo che il nostro loop ripeta la quantità che abbiamo definito il nostro FPS . In questo esempio, 60 volte al secondo.

clock.tick(FPS)

Quindi gestiremo eventi. Un evento è fondamentalmente un'azione dell'utente, come lo spostamento del mouse o la pressione di un tasto. Pygame registrerà tutti questi eventi in una coda che otteniamo chiamando pygame.event.get() . Possiamo iterare su questo e controllare se c'è un evento che vorremmo gestire. Gli eventi hanno un attributo type che possiamo controllare rispetto alle costanti nel modulo pygame per determinare quale tipo di evento sia.

for event in pygame.event.get():
    if event.type == pygame.QUIT:  # The user pressed the close button in the top corner of the window.
        quit()
        # Close the program. Other methods like 'raise SystemExit' or 'sys.exit()'.
        # Calling 'pygame.quit()' won't close the program! It will just uninitialize the modules.

Possiamo anche controllare if event.type == pygame.KEYDOWN per vedere se l'utente ha premuto un tasto. In tal caso l'evento ha una chiave di attributo che possiamo controllare per vedere quale chiave rappresenta.

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        quit()
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_w:
            rect.move_ip(0, -2)  # Changes the rect's position.
        elif event.key == pygame.K_s:
            rect.move_ip(0, 2)
        elif event.key == pygame.K_a:
            rect.move_ip(-2, 0)
        elif event.key == pygame.K_d:
            rect.move_ip(2, 0)

Ora dobbiamo mostrare la nostra immagine. Per prima cosa potremmo voler cancellare il nostro schermo dal rendering precedente. Facciamo così riempiendo il nostro intero schermo con il nero (rimuovi il codice per capire perché vogliamo eliminarlo). Quindi dobbiamo confondere la nostra immagine sullo schermo. Blittare significa essenzialmente copiare l' immagine su un'altra superficie (nel nostro caso, lo schermo). Infine si flip o aggiornare lo schermo.

Quando stiamo blittando, in realtà non stiamo visualizzando nulla all'utente. Immaginalo come il computer su un lato e l'utente sull'altro. Il computer disegna ( blits ) sul suo lato dello schermo, lo gira verso l'utente e quindi si ripete.

screen.fill(BLACK)
screen.blit(image, rect)
pygame.display.update()  # Or 'pygame.display.flip()'.

Ora abbiamo un gioco di base! Abbastanza noioso, sì, ma gli elementi essenziali sono lì! Combinato con la tua attuale conoscenza di Python e dovresti essere in grado di creare qualcosa di fantastico.

Codice completo

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))


screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60  # Frames per second.

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
# RED = (255, 0, 0), GREEN = (0, 255, 0), BLUE = (0, 0, 255).

rect = pygame.Rect((0, 0), (32, 32))
image = pygame.Surface((32, 32))
image .fill(WHITE)  

while True:
    clock.tick(FPS)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                rect.move_ip(0, -2)
            elif event.key == pygame.K_s:
                rect.move_ip(0, 2)
            elif event.key == pygame.K_a:
                rect.move_ip(-2, 0)
            elif event.key == pygame.K_d:
                rect.move_ip(2, 0)

    screen.fill(BLACK)
    screen.blit(image, rect)
    pygame.display.update()  # Or pygame.display.flip()

Meccaniche di gioco leggermente migliorate

Si noti che il programma verifica quando si preme il tasto e non quando si tiene premuto il tasto. Per risolvere questo problema potremmo introdurre una variabile di velocità . Possiamo creare una classe di giocatori per mantenerla più organizzata. Per evitare il movimento dipendente dalla trama (se modifichiamo l'FPS a 30 gli oggetti si sposterebbero a metà della velocità) introduciamo il movimento dipendente dal tempo passando il tempo tra le zecche ai nostri oggetti mobili.

import pygame

successes, failures = pygame.init()
print("Initializing pygame: {0} successes and {1} failures.".format(successes, failures))

screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)


class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((32, 32))
        self.image.fill(WHITE)
        self.rect = self.image.get_rect()  # Get rect of some size as 'image'.
        self.velocity = [0, 0]

    def update(self):
        self.rect.move_ip(*self.velocity)


player = Player()
running = True
while running:
    dt = clock.tick(FPS) / 1000  # Returns milliseconds between each call to 'tick'. The convert time to seconds.
    screen.fill(BLACK)  # Fill the screen with background color.

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                player.velocity[1] = -200 * dt  # 200 pixels per second
            elif event.key == pygame.K_s:
                player.velocity[1] = 200 * dt
            elif event.key == pygame.K_a:
                player.velocity[0] = -200 * dt
            elif event.key == pygame.K_d:
                player.velocity[0] = 200 * dt
        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_w or event.key == pygame.K_s:
                player.velocity[1] = 0
            elif event.key == pygame.K_a or event.key == pygame.K_d:
                player.velocity[0] = 0

    player.update()

    screen.blit(player.image, player.rect)
    pygame.display.update()  # Or pygame.display.flip()

print("Exited the game loop. Game will quit...")
quit()  # Not actually necessary since the script will exit anyway.

Ci sono ancora molte cose che dovrebbero essere migliorate su questo codice. Ti consiglio di leggere il tutorial su pygame e questo discorso di Richard Jones per ulteriori approfondimenti.

Installare pygame

Su Windows

1. Passare a http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame - un sito non ufficiale che fornisce binari di Windows di pacchetti Python open source per la distribuzione CPython ufficiale di Christoph Gohlke .

2. Scarica il file .whl pygame appropriato in base alla tua versione python installata. (Il file è chiamato qualcosa come pygame - <pygame version> - <python version> - win32.whl )

3. Correre

    pip install your-pygame-package.whl
   

   nel tuo terminale, bash o consol.
   Nota: se pip non viene trovato in PATH prova ad eseguire python -m pip install your-pygame-package.whl

4. Controlla se puoi importare pygame come un modulo python

   import pygame
   

   Se non ricevi un errore, hai correttamente installato pygame sul tuo computer :)

Su linux

1. Apri il tuo terminale ed esegui

   sudo apt-get install python-pygame
   

   Nota: questo installerà pygame per python2

2. Prova ad importare pygame all'interno

   import pygame
   

   Se non ricevi un errore, hai correttamente installato pygame sul tuo sistema linux :)

Su macOS

Ci sono due modi per installarlo su mac:

Metodo 1

Vai alla pagina dei download di Pygame e scarica il programma di installazione mac. Eseguilo e dovrebbe installare Pygame sul tuo Mac.

Metodo 2

Installa Homebrew :

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Quindi usa Homebrew per installare Python 2.7.12 e Pygame:

brew install python; brew install homebrew/python/pygame

Ora esegui Python nel tuo terminale e prova a import pygame . Se non dice nulla, è installato con successo.

Importazione di pygame e disegno su un display

Iniziare

Devi fare quanto segue per iniziare con Pygame:

import pygame

Questo apre una finestra di dimensioni 640.480 e lo memorizza in una variabile chiamata schermata.

Impostazione del nome di una finestra

L'impostazione di un nome per la finestra pygame richiede la seguente sintassi:

pygame.display.set_caption('Name')

A proposito dello schermo

• Il punto (0,0) si trova nell'angolo in alto a sinistra dello schermo.
• le coordinate x aumentano da sinistra a destra, le coordinate y aumentano dall'alto verso il basso. Quelle coordinate sul lato destro sul piano cartesiano sono positive e il lato sinistro è negativo. Tuttavia, le coordinate del lato superiore sul piano cartesiano sono negative sopra e positive in basso. ( Nota : questo è considerato se i punti sono presi dall'origine.)

Aggiornamento dello schermo

Le modifiche apportate allo schermo, ad esempio riempiendole di colore o disegnandole, non vengono visualizzate immediatamente!
Quindi come si fa?
Devi chiamare questa funzione:

pygame.display.update()

Colori

La colorazione in pygame funziona in modalità RGB.
Il codice per la colorazione è:

color_Name = (r,g,b)

• R sta per rosso.
• G sta per verde
• B sta per blu.
• Tutti e tre dovrebbero essere numeri interi compresi tra 0 e 255, con 255 più luminosi e 0 più scuro

Disegno

1. Per disegnare linee

   pygame.draw.lines(screen, color, closed, pointlist, thickness)
   

2. Per disegnare il rettangolo

   pygame.draw.rect(screen, color, (x,y,width,height), thickness)
   

3. Per disegnare il cerchio

   pygame.draw.circle(screen, color, (x,y), radius, thickness)
   

Impostare tutto in un ciclo

Per fare un ciclo usa il seguente codice:

running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()

Disegnare un rettangolo sulla finestra di pygame (codice)

import pygame
background_colour = (255,255,255) # White color
(width, height) = (300, 200) # Screen size
color=(0,0,0) #For retangle
screen = pygame.display.set_mode((width, height)) #Setting Screen
pygame.display.set_caption('Drawing') #Window Name
screen.fill(background_colour)#Fills white to screen
pygame.draw.rect(screen, color, (100,50,30,40), 1) #Drawing the rectangle
pygame.display.update()

#Loop
running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()