Vise og oppdatere en spillpoengsum i Pygame

I denne opplæringen lærer du hvordan du viser og oppdaterer spillpoeng i Pygame, et populært Python-bibliotek for spillutvikling. Mot slutten vil du kunne lage et enkelt jumper-spill og vise spillerens poengsum på skjermen etter hvert som de går videre. Spillet sporer tastaturinndata slik at du kan flytte spilleren til venstre og høyre ved hjelp av piltastene.

Opprette et enkelt spill

Før du kan vise og oppdatere poengsummer i Pygame, må du først lage et spill å jobbe med. I denne opplæringen skal du lage et enkelt spill der en spiller kan bevege seg til venstre eller høyre. Men før det burde du ha det pip installert på enheten din. Etter å ha installert pip, kjør kommandoen nedenfor for å installere pygame-modulen:

pip installere pygame

For å komme i gang, importer de nødvendige modulene og sett opp den grunnleggende strukturen til spillet:

import

instagram viewer
 pygame, sys
pygame.init()
# Sett opp vinduet
skjerm = pygame.display.set_mode((750, 450))
# Sett opp spilleklokken
klokke = pygame.time. Klokke()
# Sett opp spillerkarakteren
spiller = pygame. Rekt(100, 200, 50, 50)
# Sett opp hindringen
hindring = pygame. Rekt(200, 200, 50, 50)
# Sett opp spillløkken
samtidig somekte:
# Håndter hendelser
til begivenhet i pygame.event.get():
hvis event.type == pygame. SLUTTE:
 pygame.quit()
 sys.exit()
hvis event.type == pygame. NASTATUR:
hvis event.key == pygame. K_LEFT:
 player.x -= 10
elif event.key == pygame. K_RIGHT:
 player.x += 10

# Oppdater spilltilstanden
# Tegn spillet
 screen.fill((0, 0, 0))
 pygame.draw.rect (skjerm, (255, 0, 0), spiller)
 pygame.draw.rect (skjerm, (0, 255, 0), hindring)

# Oppdater skjermen
 pygame.display.flip()

# Begrens bildefrekvensen
 klokke.tick(60)

Med denne skjelettkoden er det grunnleggende spillet ditt spillbart. Trykk til venstre eller høyre for å flytte spillerkarakteren, representert ved den røde firkanten.

Vise og oppdatere spillresultater

Nå som du har et grunnleggende spill satt opp, legg til et poengsystem og vis poengsummen på skjermen.

Sette opp Pygame for tekstgjengivelse

For å vise tekst i Pygame, må vi først importere de nødvendige modulene og initialisere fontmodulen. For å gjøre dette, bruk følgende kode øverst i skriptet:

import pygame
import sys
import os
pygame.init()
pygame.font.init()

pygame.font-modulen lar deg bruke Pygames tekstgjengivelsesmuligheter, og funksjonen pygame.init() initialiserer fontmodulen.

Opprette et grunnleggende poengsystem

Deretter lager du et grunnleggende poengsystem for spillet ditt. For å gjøre det, deklarer og initialiser to variabler: score og score_increment. Poengvariabelen vil holde styr på spillerens nåværende poengsum, og score_increment-variabelen vil spesifisere hvor mye poengsummen skal øke hver gang spilleren berører en hindring.

Legg til følgende kode øverst i skriptet, under importene:

score = 0
score_increment = 10

Deretter oppdaterer du poengsummen etter hvert som spillet skrider frem. I spillløkken kan du sjekke om spillerkarakteren kolliderer med hindringen. Hvis de er det, øk poengsummen med beløpet som er spesifisert i variabelen score_increment.

Oppdater spillløkken for å inkludere følgende kode:

# Oppdater spilltilstanden
hvis player.colliderect (hinder):
 score += score_increment

Denne koden sjekker om spillerkarakteren kolliderer med hindringen. Hvis de er det, øker det poengsummen med det angitte beløpet.

Vise poengsummen på skjermen med fontmodulen

Nå som vi har et grunnleggende poengsystem på plass, la oss vise poengsummen på skjermen ved hjelp av fontmodulen.

Først, la oss sette opp fontobjektet ved å legge til følgende kode øverst i spillløkken:

# Sett opp skriftobjektet
font = pygame.font. Font(Ingen, 36)

Denne koden lager et skriftobjekt med en størrelse på 36 piksler og ingen spesifisert skriftfamilie. Du kan tilpasse fonten og skriftstørrelsen ved å spesifisere en annen skriftfil og størrelse i Font()-funksjonen.

