Hur man implementerar rullande bakgrunder i Pygame

Att rulla bakgrunder kan avsevärt förbättra den visuella överklagandet och djupet i ett spel. De kan skapa en illusion av rörelse, vilket ger spelet en dynamisk och uppslukande känsla. Du kan implementera rullande bakgrunder med bara några enkla steg med Pygame.

Pygame är ett populärt Python-bibliotek som du kan använda för att utveckla spel. Att lägga till rullande bakgrunder till dina Pygame-projekt kommer att ge dem liv och ge en mer engagerande upplevelse för spelarna.

Skapa ett enkelt spel

För att förstå konceptet med att rulla bakgrunder i Pygame, börja med att skapa ett enkelt spel där spelaren kan flytta åt vänster och höger. Du kan också inkludera två plattformar, representerade av rektanglar, för att fungera som spelmiljö. Skapa en ny fil med namnet simple-game.py.

Koden som används i den här artikeln är tillgänglig i denna GitHub-förråd och är gratis för dig att använda under MIT-licensen.

Importera först pygame-modulen och initiera den. Definiera sedan spelarens startposition och rörelsehastighet. Skapa plattformar med hjälp av pygame. Rect objekt och definiera deras positioner och dimensioner.

Inuti spelslingan, hantera händelser som att avsluta spelet. Du kan också hantera spelarens rörelse baserat på touch- eller tangentbordsingångar.

Här är resultatet av det enkla spelet:

Skapa olika lager

För att uppnå rullningseffekten kan du skapa flera lager av bakgrunder med olika färger. Varje lager kommer att röra sig med olika hastighet, vilket skapar en parallaxeffekt. Denna effekt ger en illusion av djup och förstärker känslan av rörelse i spelet.

Definiera två bakgrundslager, som vart och ett täcker hela spelfönstret, med hjälp av pygame. Rekta föremål. Definiera också färgerna för varje lager i bakgrundsfärger lista. De bakgrundshastigheter listan bestämmer hastigheten med vilken varje lager kommer att röra sig.

# Lägg till den här koden under föregående avsnitt
bakgrundsskikt = [
 pygame. Rekt(0, 0, screen_width, screen_height), 
 pygame. Rekt(0, 0, screen_width, screen_height) 
]
bakgrundsfärger = [(30, 30, 30), (60, 60, 60)]
bakgrundshastigheter = [0.1, 1.0]

För att skapa den rullande bakgrundseffekten måste du uppdatera positionerna för bakgrundslagren i spelslingan. Du flyttar varje lager horisontellt baserat på dess tilldelade hastighet.

Skapa en ny fil med namnet scrolling-bg.py och lägg till koden med följande uppdateringar:

för i i område (len (bakgrundsskikt)):
 bakgrundsskikt[i].x -= bakgrundshastigheter[i]
om bakgrundsskikt[i].x <= -skärmbredd:
 bakgrundsskikt[i].x = 0
 pygame.draw.rect (skärm, bakgrundsfärger[i], bakgrundsskikt[i])

Iterera genom varje bakgrundslager. Subtrahera motsvarande hastighet från lagrets x-koordinat, vilket gör att det flyttas åt vänster. Om ett lager når den vänstra kanten av skärmen, återställ dess position till höger, vilket skapar en kontinuerlig rullningseffekt.

Till sist, rita varje rektangulärt bakgrundslager på skärmen med hjälp av pygame.draw.rect() och passerar motsvarande färg och pygame. Rätt objekt.

Lägga till en parallaxeffekt när du rör dig

För att förbättra parallaxeffekten kan du ändra plattformsrörelsen så att den inträffar när spelaren rör sig. Detta kommer att skapa en stark känsla av djup och dynamisk rörelse. Skapa en ny fil med namnet parallax.py och lägg till koden med följande uppdateringar:

# Definiera plattformens positioner och hastigheter
rect1 = pygame. Rekt(50, skärmhöjd - 100, 200, 10)
rect2 = pygame. Rect (skärmbredd - 250, skärmhöjd - 200, 200, 10)
plattformar = [
 {"rätt": rect1, "fart": 3},
 {"rätt": rect2, "fart": 1}
]
# Lägg till den här koden i spelslingan
# Spelarens rörelse
keys = pygame.key.get_pressed()
om nycklar[pygame. K_LEFT] och player_x > 0:
 player_x -= player_speed
för plattform i plattformar:
 plattform["rätt"].x -= plattform["fart"]
om nycklar[pygame. K_RIGHT] och player_x < screen_width:
 player_x += player_speed
för plattform i plattformar:
 plattform["rätt"].x += plattform["fart"]
