Hvordan implementere rullebakgrunner i Pygame

Rullebakgrunner kan i stor grad forbedre den visuelle appellen og dybden til et spill. De kan skape en illusjon av bevegelse, og gi spillet en dynamisk og oppslukende følelse. Du kan implementere rullebakgrunner med bare noen få enkle trinn ved å bruke Pygame.

Pygame er et populært Python-bibliotek du kan bruke til å utvikle spill. Å legge til rullebakgrunner til Pygame-prosjektene dine vil bringe dem til live og gi en mer engasjerende opplevelse for spillere.

Lag et enkelt spill

For å forstå konseptet med å rulle bakgrunner i Pygame, start med å lage et enkelt spill hvor spilleren kan bevege seg til venstre og høyre. Du kan også inkludere to plattformer, representert av rektangler, for å tjene som spillmiljø. Opprett en ny fil med navnet simple-game.py.

Koden som brukes i denne artikkelen er tilgjengelig i denne GitHub-depot og er gratis for deg å bruke under MIT-lisensen.

Først, importer pygame-modulen og initialiser den. Definer deretter spillerens startposisjon og bevegelseshastighet. Lag plattformer ved hjelp av pygame. Rect objekter og definere deres posisjoner og dimensjoner.

Inne i spillløkken, håndtere hendelser som å avslutte spillet. Du kan også håndtere spillerbevegelse basert på berørings- eller tastaturinnganger.

Her er resultatet av det enkle spillet:

Lag forskjellige lag

For å oppnå rulleeffekten kan du lage flere lag med bakgrunner med forskjellige farger. Hvert lag vil bevege seg med en annen hastighet, og skape en parallakseeffekt. Denne effekten gir en illusjon av dybde og forbedrer følelsen av bevegelse i spillet.

Definer to bakgrunnslag, som hvert dekker hele spillvinduet, ved å bruke pygame. Rett gjenstander. Definer også fargene på hvert lag i bakgrunnsfarger liste. De bakgrunnshastigheter listen bestemmer hastigheten som hvert lag skal bevege seg med.

# Legg til denne koden under forrige seksjon
bakgrunnslag = [
 pygame. Rekt(0, 0, screen_width, screen_height), 
 pygame. Rekt(0, 0, screen_width, screen_height) 
]
bakgrunnsfarger = [(30, 30, 30), (60, 60, 60)]
bakgrunnshastigheter = [0.1, 1.0]

For å lage den rullende bakgrunnseffekten, må du oppdatere posisjonene til bakgrunnslagene i spillløkken. Du flytter hvert lag horisontalt basert på dets tilordnede hastighet.

Opprett en ny fil med navnet scrolling-bg.py og legg til koden med oppdateringene nedenfor:

til Jeg i område (len (background_layers)):
 background_layers[i].x -= background_speeds[i]
hvis bakgrunnslag[i].x <= -skjermbredde:
 bakgrunnslag[i].x = 0
 pygame.draw.rect (skjerm, bakgrunnsfarger[i], bakgrunnslag[i])

Iterer gjennom hvert bakgrunnslag. Trekk den tilsvarende hastigheten fra lagets x-koordinat, slik at den beveger seg til venstre. Hvis et lag når venstre kant av skjermen, tilbakestill posisjonen til høyre, og skaper en kontinuerlig rulleeffekt.

Endelig, tegne hvert rektangulære bakgrunnslag på skjermen ved hjelp av pygame.draw.rect() og passerer den tilsvarende fargen og pygame. Rekt objekt.

Legge til en parallakseeffekt mens du beveger deg

For å forbedre parallakseeffekten kan du endre plattformbevegelsen slik at den oppstår når spilleren beveger seg. Dette vil skape en sterk følelse av dybde og dynamisk bevegelse. Opprett en ny fil med navnet parallax.py og legg til koden med oppdateringene nedenfor:

# Definer plattformposisjonene og hastighetene
rect1 = pygame. Rekt(50, skjermhøyde - 100, 200, 10)
rect2 = pygame. Rekt (skjermbredde - 250, skjermhøyde - 200, 200, 10)
plattformer = [
 {"riktig": rect1, "hastighet": 3},
 {"riktig": rect2, "hastighet": 1}
]
# Legg til denne koden i spillløkken
# Spillerbevegelse
keys = pygame.key.get_pressed()
hvis keys[pygame. K_LEFT] og player_x > 0:
 player_x -= player_speed
til plattform i plattformer:
 plattform["riktig"].x -= plattform["hastighet"]
hvis keys[pygame. K_RIGHT] og player_x < screen_width:
 player_x += player_speed
til plattform i plattformer:
 plattform["riktig"].x += plattform["hastighet"]
til plattform i plattformer:
 pygame.draw.rect (skjerm, (0, 255, 0), plattform["riktig"])