La oss deretter tegne poengsummen til skjermen. Legg til følgende kode i spillløkken, etter at du har oppdatert spillstatusen og fylt skjermen:

# Tegn partituret til skjermen
score_text = font.render(f'Score: {score}', ekte, (255, 255, 255))
screen.blit (score_text, (10, 10))

Denne koden bruker render()-metoden til fontobjektet for å lage en tekstoverflate som inneholder partituret, og deretter blits (tegner) tekstoverflaten til skjermen ved posisjonen (10, 10).

Tilpasse utseendet til partiturteksten

Til slutt tilpasser du utseendet til partiturteksten ved å velge font og skriftstørrelse og endre fargen på teksten.

For å velge en bestemt skrift og skriftstørrelse, send skriftfilen og størrelsen som argumenter til Font()-funksjonen:

font = pygame.font. Font('arial.ttf', 48)

Du kan enkelt last ned forskjellige fontfiler fra internett. Etter nedlasting, plasser bare fontfilen i roten av arbeidskatalogen din.

For å endre fargen på teksten, send en fargetuppel som det tredje argumentet til render()-metoden:

score_text = font.render(f'Score: {score}', ekte, (0, 255, 0))

Og det er det! Med disse endringene bør du nå ha et fullt funksjonelt spillpoengsystem som viser poengsummen på skjermen og oppdaterer det etter hvert som spilleren går gjennom spillet. Du kan tilpasse utseendet til partituret ytterligere ved å eksperimentere med forskjellige skriftfamilier, størrelser og farger.

Poengsporing i spillet

Nedenfor er hele arbeidskoden, du kan også finne koden på denne GitHub repo.

import pygame
import os
pygame.init()
pygame.font.init()
score = 0
score_increment = 10
# Sett opp vinduet
skjerm = pygame.display.set_mode((750, 450))
# Sett opp spilleklokken
klokke = pygame.time. Klokke()
# Sett opp spillerkarakteren
spiller = pygame. Rekt(100, 200, 50, 50)
# Sett opp hindringen
hindring = pygame. Rekt(200, 200, 50, 50)
# Sett opp spillløkken
samtidig somekte:
 font = pygame.font. Font(Ingen, 36)
# Håndter hendelser
til begivenhet i pygame.event.get():
hvis event.type == pygame. SLUTTE:
 pygame.quit()
 sys.exit()
hvis event.type == pygame. NASTATUR:
hvis event.key == pygame. K_LEFT:
 player.x -= 10
elif event.key == pygame. K_RIGHT:
 player.x += 10

# Oppdater spilltilstanden
hvis player.colliderect (hinder):
 score += score_increment

# Tegn spillet
 screen.fill((0, 0, 0))
 pygame.draw.rect (skjerm, (255, 0, 0), spiller)
 pygame.draw.rect (skjerm, (0, 255, 0), hindring)
# Tegn partituret til skjermen
 score_text = font.render(f'Score: {score}', ekte, (255, 255, 255))
 screen.blit (score_text, (10, 10))

# Oppdater skjermen
 pygame.display.flip()

# Begrens bildefrekvensen
 klokke.tick(60)

Denne koden lager et vindu med en størrelse på 750x450 piksler, en spillerkarakter og en hindring. Den bruker en spillløkke for å håndtere hendelser, oppdatere tilstand og tegne spillet til skjermen. Det inkluderer også et poengsystem som øker poengsummen med ti poeng hver gang spillerens karakter kolliderer med hindringen, og et skriftobjekt og tekstgjengivelseskode for å vise partituret på skjermen.

I hendelseshåndteringsdelen inkluderer koden også funksjonalitet for å flytte spillerkarakteren til venstre og høyre ved hjelp av piltastene.

Spillløkken inkluderer kode for å oppdatere skjermen og begrense bildefrekvensen til 60 FPS, noe som sikrer at spillet kjører jevnt.

Totalt sett gir denne koden et grunnleggende eksempel på hvordan du viser og oppdaterer spillpoeng i Pygame, og kan tilpasses og utvides ytterligere for å lage mer komplekse og engasjerende spill.

Lag forskjellige spill med Pygame

Pygame er et kraftig og brukervennlig bibliotek for å lage spill i Python. Med sitt rike sett med funksjoner og muligheter kan du lage et bredt spekter av spill, fra enkle jumpere og plattformspillere til mer komplekse og oppslukende spill.

Enten du er en nybegynner eller en erfaren spillutvikler, er Pygame et utmerket valg for å lage engasjerende og morsomme spill.