Sådan implementeres spilniveauer i Pythons arkade

Pythons Arcade-bibliotek tilbyder en ligetil og effektiv måde at implementere spilniveauer i dine projekter.

Spiludvikling er en spændende og kreativ proces, der giver dig mulighed for at føre dine fantasifulde ideer ud i livet. Når man designer et spil, er et af nøgleelementerne, der i høj grad kan forbedre spilleroplevelsen, implementeringen af spilniveauer.

Niveauer giver struktur, progression og udfordringer, hvilket giver spillerne en følelse af præstation og engagement, når de navigerer gennem forskellige stadier af spillet.

Opret et simpelt spil

Før du starter, skal du sikre dig, at du har pip installeret på din enhed. Brug denne kommando til at installere arkade bibliotek:

pip installere arkade

Lav et grundlæggende spil, hvor spilleren kan bevæge sig til venstre og højre.

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

Udnyt mulighederne i Arcade-biblioteket til at håndtere brugerinput og opdatere spillets tilstand i overensstemmelse hermed. Opret en ny fil med navnet simple-game.py og tilføj nedenstående kode:

instagram viewer

importere arkadeSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
klasseMit Spil(arkade. Vindue):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mit spil")
 arcade.set_background_color (arcade.color. HVID)
 self.player_x = SCREEN_WIDTH // 2
defon_draw(selv):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkade.farve. BLÅ)
defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= 10
elif nøgle == arkade.nøgle. HØJRE:
 self.player_x += 10
defon_key_release(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE eller nøgle == arkade.nøgle. HØJRE:
passere
defvigtigste():
 spil = Mit Spil()
 arcade.run()hvis __navn__ == "__main__":
 hoved()

Nedenfor er output:

Opret flere niveauer

Udvid nu spillet ved at tilføje flere niveauer. Hvert niveau vil have sine egne unikke karakteristika, der giver spilleren forskellige udfordringer. Du kan ændre den tidligere kode til at inkludere yderligere niveauer. Her er et eksempel:

klasseLevelOne:
def__i det__(selv):
 self.player_x = SCREEN_WIDTH // 2defopdatering(selv):
passere
deftegne(selv):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkade.farve. BLÅ)
klasseNiveau to:
def__i det__(selv):
 self.player_x = SCREEN_WIDTH // 2
defopdatering(selv):
passere
deftegne(selv):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkade.farve. RØD)
klasseMit Spil(arkade. Vindue):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mit spil")
 arcade.set_background_color (arcade.color. HVID)
 self.levels = [LevelOne(), LevelTwo()]
 self.current_level = 0
defon_draw(selv):
 arcade.start_render()
 self.levels[self.current_level].draw()
defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.levels[self.current_level].player_x -= 10
elif nøgle == arkade.nøgle. HØJRE:
 self.levels[self.current_level].player_x += 10
defon_key_release(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE eller nøgle == arkade.nøgle. HØJRE:
passere
defopdatering(selv, delta_tid):
 self.levels[self.current_level].update()
defvigtigste():
 spil = Mit Spil()
 arcade.run()hvis __navn__ == "__main__":
 hoved()

Overgang mellem niveauer

For at skabe en jævn overgang mellem niveauer skal du registrere, hvornår spilleren krydser en specifik grænse. Du kan spore spillerens bevægelse, og når spilleren krydser grænsen, kan du skifte til næste niveau. Opret en ny fil med navnet transition-between-levels.py og tilføj koden med nedenstående opdateringer:

klasseMit Spil(arkade. Vindue):
# ...defopdatering(selv, delta_tid):
 self.levels[self.current_level].update()
# Tjek om spilleren krydsede grænsen
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 output:

Inklusiv yderligere funktioner

For at gøre dine spilniveauer mere engagerende kan du inkorporere yderligere funktioner såsom power-ups og mål.

Mål

Mål giver specifikke mål eller mål, som spilleren kan nå inden for et niveau. De tilføjer en følelse af formål og fremskridt. Her er et eksempel på implementering af en objektiv funktion:

klasseObjektiv:
def__i det__(selv, x, y):
 selv.x = x
 self.y = y
 selv.radius = 20deftegne(selv):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GRØN)
klasseLevelOne:
def__i det__(selv):
 self.objective = Objektiv(600, 400)
# ...
defopdatering(selv):
# Tjek om spilleren når målet
hvis arcade.check_for_collision (self.player, self.objective):
 self.complete_objective()