Representer plattformene som ordbøker som inneholder både rektangelobjektet (rekt) og hastigheten plattformen skal bevege seg med (hastighet). Plattformene oppdateres i spillløkken basert på spillerens bevegelse.

Ved å implementere denne modifikasjonen vil rulleeffekten bare være aktiv når spilleren aktivt beveger seg, noe som ytterligere forsterker illusjonen av dybde og bevegelse.

Inkludert tilleggsfunksjoner

Du kan implementere flere tilleggsfunksjoner for å forbedre rullebakgrunnen i spillet ditt. Her er noen eksempler.

Randomiser bakgrunnsfarger

For å legge til variasjon til bakgrunnslagene, kan du randomisere fargene deres. Du kan gjøre dette ved å endre bakgrunnsfarger liste:

import tilfeldig
# Legg til denne koden før spillløkken
bakgrunnsfarger = [
 (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)),
 (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)),
 (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
]

Legg til flere bakgrunnslag

Du kan eksperimentere med å legge til flere bakgrunnslag for å skape en rikere parallakseeffekt. Bare definer tillegg pygame. Rect objekter, farger og hastigheter:

# Legg til denne koden før spillløkken
bakgrunnslag = [
 pygame. Rekt(0, 0, screen_width, screen_height), 
 pygame. Rekt(0, 0, screen_width, screen_height), 
 pygame. Rekt(0, 0, screen_width, screen_height), 
 pygame. Rekt(0, 0, screen_width, screen_height) 
]
bakgrunnsfarger = [
 (30, 30, 30),
 (60, 60, 60),
 (90, 90, 90),
 (120, 120, 120)
]
bakgrunnshastigheter = [1, 2, 3, 4]

Bruk bilder som bakgrunn

I stedet for solide farger kan du bruke bildefiler som bakgrunn. Pygame tilbyr funksjoner for å laste og gjengi bilder.

Last inn bildefilene background_0.png, background_1.png, og background_2.png ved hjelp av pygame.image.load(). Bruk convert()-metoden for å forbedre ytelsen og skalere bildene for å matche skjermdimensjonene pygame.transform.scale().

# Legg til denne koden før spillløkken
bakgrunnsbilder = [
 pygame.image.load("background_0.png").konvertere(),
 pygame.image.load("background_1.png").konvertere(),
 pygame.image.load("background_2.png").konvertere()
]
bakgrunnshastigheter = [1, 2, 3]
til Jeg i område (len (bakgrunnsbilder)):
 størrelse = (skjermbredde, skjermhøyde)
 background_images[i] = pygame.transform.scale (background_images[i], størrelse)

Til slutt oppdaterer du løkken der du tegner bakgrunnslagene for å bruke bildene:

# Oppdater denne koden inne i spillsløyfen
til Jeg i område (len (background_layers)):
 background_layers[i].x -= background_speeds[i]
hvis bakgrunnslag[i].x <= -skjermbredde:
 bakgrunnslag[i].x = 0
 screen.blit (bakgrunnsbilder[i], bakgrunnslag[i])

Her er noen beste fremgangsmåter du bør vurdere når du implementerer rullebakgrunner i Pygame-prosjektene dine.

Optimaliser ytelsen

Rullebakgrunner innebærer kontinuerlig gjengivelse og oppdatering. For å sikre jevn spilling bør du vurdere å optimalisere koden din og minimere unødvendige beregninger.

Eksperimenter med laghastigheter

Justering av hastighetene til bakgrunnslagene kan skape forskjellige effekter. Lek med ulike verdier for å finne den rette balansen og oppnå ønsket visuell effekt.

Test på forskjellige skjermstørrelser

Sørg for at rullebakgrunnene dine fungerer godt på forskjellige skjermoppløsninger. Vurder å implementere dynamisk skalering eller bruke forskjellige bakgrunnsbilder for forskjellige størrelsesforhold.

Bruk passende bildeformater

Hvis du bestemmer deg for å bruke bilder som bakgrunn, velg riktig bildeformat (f.eks. PNG, JPEG) for å balansere filstørrelse og bildekvalitet. Du kan også redusere lastetidene ved å komprimere og optimalisere bildene dine.

Vurder minnebruk

Hvis du planlegger å bruke mange høyoppløselige bilder for bakgrunnen din, vær oppmerksom på minnekravene. Store bilder kan forbruke en betydelig mengde minne, og potensielt påvirke ytelsen og responsen til spillet ditt.

Ved å inkludere rullebakgrunner kan du skape forskjellige miljøer, for eksempel bevegelige landskap, futuristiske bylandskap eller undervannsverdener. Parallakseeffekten gir et dynamisk preg, slik at spillverdenen føles levende og interaktiv.

Husk å eksperimentere, gjenta og utforske kreative muligheter med rullebakgrunner for å gjøre spillene dine mer morsomme og fengslende for spillere.