Sådan implementeres rullebaggrunde i Pygame

Rullebaggrunde kan i høj grad forbedre den visuelle appel og dybden af ​​et spil. De kan skabe en illusion af bevægelse, hvilket giver spillet en dynamisk og fordybende følelse. Du kan implementere rullebaggrunde i nogle få enkle trin ved hjælp af Pygame.

Pygame er et populært Python-bibliotek, du kan bruge til at udvikle spil. Tilføjelse af rullebaggrunde til dine Pygame-projekter vil bringe dem til live og give spillere en mere engagerende oplevelse.

Opret et simpelt spil

For at forstå konceptet med at rulle baggrunde i Pygame, start med at skabe et simpelt spil, hvor spilleren kan bevæge sig til venstre og højre. Du kan også inkludere to platforme, repræsenteret ved rektangler, for at tjene som spilmiljøet. Opret en ny fil med navnet simple-game.py.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

Først skal du importere pygame-modulet og initialisere det. Definer derefter spillerens startposition og bevægelseshastighed. Opret platforme vha pygame. Rect objekter og definere deres positioner og dimensioner.

Inde i spilløkken skal du håndtere begivenheder såsom at forlade spillet. Du kan også klare spillerbevægelse baseret på berørings- eller tastaturinput.

Her er resultatet af det simple spil:

Opret forskellige lag

For at opnå rulleeffekten kan du oprette flere lag af baggrunde med forskellige farver. Hvert lag vil bevæge sig med en forskellig hastighed, hvilket skaber en parallakseeffekt. Denne effekt giver en illusion af dybde og øger følelsen af ​​bevægelse i spillet.

Definer to baggrundslag, der hver dækker hele spilvinduet, ved hjælp af pygame. Ret objekter. Definer også farverne på hvert lag i baggrundsfarver liste. Det baggrundshastigheder listen bestemmer hastigheden, hvormed hvert lag vil bevæge sig.

# Tilføj denne kode under det forrige afsnit
baggrundslag = [
 pygame. Rekt(0, 0, screen_width, screen_height), 
 pygame. Rekt(0, 0, screen_width, screen_height) 
]
baggrundsfarver = [(30, 30, 30), (60, 60, 60)]
baggrundshastigheder = [0.1, 1.0]

For at skabe den rullende baggrundseffekt skal du opdatere placeringen af ​​baggrundslagene i spilløkken. Du flytter hvert lag vandret baseret på dets tildelte hastighed.

Opret en ny fil med navnet scrolling-bg.py og tilføj koden med nedenstående opdateringer:

til jeg i interval (len (baggrundslag)):
 baggrundslag[i].x -= baggrundshastigheder[i]
hvis baggrundslag[i].x <= -skærmbredde:
 baggrundslag[i].x = 0
 pygame.draw.rect (skærm, baggrundsfarver[i], baggrundslag[i])

Gentag gennem hvert baggrundslag. Træk den tilsvarende hastighed fra lagets x-koordinat, hvilket får det til at bevæge sig til venstre. Hvis et lag når den venstre kant af skærmen, skal du nulstille dets position til højre, hvilket skaber en kontinuerlig rulleeffekt.

Endelig, tegne hvert rektangulært baggrundslag på skærmen ved hjælp af pygame.draw.rect() og passerer den tilsvarende farve og pygame. Ret objekt.

Tilføjelse af en parallakseeffekt under bevægelse

For at forstærke parallakseeffekten kan du ændre platformsbevægelsen, så den finder sted, når spilleren bevæger sig. Dette vil skabe en stærk følelse af dybde og dynamisk bevægelse. Opret en ny fil med navnet parallax.py og tilføj koden med nedenstående opdateringer:

# Definer platformens positioner og hastigheder
rect1 = pygame. Rekt(50, skærmhøjde - 100, 200, 10)
rect2 = pygame. Rekt (skærmbredde - 250, skærmhøjde - 200, 200, 10)
platforme = [
 {"rigtigt": rect1, "fart": 3},
 {"rigtigt": rect2, "fart": 1}
]
# Tilføj denne kode i spilløkken
# Spillerbevægelse
keys = pygame.key.get_pressed()
hvis nøgler[pygame. K_LEFT] og player_x > 0:
 player_x -= player_speed
til platform i platforme:
 platform["rigtigt"].x -= platform["fart"]
hvis nøgler[pygame. K_RIGHT] og player_x < screen_width:
 player_x += player_speed
til platform i platforme:
 platform["rigtigt"].x += platform["fart"]
til platform i platforme:
 pygame.draw.rect (skærm, (0, 255, 0), platform["rigtigt"])