deftegne(selv):
 self.objective.draw()
# ...defkomplet_mål(selv):
# Kode til at håndtere objektiv fuldførelse
passere

Samlerobjekter

Samleobjekter er genstande eller bonusser, som spilleren kan samle gennem niveauerne. Her er et eksempel på implementering af en samlefunktion:

klasseSamlerobjekt:
def__i det__(selv, x, y):
 selv.x = x
 self.y = y
 selv.radius = 10
 self.is_collected = Falskdeftegne(selv):
hvisikke self.is_collected:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. ORANGE)
defindsamle(selv):
 self.is_collected = Rigtigt
# Kode til at håndtere samleobjektets effekt på spilleren
klasseLevelOne:
def__i det__(selv):
 self.collectible = Collectible(300, 300)
# ...
defopdatering(selv):
# Tjek om spilleren samler varen
hvis arcade.check_for_collision (self.player, self.collectible):
 self.collectible.collect()deftegne(selv):
 self.collectible.draw()
# ...

Forhindringer

Forhindringer kan være statiske objekter eller bevægelige enheder, der hindrer spillerens vej. De kræver, at spilleren strategierer og finder måder at overvinde dem på. Her er et eksempel på implementering af funktionen forhindringer:

klasseHindring:
def__i det__(selv, x, y, bredde, højde):
 selv.x = x
 self.y = y
 self.width = bredde
 selv.højde = højdedeftegne(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), Forhindring(600, 500, 80, 120)]
# ...

Power-ups

Power-ups kan forbedre spillerens evner eller give midlertidige fordele. Her er et eksempel på implementering af en opstartsfunktion:

klasseOpstart:
def__i det__(selv, x, y):
 selv.x = x
 self.y = y
 selv.radius = 10
 self.is_active = Rigtigtdeftegne(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 = Rigtigt
defdeactivate_power_up(selv):
 self.is_active = Falsk
klasseLevelOne:
def__i det__(selv):
 self.power_up = PowerUp(200, 200)
# ...
defopdatering(selv):
# Tjek om afspilleren kolliderer med opstarten
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()
# ...

Bedste praksis for niveaudesign

Niveaudesign spiller en afgørende rolle i at skabe engagerende og underholdende spiloplevelser. Her er nogle bedste fremgangsmåder, du skal overveje, når du designer niveauer til dit spil:

Klare mål

Hvert niveau skal have et klart mål eller mål for spilleren at opnå. Uanset om det er at nå et bestemt sted, besejre fjender eller løse gåder, skal målet være veldefineret og kommunikeret til spilleren.

Gradvis sværhedsgrad

Designniveauer med en gradvis stigning i sværhedsgrad for at give spillere en jævn indlæringskurve. Start med enklere udfordringer og introducer gradvist ny mekanik eller forhindringer, efterhånden som spilleren skrider frem. Pludselige spidser i sværhedsgraden kan frustrere spillere, så det er vigtigt at opretholde en afbalanceret progression.

Visuel klarhed

Sørg for, at niveaudesignet og de visuelle elementer tydeligt kommunikerer vigtig information til spilleren. Inkorporerer musik og lydeffekter kan også formidle afgørende spor og give vigtige oplysninger til spilleren.

Playtesting og iteration

Regelmæssig playtest er afgørende for at forfine og forbedre niveaudesignet. Indsaml feedback fra spillere og observer deres oplevelser for at identificere områder, der kan kræve justeringer. Gentag dit niveaudesign baseret på denne feedback for at skabe mere behageligt og afbalanceret gameplay.

Balancere belønning og udfordring

Beløn spillere for at overvinde udfordringer på dine niveauer. Dette kan opnås gennem power-ups, samleobjekter, frigørelse af nye områder eller narrativ progression. At balancere sværhedsgraden af udfordringerne med meningsfulde belønninger hjælper med at motivere spillere og giver en følelse af præstation.

Gør spil mere engagerende med niveauer

Ved at implementere spilniveauer kan du forbedre den overordnede spilleroplevelse og skabe et mere engagerende spilmiljø. Niveauer giver progression, udfordring og variation, hvilket holder spillerne investerede og motiverede. De giver dig mulighed for at introducere ny mekanik, forhindringer, fjender og belønninger, hvilket sikrer, at hvert niveau føles særskilt og spændende.

About Technology - denizatm.com