Videogiochi di Pygame

Nestore Caruso

Pygame è un modulo in Python utilizzato per il design dei videogiochi; Questi videogiochi vanno da un semplice tic tac toe ai combattenti spaziali. Sia che tu voglia progettare un gioco semplice o complicato, devi iniziare con le basi di come funziona Pygame. In questo tutorial, esamineremo le basi di Pygame creando un videogioco.

Installa Pygame usando:

PIP Installa Pygame

Passaggio 1: creazione della finestra iniziale

Il primo passo nella creazione di un videogioco è inizializzare il metodo Pygame usando il metodo init (). Successivamente, impostiamo la geometria dello schermo usando Pygame.Schermo.set_mode (), dove passiamo la larghezza e l'altezza dello schermo (in quell'ordine). Queste due righe di codice creeranno una finestra che scomparirà rapidamente, quindi abbiamo bisogno di un mainloop per far funzionare la finestra. All'interno di questo mainloop, aggiungeremo una strategia di uscita. La strategia di uscita viene creata selezionando un evento dall'elenco degli eventi (questo elenco di eventi si trova all'interno di Pygame.evento.get () che ospita tutti gli eventi disponibili). Successivamente, affermiamo che se l'evento che abbiamo selezionato è Pygame.Smettila, quindi esci. Quest'ultimo creerà un mainloop per la finestra, che manterrà la finestra in esecuzione finché non si preme il pulsante di smettere.

Importa Pygame
Import sys
Pygame.dentro()
dimensione = larghezza, altezza = 800, 600
Screen = PyGame.Schermo.set_mode (dimensione)
mentre è vero:
Per evento in Pygame.evento.Ottenere():
se evento.type == Pygame.ESENTATO:
sys.Uscita()

Passaggio 2: aggiunta di titoli, icone, colori di sfondo e immagini

In questa sezione, aggiungeremo titoli, colori di sfondo e immagini e icone alla finestra.

(a) Il titolo viene aggiunto usando:

# imposta il titolo di finestra
Pygame.Schermo.set_caption ("videogioco")

(b) Ho ricevuto il mio logo da https: // icons8.com/icona/set/computer-hardware/doodle. Se stai usando PyCharm, posiziona l'icona che scarica nella cartella appropriata (nel mio caso, era C: \ Users \ Never \ PyCharmProjects \ PythonProject2 \ icon.PNG). Il logo viene aggiunto usando:

# Imposta l'icona
Immagine = PyGame.Immagine.carico ("icona.png ")
Pygame.Schermo.set_icon (immagine)

(c) Puoi anche cambiare il colore del backgound. Per questo, usiamo lo schermo.FILL () che richiede un colore RGB. Nel mio caso, l'ho impostato su (0,0,0). Una volta impostato il colore, devi anche aggiornare il Pygame per la modifica del colore per avere effetto.

# riempi lo sfondo
schermo.riempire ((0, 0, 0))
Pygame.Schermo.aggiornamento()

(d) Cosa succede se volessi impostare un'immagine di sfondo sullo schermo? Anche questo è possibile. Dal momento che si desidera che l'immagine sia sempre eseguita, deve essere posizionata entro il ciclo. In effetti, tutto ciò che deve funzionare costantemente deve essere collocato nel mainloop. Usiamo Pygame.Immagine.load () per selezionare un'immagine che vogliamo caricare e il metodo blit () per posizionarla. Qui, schermo.blit () prende due argomenti: l'immagine caricata, la tuplo della posizione in cui verrà posizionato l'angolo in alto a sinistra dell'immagine. Inoltre, Pygame.Schermo.Aggiornamento () deve essere posizionato alla fine per aggiornare lo schermo! Quando si progettano videogiochi, l'ordine in cui si effettua il codice è importante!!! Ad esempio, l'aggiornamento non può venire prima delle immagini!

# Crea l'immagine di sfondo
bg_image = pygame.Immagine.load ("bg_image.jpg ")
schermo.blit (bg_image, (-15, -25))
Pygame.Schermo.aggiornamento()

In alternativa, possiamo anche scaricarlo in una funzione di sfondo (che sarà utile in seguito), quindi riscriviamo lo sfondo come segue:

# Crea l'immagine di sfondo
bg_image = pygame.Immagine.load ("bg_image_3.jpg ")
sfondo def ():
schermo.blit (bg_image, (-15, -25))

Si prega di notare che abbiamo inserito lo sfondo in una funzione chiamata background (), che attiveremo nel ciclo while in seguito.

Passaggio 3: aggiunta di immagini del giocatore alla finestra

Successivamente, creiamo una persona. Questo viene fatto caricando prima l'immagine e quindi utilizzando lo schermo.blit () per posizionare l'immagine.

# Immagine della persona
image_person = pygame.Immagine.carico ("persona.png ")
schermo.blit (image_person, (400, 550))

Si prega di notare che l'ordine in cui si effettua anche il codice conta! Se si posiziona il codice per lo sfondo dopo il codice per il nemico, né la persona né il nemico saranno visibili!

Tuttavia, ancora una volta, ai fini dell'intero codice, lo metteremo in una funzione. Quindi il codice può essere riscritto come segue:

# Immagine della persona
Person_x = 400
Person_y = 550
image_person = pygame.Immagine.carico ("ragazza.png ")
def persona (x, y):
schermo.blit (image_person, (x, y))

Questa funzione può essere attivata nel ciclo while come segue:

Person (Person_x, Person_y)

Passaggio 4: sposta la persona ()

Ora, diventa complicato, quindi presta attenzione. Dobbiamo premere le chiavi per spostare la persona giusta, quindi le inseriremo nel ciclo while come segue:

pressed_keys = pygame.chiave.get_pressed ()
Se pressed_keys [Pygame.K_right]:
Person_x += 0.1
Se pressed_keys [Pygame.K_left]:
Person_x += -0.1

Usiamo Pygame.chiave.get_pressed () per ottenere il tasto premuto, quindi controllalo. Se il tasto premuto è il tasto freccia destra (Pygame.K_right), quindi la nostra variabile persona_x è incrementata da un valore di 0.1. Se, d'altra parte, il tasto premuto è la freccia sinistra (Pygame.K_left), quindi diminuiamo di 0.1. Quello che stiamo facendo è cambiare la posizione dell'immagine sulla console. Se viene premuta la freccia destra, la tupla iniziale di (400, 550) diventerà (400.1, 550) - E questa è la posizione dell'immagine!

Dobbiamo anche attivare entrambe le funzioni - background () e persona (). Lo sfondo della funzione () cancellerà lo schermo ogni volta che il ciclo inizia e senza di essa, avrai una "trascinamento".

Il codice nel suo insieme a questo punto sembrerebbe così:

Importa Pygame
Import sys
# Inizializza
Pygame.dentro()
# imposta la geometria dello schermo
dimensione = larghezza, altezza = 800, 600
Screen = PyGame.Schermo.set_mode (dimensione)
# imposta il titolo di finestra
Pygame.Schermo.set_caption ("videogioco")
# Imposta l'icona
Immagine = PyGame.Immagine.carico ("icona.png ")
Pygame.Schermo.set_icon (immagine)
# Crea l'immagine di sfondo
bg_image = pygame.Immagine.load ("bg_image_3.jpg ")
sfondo def ():
schermo.blit (bg_image, (-15, -25))
# Immagine della persona
Person_x = 400
Person_y = 550
image_person = pygame.Immagine.carico ("ragazza.png ")
def persona (x, y):
schermo.blit (image_person, (x, y))
# mainloop
mentre è vero:
Per evento in Pygame.evento.Ottenere():
se evento.type == Pygame.ESENTATO:
sys.Uscita()
# Controlla i tasti premuti
pressed_keys = pygame.chiave.get_pressed ()
# Se il tasto premuto è la freccia giusta,
# quindi spostati a destra
Se pressed_keys [Pygame.K_right]:
Person_x += 0.1
# Se il tasto premuto è la freccia sinistra,
# quindi spostati a sinistra
Se pressed_keys [Pygame.K_left]:
Person_x += -0.1
# Attiva la funzione di sfondo
sfondo()
# Attiva la funzione della persona
Person (Person_x, Person_y)
# aggiorna tutto
Pygame.Schermo.aggiornamento()

Passaggio 5: impostare i limiti del bordo

Quando prememo il tasto freccia destro o sinistro, al momento, la persona (o il personaggio principale) nel nostro gioco continuerà a muoversi e muoversi anche fuori portata o fuori dalla finestra della console. Quindi la prossima cosa che dobbiamo fare è stabilire limiti sul movimento.

L'impostazione dei limiti è facile. Andiamo al nostro pressed_keys [Pygame.K_right] argomento e aggiungi una condizione. Aggiungiamo la condizione che X deve essere inferiore alla larghezza della nostra schermata - Larghezza del personaggio.

Nel mio caso, la larghezza del personaggio era di 50 pixel e la larghezza X del mio schermo era 800. Quindi ho impostato il mio lato destro su 800 - 50 = 750 pixel. Ciò che fa è limitare il movimento del mio personaggio. Il mio personaggio non può andare oltre 750 pixel e quindi rimarrà sullo schermo della console in ogni momento.

pressed_keys = pygame.chiave.get_pressed ()
# Se il tasto premuto è la freccia giusta,
# quindi spostati a destra
Se pressed_keys [Pygame.K_right] e persona_x < 750:
Person_x += 0.1
# Se il tasto premuto è la freccia sinistra,
# quindi spostati a sinistra
Se pressed_keys [Pygame.K_left] e persona_x> 0:
Person_x += -0.1

Passaggio 6: creazione del nemico

Creare il nemico è la parte facile. Lo facciamo allo stesso modo in cui abbiamo creato il personaggio principale. Qui, vorremmo randomizzare la posizione in cui appare il nemico, quindi useremo il modulo casuale per farlo. Usiamo casuale.Randint () per impostare una posizione casuale.

importare casuali
# immagine nemica
Enemy_x = casuale.Randint (0, 750)
Enemy_y = casuale.Randint (0, 300)
image_enemy = pygame.Immagine.carico ("nemico.png ")
Def Enemy (X, Y):
schermo.blit (image_enemy, (x, y))

Ricorda di attivare il nemico nel while loop:

# Attiva il nemico
Enemy (Enemy_X, Enemy_Y)

Passaggio 7: spostare il nemico

Spostare il nemico richiede un po 'di immaginazione. Inizializziamo le variabili (al di fuori del ciclo while):

#Initialize variabili
Enemy_diff = 0.6
Enemy_x = 0

E entro il circuito, scriviamo:

# muovi il nemico
Enemy_x += Enemy_diff
Se Enemy_X <= 0:
Enemy_x = 0
Enemy_diff = 0.6
Se Enemy_X> = 730:
Enemy_x = 730
Enemy_diff = -0.6

Ciò che fa è che se l'immagine del nemico è nei limiti (in questo caso, tra 0 e 730), calcolerà l'equazione Enemy_X = Enemy_X + Enemy_diff e lo sposta. Se, d'altra parte, la posizione del nemico è maggiore di 730, allora impostiamo la posizione Enemy_x su 730 e invertiamo la velocità scrivendo -0.6 invece di 0.6. Se la posizione del nemico è inferiore a 0, impostiamo la variabile Enemy_x su 0 e gli diciamo di andare avanti di 0.6 pixel. Poiché abbiamo a che fare con un ciclo di tempo, ogni volta che il ciclo ricomincia, fa cambiare la variabile Enemy_X e, quindi, la posizione del nemico. Alla fine, tutto questo farà è spostare il nemico avanti e indietro a sinistra e per sempre.

Passaggio 8: creare e sparare più proiettili

Nel mio caso, lancerò libri al Fireball. Quindi il mio proiettile è un libro o più libri. Per prima cosa inizializziamo tutte le variabili di cui abbiamo bisogno:

#Initialize variabili
books_diff = 4
libri_y = 520
libri_x = 420

Books_x e books_y sono la loro posizione iniziale; Li ho posizionati vicino al personaggio principale. Books_diff è la sua velocità. Successivamente, inizializziamo il suo stato, che non si muove "e cariciamo l'immagine.

# Immagine dei libri
books_state = "non si muove"
Image_Books = PyGame.Immagine.Load ("Libri.png ")

Creiamo quindi una funzione che prende i libri_state. Se mettiamo il libro sulla griglia, allora cambiamo il suo stato in "muoverci". Questa funzione è la funzione principale che posizionerà il proiettile sulla mappa/console. Inoltre, nei libri di funzione (), ho scritto x+15 e y+1 per centrare l'immagine. Senza quest'ultimo, i libri si guardano da un lato.

libri def (x, y):
Global Books_State
books_state = "Moving"
schermo.blit (image_books, (x + 15, y + 1))

E all'interno del ciclo principale, scriveresti:

# Movimento dei libri
Se libri_y <= 0:
libri_y = 420
books_state = "non si muove"
Se Books_state è "commovente":
libri_x = persona_x
libri (libri_x, libri_y)
books_y -= books_diff
# spara se il pulsante Spazio viene premuto
Se pressed_keys [Pygame.K_space]:
libri_x = persona_x
libri (libri_x, libri_y)

Definiamo per la prima volta cosa succede quando i proiettili/libri si muovono dalla griglia o sono in posizione y<0. In this case, we change the state back to “not moving” and place the books back on the y-axis at 420. If, on the other hand, the state of the book is “moving”, we say that we want it to move (books_y -= books_diff where books_diff is its speed). Next, we also state that if the key is pressed, we want the books() function to be activated, placing the books' image onto the console grid.

Il codice nel suo insieme a questo punto sembrerebbe qualcosa di simile:

Importa Pygame
Import sys
# Inizializza
Pygame.dentro()
# Inizializza l'orologio
Clock = Pygame.tempo.Orologio()
# imposta la geometria dello schermo
dimensione = larghezza, altezza = 800, 600
Screen = PyGame.Schermo.set_mode (dimensione)
# imposta il titolo di finestra
Pygame.Schermo.set_caption ("videogioco")
# Imposta l'icona
Immagine = PyGame.Immagine.carico ("icona.png ")
Pygame.Schermo.set_icon (immagine)
# Crea l'immagine di sfondo
bg_image = pygame.Immagine.load ("bg_image_3.jpg ")
sfondo def ():
schermo.blit (bg_image, (-15, -25))
# Immagine della persona
Person_x = 400
Person_y = 550
image_person = pygame.Immagine.carico ("ragazza.png ")
def persona (x, y):
schermo.blit (image_person, (x, y))
importare casuali
# immagine nemica
Enemy_x = casuale.Randint (0, 750)
Enemy_y = casuale.Randint (0, 300)
image_enemy = pygame.Immagine.carico ("nemico.png ")
Def Enemy (X, Y):
schermo.blit (image_enemy, (x, y))
#Initialize Variabili nemiche
Enemy_diff = 0.6
Enemy_x = 0
#Initialize variabili
books_diff = 4
libri_y = 520
libri_x = 420
# Immagine dei libri
books_state = "non si muove"
Image_Books = PyGame.Immagine.Load ("Libri.png ")
libri def (x, y):
Global Books_State
books_state = "Moving"
schermo.blit (image_books, (x + 15, y + 1))
# mainloop
mentre è vero:
Per evento in Pygame.evento.Ottenere():
se evento.type == Pygame.ESENTATO:
sys.Uscita()
# Controlla i tasti premuti
pressed_keys = pygame.chiave.get_pressed ()
# Se il tasto premuto è la freccia giusta,
# quindi spostati a destra
Se pressed_keys [Pygame.K_right] e persona_x < 750:
Person_x += 0.8
# Se il tasto premuto è la freccia sinistra,
# quindi spostati a sinistra
Se pressed_keys [Pygame.K_left] e persona_x> 0:
Person_x += -0.8
# Attiva la funzione di sfondo
sfondo()
# Attiva la funzione della persona
Person (Person_x, Person_y)
# muovi il nemico
Enemy_x += Enemy_diff
Se Enemy_X <= 0:
Enemy_x = 0
Enemy_diff = 0.6
Se Enemy_X> = 730:
Enemy_x = 730
Enemy_diff = -0.6
# Movimento dei libri
Se libri_y <= 0:
libri_y = 420
books_state = "non si muove"
Se Books_state è "commovente":
libri_x = persona_x
libri (libri_x, libri_y)
books_y -= books_diff
# spara se il pulsante Spazio viene premuto
Se pressed_keys [Pygame.K_space]:
libri_x = persona_x
libri (libri_x, libri_y)
# Attiva il nemico
Enemy (Enemy_X, Enemy_Y)
# aggiorna tutto
Pygame.Schermo.aggiornamento()
orologio.Tick (60)

Questo codice girerà più libri uno dopo l'altro quando viene premuto il tasto Spazio.

Passaggio 9: rilevamento delle collisioni

Il prossimo passo è rilevare una collisione, e questo sembra abbastanza semplice. Useresti il Pygame.Rect (x, y, larghezza, altezza) per definire un rettangolo. Quindi utilizzare il metodo collinect () per rilevare la collisione tra due rettangoli. Diciamo anche che se rileva una collisione, incrediamo il punteggio di 1, re-localizza il nemico e rimuoviamo il proiettile ripristinandolo.

# rilevamento delle collisioni
Enemy_rect = pygame.Rect (Enemy_X, Enemy_Y, 64, 64)
libri_rect = pygame.Rect (Books_x, Books_y, 64, 64)
Se books_rect.Collidect (Enemy_Rect):
Enemy_x = casuale.RandRange (0, 800)
Enemy_y = casuale.RandRange (0, 300)
Punteggio += 1
Bullet_state = "non si muove"
Enemy (Enemy_X, Enemy_Y)
libri_y = 0

Passaggio 10: visualizzazione del testo

Al di fuori del Mainloop, scriveresti:

Punteggio = 0
#Initialize Carattere
Pygame.font.dentro()
myfont = pygame.font.Sysfont ("Comic Sans MS", 50)
def text_score (x, y):
text_score = myfont.render ('punteggio:'+ str (punteggio), true, (0, 0, 0))
schermo.blit (text_score, (x, y))

All'interno del ciclo principale, scriveresti:

# Attiva il punteggio del testo
text_score (6, 6)

Qui, i caratteri devono essere inizializzati, quindi inizializzalo usando Pygame.font.dentro(). Quindi scegli il tuo carattere usando Pygame.font.Sysfont () dove passi il carattere e le dimensioni. Successivamente, definiamo una funzione in cui utilizziamo il metodo di rendering per renderlo. Qui, poiché il punteggio è un numero intero, usiamo STR (punteggio). E poi, li posizioniamo sullo schermo usando il metodo blit ().

A questo punto, l'intero codice sembrerebbe così:

Importa Pygame
Import sys
# Inizializza
Pygame.dentro()
# Inizializza l'orologio
Clock = Pygame.tempo.Orologio()
# imposta la geometria dello schermo
dimensione = larghezza, altezza = 800, 600
Screen = PyGame.Schermo.set_mode (dimensione)
# imposta il titolo di finestra
Pygame.Schermo.set_caption ("videogioco")
# Imposta l'icona
Immagine = PyGame.Immagine.carico ("icona.png ")
Pygame.Schermo.set_icon (immagine)
# Crea l'immagine di sfondo
bg_image = pygame.Immagine.load ("bg_image_3.jpg ")
sfondo def ():
schermo.blit (bg_image, (-15, -25))
# Immagine della persona
Person_x = 400
Person_y = 550
image_person = pygame.Immagine.carico ("ragazza.png ")
def persona (x, y):
schermo.blit (image_person, (x, y))
importare casuali
# immagine nemica
Enemy_x = casuale.Randint (0, 750)
Enemy_y = casuale.Randint (0, 300)
image_enemy = pygame.Immagine.carico ("nemico.png ")
Def Enemy (X, Y):
schermo.blit (image_enemy, (x, y))
#Initialize Variabili nemiche
Enemy_diff = 0.6
Enemy_x = 0
#Initialize variabili
books_diff = 4
libri_y = 520
libri_x = 420
# Immagine dei libri
books_state = "non si muove"
Image_Books = PyGame.Immagine.Load ("Libri.png ")
libri def (x, y):
Global Books_State
books_state = "Moving"
schermo.blit (image_books, (x + 15, y + 1))
Punteggio = 0
#Initialize Carattere
Pygame.font.dentro()
myfont = pygame.font.Sysfont ("Comic Sans MS", 50)
def text_score (x, y):
text_score = myfont.render ('punteggio:'+ str (punteggio), true, (0, 0, 0))
schermo.blit (text_score, (x, y))
# mainloop
mentre è vero:
Per evento in Pygame.evento.Ottenere():
se evento.type == Pygame.ESENTATO:
sys.Uscita()
# Controlla i tasti premuti
pressed_keys = pygame.chiave.get_pressed ()
# Se il tasto premuto è la freccia giusta,
# quindi spostati a destra
Se pressed_keys [Pygame.K_right] e persona_x < 750:
Person_x += 0.8
# Se il tasto premuto è la freccia sinistra,
# quindi spostati a sinistra
Se pressed_keys [Pygame.K_left] e persona_x> 0:
Person_x += -0.8
# Attiva la funzione di sfondo
sfondo()
# Attiva la funzione della persona
Person (Person_x, Person_y)
# muovi il nemico
Enemy_x += Enemy_diff
Se Enemy_X <= 0:
Enemy_x = 0
Enemy_diff = 0.6
Se Enemy_X> = 730:
Enemy_x = 730
Enemy_diff = -0.6
# Movimento dei libri
Se libri_y <= 0:
libri_y = 420
books_state = "non si muove"
Se Books_state è "commovente":
libri_x = persona_x
libri (libri_x, libri_y)
books_y -= books_diff
# spara se il pulsante Spazio viene premuto
Se pressed_keys [Pygame.K_space]:
libri_x = persona_x
libri (libri_x, libri_y)
# Attiva il nemico
Enemy (Enemy_X, Enemy_Y)
# rilevamento delle collisioni
Enemy_rect = pygame.Rect (Enemy_X, Enemy_Y, 64, 64)
libri_rect = pygame.Rect (Books_x, Books_y, 64, 64)
Se books_rect.Collidect (Enemy_Rect):
Enemy_x = casuale.RandRange (0, 800)
Enemy_y = casuale.RandRange (0, 300)
Punteggio += 1
Bullet_state = "non si muove"
Enemy (Enemy_X, Enemy_Y)
libri_y = 0
# Attiva il punteggio del testo
text_score (6, 6)
# aggiorna tutto
Pygame.Schermo.aggiornamento()
orologio.Tick (60)

Passaggio 11: aggiunta suoni

L'aggiunta di suoni è facile Duper!

Al di fuori del ciclo principale, scriveresti:

# Inizializza i suoni
Pygame.mixer.dentro()
Pygame.mixer.musica.carico ("pistola-01.wav ")

All'interno del Mainloop, attirerò il suono se c'è una collisione! Qui, usiamo Pygame.mixer.musica.giocare().

Passaggio 12: terminare il gioco

Ho intenzione di impostare questa partita a vittoria se il punteggio è maggiore di 5. Quindi al di fuori del ciclo principale, scriviamo il seguente codice:

text_game_over = pygame.font.Sysfont ("Comic Sans MS", 80)
# Game Over Function
def game_over (x, y):
text_game_over_2 = myfont.Render ('You Won', true, (0, 0, 0))
schermo.blit (text_game_over_2, (x, y))

E all'interno del ciclo principale, scriveresti:

# Controlla la vittoria
Se punteggio> 5:
Game_over (400, 300)
Pygame.Schermo.Flip()
tempo.sonno (5)
rottura
# Attiva il punteggio del testo
text_score (6, 6)
timer (500, 6)

Ciò significa che se il punteggio è maggiore di 5, la funzione Game_over () verrà attivata, lo schermo verrà aggiornato e quindi diciamo, dormire un po 'prima di smettere.

L'intero codice sembrerebbe così:

Importa Pygame
Import sys
tempo di importazione
# Inizializza
Pygame.dentro()
# Inizializza l'orologio
Clock = Pygame.tempo.Orologio()
# imposta la geometria dello schermo
dimensione = larghezza, altezza = 800, 600
Screen = PyGame.Schermo.set_mode (dimensione)
# imposta il titolo di finestra
Pygame.Schermo.set_caption ("videogioco")
# Imposta l'icona
Immagine = PyGame.Immagine.carico ("icona.png ")
Pygame.Schermo.set_icon (immagine)
# Crea l'immagine di sfondo
bg_image = pygame.Immagine.load ("bg_image_3.jpg ")
sfondo def ():
schermo.blit (bg_image, (-15, -25))
# Immagine della persona
Person_x = 400
Person_y = 550
image_person = pygame.Immagine.carico ("ragazza.png ")
def persona (x, y):
schermo.blit (image_person, (x, y))
importare casuali
# immagine nemica
Enemy_x = casuale.Randint (0, 750)
Enemy_y = casuale.Randint (0, 300)
image_enemy = pygame.Immagine.carico ("nemico.png ")
Def Enemy (X, Y):
schermo.blit (image_enemy, (x, y))
#Initialize Variabili nemiche
Enemy_diff = 0.6
Enemy_x = 0
#Initialize variabili
books_diff = 4
libri_y = 520
libri_x = 420
# Immagine dei libri
books_state = "non si muove"
Image_Books = PyGame.Immagine.Load ("Libri.png ")
libri def (x, y):
Global Books_State
books_state = "Moving"
schermo.blit (image_books, (x + 15, y + 1))
Punteggio = 0
#Initialize Carattere
Pygame.font.dentro()
myfont = pygame.font.Sysfont ("Comic Sans MS", 50)
def text_score (x, y):
text_score = myfont.render ('punteggio:'+ str (punteggio), true, (0, 0, 0))
schermo.blit (text_score, (x, y))
# Inizializza i suoni
Pygame.mixer.dentro()
Pygame.mixer.musica.carico ("pistola-01.wav ")
text_game_over = pygame.font.Sysfont ("Comic Sans MS", 80)
# Game Over Function
def game_over (x, y):
text_game_over_2 = myfont.Render ('You Won', true, (0, 0, 0))
schermo.blit (text_game_over_2, (x, y))
DEF TIMER (X, Y):
text_timer = myfont.Render ('Time:'+ STR (Pygame.tempo.get_ticks ()), true, (0, 0, 0))
schermo.blit (text_timer, (x, y))
# mainloop
mentre è vero:
Per evento in Pygame.evento.Ottenere():
se evento.type == Pygame.ESENTATO:
sys.Uscita()
# Controlla i tasti premuti
pressed_keys = pygame.chiave.get_pressed ()
# Se il tasto premuto è la freccia giusta,
# quindi spostati a destra
Se pressed_keys [Pygame.K_right] e persona_x < 750:
Person_x += 0.8
# Se il tasto premuto è la freccia sinistra,
# quindi spostati a sinistra
Se pressed_keys [Pygame.K_left] e persona_x> 0:
Person_x += -0.8
# Attiva la funzione di sfondo
sfondo()
# Attiva la funzione della persona
Person (Person_x, Person_y)
# muovi il nemico
Enemy_x += Enemy_diff
Se Enemy_X <= 0:
Enemy_x = 0
Enemy_diff = 0.6
Se Enemy_X> = 730:
Enemy_x = 730
Enemy_diff = -0.6
# Movimento dei libri
Se libri_y <= 0:
libri_y = 420
books_state = "non si muove"
Se Books_state è "commovente":
libri_x = persona_x
libri (libri_x, libri_y)
books_y -= books_diff
# spara se il pulsante Spazio viene premuto
Se pressed_keys [Pygame.K_space]:
libri_x = persona_x
libri (libri_x, libri_y)
# Attiva il nemico
Enemy (Enemy_X, Enemy_Y)
# rilevamento delle collisioni
Enemy_rect = pygame.Rect (Enemy_X, Enemy_Y, 64, 64)
libri_rect = pygame.Rect (Books_x, Books_y, 64, 64)
Se books_rect.Collidect (Enemy_Rect):
Enemy_x = casuale.RandRange (0, 800)
Enemy_y = casuale.RandRange (0, 300)
Punteggio += 1
Bullet_state = "non si muove"
Enemy (Enemy_X, Enemy_Y)
libri_y = 0
Pygame.mixer.musica.giocare()
# Controlla la vittoria
Se punteggio> 5:
Game_over (400, 300)
Pygame.Schermo.Flip()
tempo.sonno (5)
rottura
# Attiva il punteggio del testo
text_score (6, 6)
timer (500, 6)
# aggiorna tutto
Pygame.Schermo.aggiornamento()
orologio.Tick (60)

Questo, ovviamente, è il più semplice di tutti i giochi che puoi creare! Tuttavia, è un inizio per coloro che vogliono imparare Pygame e progettare videogiochi migliori.

GIOCO FELICE!

c affilato

Come convertire un decimale in un doppio in C#

Per convertire un valore decimale in un doppio in C#, usiamo il decimale.Metodo ToDouble (). Ci vuol...

Cristyn De Santis

Golang

Cosa sono i pacchetti in Golang?

Un pacchetto è una tecnica di raggruppamento del codice in Go in blocchi riutilizzabili e gestibili....

Artemide Ricci

c affilato

Qual è la differenza tra classe e oggetto in C#

Una classe è un modello o un modello che definisce le caratteristiche e i comportamenti di un partic...

Nick Marini