Pythons Arcade-bibliotek tilbyr en enkel og effektiv måte å implementere spillnivåer i prosjektene dine på.

Spillutvikling er en spennende og kreativ prosess som lar deg bringe dine fantasifulle ideer til live. Når du designer et spill, er et av nøkkelelementene som i stor grad kan forbedre spilleropplevelsen implementeringen av spillnivåer.

Nivåer gir struktur, progresjon og utfordringer, og gir spillerne en følelse av prestasjon og engasjement når de navigerer gjennom ulike stadier av spillet.

Lag et enkelt spill

Før du starter, sørg for at du har pip installert på enheten din. Bruk denne kommandoen til å installere arkade bibliotek:

pip installer arkade

Lag et grunnleggende spill hvor spilleren kan bevege seg til venstre og høyre.

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

Bruk egenskapene til Arcade-biblioteket til å håndtere brukerinndata og oppdater spilltilstanden deretter. Opprett en ny fil med navnet simple-game.py og legg til koden nedenfor:

instagram viewer 
import arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


klasseMitt Spill(arkade. Vindu):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spill")
 arcade.set_background_color (arcade.color. HVIT)
 self.player_x = SCREEN_WIDTH // 2


defon_draw(selv):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkade.farge. BLÅ)


defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.player_x -= 10
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.player_x += 10


defon_key_release(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE eller nøkkel == arkade.nøkkel. IKKE SANT:
sende


defhoved-():
 spill = MyGame()
 arcade.run()
hvis __navn__ == "__hoved__":
 hoved()

Nedenfor er utgangen:

Lag flere nivåer

Nå kan du utvide spillet ved å legge til flere nivåer. Hvert nivå vil ha sine egne unike egenskaper, som gir forskjellige utfordringer for spilleren. Du kan endre den forrige koden for å inkludere flere nivåer. Her er et eksempel:

klasseLevelOne:
def__i det__(selv):
 self.player_x = SCREEN_WIDTH // 2
defOppdater(selv):
sende


deftegne(selv):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkade.farge. BLÅ)


klasseNivå to:
def__i det__(selv):
 self.player_x = SCREEN_WIDTH // 2


defOppdater(selv):
sende


deftegne(selv):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkade.farge. RØD)


klasseMitt Spill(arkade. Vindu):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spill")
 arcade.set_background_color (arcade.color. HVIT)
 self.levels = [LevelOne(), LevelTo()]
 self.current_level = 0


defon_draw(selv):
 arcade.start_render()
 self.levels[self.current_level].draw()


defon_key_press(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE:
 self.levels[self.current_level].player_x -= 10
elif nøkkel == arkade.nøkkel. IKKE SANT:
 self.levels[self.current_level].player_x += 10


defon_key_release(selv, nøkkel, modifikatorer):
hvis nøkkel == arkade.nøkkel. VENSTRE eller nøkkel == arkade.nøkkel. IKKE SANT:
sende


defOppdater(selv, delta_tid):
 self.levels[self.current_level].update()


defhoved-():
 spill = MyGame()
 arcade.run()
hvis __navn__ == "__hoved__":
 hoved()

Overgang mellom nivåer

For å skape en jevn overgang mellom nivåer, registrer når spilleren krysser en spesifikk grense. Du kan spore spillerens bevegelser, og når spilleren krysser grensen, kan du bytte til neste nivå. Opprett en ny fil med navnet transition-between-levels.py og legg til koden med oppdateringene nedenfor:

klasseMitt Spill(arkade. Vindu):
# ...
defOppdater(selv, delta_tid):
 self.levels[self.current_level].update()


# Sjekk om spilleren krysset grensen
hvis self.levels[self.current_level].player_x < 0:
 self.current_level += 1
 self.current_level %= len (self.levels)
 self.levels[self.current_level].player_x = SCREEN_WIDTH
elif self.levels[self.current_level].player_x > SCREEN_WIDTH:
 self.current_level += 1
 self.current_level %= len (self.levels)
 self.levels[self.current_level].player_x = 0
# ...

Nedenfor er utgangen:

Inkludert tilleggsfunksjoner

For å gjøre spillnivåene dine mer engasjerende, kan du inkludere tilleggsfunksjoner som power-ups og mål.

Mål

Mål gir spesifikke mål eller mål for spilleren å oppnå innenfor et nivå. De gir en følelse av hensikt og fremgang. Her er et eksempel på implementering av en objektiv funksjon:

klasseObjektiv:
def__i det__(selv, x, y):
 selv.x = x
 self.y = y
 self.radius = 20
deftegne(selv):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GRØNN)


klasseLevelOne:
def__i det__(selv):
 self.objective = Objective(600, 400)
# ...


defOppdater(selv):
# Sjekk om spilleren når målet
hvis arcade.check_for_collision (selv.spiller, self.objective):
 self.complete_objective()