för plattform i plattformar:
 pygame.draw.rect (skärm, (0, 255, 0), plattform["rätt"])

Representera plattformarna som ordböcker som innehåller både rektangelobjektet (rect) och hastigheten med vilken plattformen ska röra sig (hastighet). Plattformarna uppdateras i spelslingan baserat på spelarens rörelse.

Genom att implementera denna modifiering kommer rullningseffekten endast att vara aktiv när spelaren aktivt rör sig, vilket ytterligare förstärker illusionen av djup och rörelse.

Inklusive ytterligare funktioner

Du kan implementera flera ytterligare funktioner för att förbättra rullningsbakgrunderna i ditt spel. Här är några exempel.

Randomisera bakgrundsfärger

För att lägga till variation till bakgrundslagren kan du slumpvisa deras färger. Du kan göra detta genom att ändra bakgrundsfärger lista:

importera slumpmässig
# Lägg till den här koden före spelslingan
bakgrundsfärger = [
 (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))
]

Lägg till fler bakgrundslager

Du kan experimentera med att lägga till fler bakgrundslager för att skapa en rikare parallaxeffekt. Definiera helt enkelt ytterligare pygame. Rect objekt, färger och hastigheter:

# Lägg till den här koden före spelslingan
bakgrundsskikt = [
 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) 
]
bakgrundsfärger = [
 (30, 30, 30),
 (60, 60, 60),
 (90, 90, 90),
 (120, 120, 120)
]
bakgrundshastigheter = [1, 2, 3, 4]

Använd bilder för bakgrunder

Istället för solida färger kan du använda bildfiler som bakgrund. Pygame tillhandahåller funktioner för att ladda och rendera bilder.

Ladda bildfilerna background_0.png, background_1.png, och background_2.png använder sig av pygame.image.load(). Använd metoden convert() för att förbättra prestanda och skala bilderna så att de matchar skärmdimensionerna pygame.transform.scale().

# Lägg till den här koden före spelslingan
bakgrundsbilder = [
 pygame.image.load("background_0.png").konvertera(),
 pygame.image.load("background_1.png").konvertera(),
 pygame.image.load("background_2.png").konvertera()
]
bakgrundshastigheter = [1, 2, 3]
för i i intervall (len (bakgrundsbilder)):
 storlek = (skärmbredd, skärmhöjd)
 background_images[i] = pygame.transform.scale (background_images[i], storlek)

Uppdatera slutligen slingan där du ritar bakgrundslagren för att använda bilderna:

# Uppdatera den här koden i spelslingan
för i i område (len (bakgrundsskikt)):
 bakgrundsskikt[i].x -= bakgrundshastigheter[i]
om bakgrundsskikt[i].x <= -skärmbredd:
 bakgrundsskikt[i].x = 0
 screen.blit (bakgrundsbilder[i], bakgrundsskikt[i])

Här är några bästa metoder att tänka på när du implementerar rullande bakgrunder i dina Pygame-projekt.

Optimera prestanda

Rulla bakgrunder innebär kontinuerlig rendering och uppdatering. För att säkerställa smidigt spelande, överväg att optimera din kod och minimera onödiga beräkningar.

Experimentera med lagerhastigheter

Att justera hastigheten för bakgrundslagren kan skapa olika effekter. Lek med olika värden för att hitta rätt balans och uppnå önskad visuell effekt.

Testa på olika skärmstorlekar

Se till att dina rullande bakgrunder fungerar bra på olika skärmupplösningar. Överväg att implementera dynamisk skalning eller använda olika bakgrundsbilder för olika bildförhållanden.

Använd lämpliga bildformat

Om du bestämmer dig för att använda bilder för dina bakgrunder, välj lämpligt bildformat (t.ex. PNG, JPEG) för att balansera filstorlek och bildkvalitet. Du kan också minska laddningstiderna genom att komprimera och optimera dina bilder.

Tänk på minnesanvändning

Om du planerar att använda många högupplösta bilder för dina bakgrunder, var uppmärksam på minneskraven. Stora bilder kan konsumera en betydande mängd minne, vilket potentiellt kan påverka ditt spels prestanda och lyhördhet.

Genom att inkludera rullande bakgrunder kan du skapa olika miljöer, som rörliga landskap, futuristiska stadsbilder eller undervattensvärldar. Parallaxeffekten ger en dynamisk touch, vilket gör att spelvärlden känns levande och interaktiv.

Kom ihåg att experimentera, iterera och utforska kreativa möjligheter med rullande bakgrunder för att göra dina spel roligare och fängslande för spelare.