Repræsenter platformene som ordbøger, der indeholder både rektangelobjektet (rekt) og den hastighed, hvormed platformen skal bevæge sig (hastighed). Platformene opdateres i spilløkken baseret på spillerens bevægelse.

Ved at implementere denne modifikation vil rulleeffekten kun være aktiv, når spilleren aktivt bevæger sig, hvilket yderligere forstærker illusionen om dybde og bevægelse.

Inklusiv yderligere funktioner

Du kan implementere flere ekstra funktioner for at forbedre rullebaggrundene i dit spil. Her er nogle eksempler.

Randomiser baggrundsfarver

For at tilføje variation til baggrundslagene kan du randomisere deres farver. Du kan gøre dette ved at ændre baggrundsfarver liste:

importere tilfældig
# Tilføj denne kode før spilsløjfen
baggrundsfarver = [
 (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))
]

Tilføj flere baggrundslag

Du kan eksperimentere med at tilføje flere baggrundslag for at skabe en rigere parallakseeffekt. Du skal blot definere yderligere pygame. Rect objekter, farver og hastigheder:

# Tilføj denne kode før spilsløjfen
baggrundslag = [
 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) 
]
baggrundsfarver = [
 (30, 30, 30),
 (60, 60, 60),
 (90, 90, 90),
 (120, 120, 120)
]
baggrundshastigheder = [1, 2, 3, 4]

Brug billeder til baggrunde

I stedet for solide farver kan du bruge billedfiler som baggrunde. Pygame giver funktioner til at indlæse og gengive billeder.

Indlæs billedfilerne baggrund_0.png, baggrund_1.png, og baggrund_2.png ved brug af pygame.image.load(). Brug convert()-metoden til at forbedre ydeevnen og skalere billederne, så de matcher skærmdimensionerne pygame.transform.scale().

# Tilføj denne kode før spilsløjfen
baggrundsbilleder = [
 pygame.image.load("baggrund_0.png").konvertere(),
 pygame.image.load("baggrund_1.png").konvertere(),
 pygame.image.load("baggrund_2.png").konvertere()
]
baggrundshastigheder = [1, 2, 3]
til jeg i interval (len (baggrundsbilleder)):
 størrelse = (skærmbredde, skærmhøjde)
 background_images[i] = pygame.transform.scale (baggrundsbilleder[i], størrelse)

Til sidst skal du opdatere løkken, hvor du tegner baggrundslagene, for at bruge billederne:

# Opdater denne kode inde i spilløkken
til jeg i interval (len (baggrundslag)):
 baggrundslag[i].x -= baggrundshastigheder[i]
hvis baggrundslag[i].x <= -skærmbredde:
 baggrundslag[i].x = 0
 screen.blit (baggrundsbilleder[i], baggrundslag[i])

Her er nogle bedste praksis at overveje, når du implementerer rullebaggrunde i dine Pygame-projekter.

Optimer ydeevnen

Rullebaggrunde involverer kontinuerlig gengivelse og opdatering. For at sikre glat gameplay, overvej at optimere din kode og minimere unødvendige beregninger.

Eksperimenter med laghastigheder

Justering af hastighederne på baggrundslagene kan skabe forskellige effekter. Leg med forskellige værdier for at finde den rigtige balance og opnå den ønskede visuelle effekt.

Test på forskellige skærmstørrelser

Sørg for, at dine rullebaggrunde fungerer godt på forskellige skærmopløsninger. Overvej at implementere dynamisk skalering eller bruge forskellige baggrundsbilleder til forskellige billedformater.

Brug passende billedformater

Hvis du beslutter dig for at bruge billeder til dine baggrunde, skal du vælge det passende billedformat (f.eks. PNG, JPEG) for at balancere filstørrelse og billedkvalitet. Du kan også reducere indlæsningstiden ved at komprimere og optimere dine billeder.

Overvej hukommelsesbrug

Hvis du planlægger at bruge mange billeder i høj opløsning til dine baggrunde, skal du være opmærksom på hukommelseskravene. Store billeder kan forbruge en betydelig mængde hukommelse, hvilket potentielt kan påvirke dit spils ydeevne og reaktionsevne.

Ved at inkorporere rullebaggrunde kan du skabe forskellige miljøer, såsom bevægende landskaber, futuristiske bylandskaber eller undervandsverdener. Parallakseeffekten tilføjer et dynamisk touch, så spilverdenen føles levende og interaktiv.

Husk at eksperimentere, gentage og udforske kreative muligheder med rullebaggrunde for at gøre dine spil sjovere og mere fængslende for spillere.