deftegne(selv):
 self.objective.draw()
# ...
defkomplett_mål(selv):
# Kode for å håndtere objektiv fullføring
sende

Samleobjekter

Samleobjekter er gjenstander eller bonuser som spilleren kan samle gjennom nivåene. Her er et eksempel på implementering av en samleobjekt:

klasseSamleobjekt:
def__i det__(selv, x, y):
 selv.x = x
 self.y = y
 self.radius = 10
 self.is_collected = Falsk
deftegne(selv):
hvisikke self.is_collected:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. ORANSJE)


defsamle inn(selv):
 self.is_collected = ekte
# Kode for å håndtere samleobjektets effekt på spilleren


klasseLevelOne:
def__i det__(selv):
 self.collectible = Collectible(300, 300)
# ...


defOppdater(selv):
# Sjekk om spilleren samler varen
hvis arcade.check_for_collision (selv.spiller, self.collectible):
 self.collectible.collect()
deftegne(selv):
 self.collectible.draw()
# ...

Hindringer

Hindringer kan være statiske objekter eller bevegelige enheter som hindrer spillerens vei. De krever at spilleren legger strategier og finner måter å overvinne dem på. Her er et eksempel på implementering av hindringer-funksjonen:

klasseHindring:
def__i det__(selv, x, y, bredde, høyde):
 selv.x = x
 self.y = y
 self.width = bredde
 selv.høyde = høyde
deftegne(selv):
 arcade.draw_rectangle_filled (self.x, self.y, self.width, self.height, arcade.color. GRÅ)
klasseLevelOne:
def__i det__(selv):
 self.obstacles = [Obstacle(400, 200, 100, 50), Hindring(600, 500, 80, 120)]
# ...

Power-ups

Power-ups kan forbedre spillerens evner eller gi midlertidige fordeler. Her er et eksempel på implementering av en oppstartsfunksjon:

klasseStart opp:
def__i det__(selv, x, y):
 selv.x = x
 self.y = y
 self.radius = 10
 self.is_active = ekte
deftegne(selv):
hvis self.is_active:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GUL)


defactivate_power_up(selv):
 self.is_active = ekte


defdeactivate_power_up(selv):
 self.is_active = Falsk


klasseLevelOne:
def__i det__(selv):
 self.power_up = PowerUp(200, 200)
# ...


defOppdater(selv):
# Sjekk om spilleren kolliderer med oppstart
hvis arcade.check_for_collision (self.player, self.power_up):
 self.player.activate_power_up()
 self.power_up.deactivate_power_up()
deftegne(selv):
 self.power_up.draw()
# ...

Beste praksis for nivådesign

Nivådesign spiller en avgjørende rolle for å skape engasjerende og morsomme spillopplevelser. Her er noen beste fremgangsmåter du bør vurdere når du designer nivåer for spillet ditt:

Klare mål

Hvert nivå bør ha et klart mål eller mål for spilleren å oppnå. Enten det er å nå et bestemt sted, beseire fiender eller løse gåter, bør målet være godt definert og kommunisert til spilleren.

Gradvis vanskelighetsgrad

Designnivåer med gradvis økning i vanskelighetsgrad for å gi en jevn læringskurve for spillere. Start med enklere utfordringer og introduser gradvis ny mekanikk eller hindringer etter hvert som spilleren skrider frem. Plutselige stigninger i vanskelighetsgraden kan frustrere spillere, så det er viktig å opprettholde en balansert progresjon.

Visuell klarhet

Sørg for at nivådesignet og visuelle elementer tydelig kommuniserer viktig informasjon til spilleren. Inkluderer musikk og lydeffekter kan også formidle viktige ledetråder og gi viktig informasjon til spilleren.

Spilletesting og iterasjon

Regelmessige leketesting er avgjørende for å foredle og forbedre nivådesignet. Samle tilbakemeldinger fra spillere og observer deres erfaringer for å identifisere områder som kan kreve justeringer. Gjenta nivådesignet ditt basert på denne tilbakemeldingen for å skape morsommere og mer balansert spilling.

Balanser belønning og utfordring

Belønn spillere for å overvinne utfordringer på nivåene dine. Dette kan oppnås gjennom power-ups, samleobjekter, låse opp nye områder eller narrativ progresjon. Å balansere vanskelighetsgraden til utfordringene med meningsfulle belønninger hjelper med å motivere spillere og gir en følelse av prestasjon.

Gjør spill mer engasjerende med nivåer

Ved å implementere spillnivåer kan du forbedre den generelle spilleropplevelsen og skape et mer engasjerende spillmiljø. Nivåer gir progresjon, utfordring og variasjon, og holder spillerne investert og motivert. De lar deg introdusere ny mekanikk, hindringer, fiender og belønninger, og sikrer at hvert nivå føles distinkt og spennende.