Pythons Arcade-bibliotek erbjuder ett enkelt och effektivt sätt att implementera spelnivåer i dina projekt.

Spelutveckling är en spännande och kreativ process som gör att du kan förverkliga dina fantasifulla idéer. När man designar ett spel är en av nyckelelementen som avsevärt kan förbättra spelarupplevelsen implementeringen av spelnivåer.

Nivåer ger struktur, progression och utmaningar, vilket ger spelarna en känsla av prestation och engagemang när de navigerar genom olika stadier av spelet.

Skapa ett enkelt spel

Innan du börjar, se till att du har pip installerad på din enhet. Använd det här kommandot för att installera arkad bibliotek:

pip installera arkad

Skapa ett grundläggande spel där spelaren kan röra sig åt vänster och höger.

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.

Använd funktionerna i Arcade-biblioteket för att hantera användarinmatning och uppdatera speltillståndet därefter. Skapa en ny fil med namnet simple-game.py och lägg till koden nedan:

instagram viewer 
importera arkad
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


klassMitt spel(arkad. Fönster):
def__i det__(själv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spel")
 arcade.set_background_color (arcade.color. VIT)
 self.player_x = SCREEN_WIDTH // 2


defon_draw(själv):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkad.färg. BLÅ)


defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
 self.player_x -= 10
elif nyckel == arkad.nyckel. HÖGER:
 self.player_x += 10


defon_key_release(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER eller nyckel == arkad.nyckel. HÖGER:
passera


defhuvud():
 spel = MyGame()
 arcade.run()
om __namn__ == "__huvud__":
 main()

Nedan är utgången:

Skapa flera nivåer

Utöka nu spelet genom att lägga till flera nivåer. Varje nivå kommer att ha sina egna unika egenskaper, vilket ger spelaren olika utmaningar. Du kan ändra den tidigare koden för att inkludera ytterligare nivåer. Här är ett exempel:

klassNivå ett:
def__i det__(själv):
 self.player_x = SCREEN_WIDTH // 2
defuppdatering(själv):
passera


defdra(själv):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkad.färg. BLÅ)


klassNivå två:
def__i det__(själv):
 self.player_x = SCREEN_WIDTH // 2


defuppdatering(själv):
passera


defdra(själv):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arkad.färg. RÖD)


klassMitt spel(arkad. Fönster):
def__i det__(själv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mitt spel")
 arcade.set_background_color (arcade.color. VIT)
 self.levels = [LevelOne(), LevelTwo()]
 self.current_level = 0


defon_draw(själv):
 arcade.start_render()
 self.levels[self.current_level].draw()


defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
 self.levels[self.current_level].player_x -= 10
elif nyckel == arkad.nyckel. HÖGER:
 self.levels[self.current_level].player_x += 10


defon_key_release(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER eller nyckel == arkad.nyckel. HÖGER:
passera


defuppdatering(själv, delta_tid):
 self.levels[self.current_level].update()


defhuvud():
 spel = MyGame()
 arcade.run()
om __namn__ == "__huvud__":
 main()

Övergång mellan nivåer

För att skapa en mjuk övergång mellan nivåer, upptäck när spelaren passerar en specifik gräns. Du kan spåra spelarens rörelse, och när spelaren passerar gränsen kan du byta till nästa nivå. Skapa en ny fil med namnet transition-between-levels.py och lägg till koden med följande uppdateringar:

klassMitt spel(arkad. Fönster):
# ...
defuppdatering(själv, delta_tid):
 self.levels[self.current_level].update()


# Kontrollera om spelaren passerade gränsen
om 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
# ...

Nedan är utgången:

Inklusive ytterligare funktioner

För att göra dina spelnivåer mer engagerande kan du inkludera ytterligare funktioner som power-ups och mål.

Mål

Mål ger specifika mål eller mål för spelaren att uppnå inom en nivå. De ger en känsla av syfte och framsteg. Här är ett exempel på implementering av en objektiv funktion:

klassMål:
def__i det__(själv, x, y):
 själv.x = x
 själv.y = y
 self.radius = 20
defdra(själv):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GRÖN)


klassNivå ett:
def__i det__(själv):
 self.objective = Objective(600, 400)
# ...


defuppdatering(själv):
# Kontrollera om spelaren når målet
om arcade.check_for_collision (self.player, self.objective):
 self.complete_objective()


defdra(själv):
 self.objective.draw()
# ...
defkomplett_objektiv(själv):
# Kod för att hantera objektivt slutförande
passera

Samlarföremål

Samlarföremål är föremål eller bonusar som spelaren kan samla på sig genom hela nivåerna. Här är ett exempel på implementering av en samlarfunktion:

klassSamlarobjekt:
def__i det__(själv, x, y):
 själv.x = x
 själv.y = y
 self.radius = 10
 self.is_collected = Falsk
defdra(själv):
ominte self.is_collected:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. ORANGE)


defsamla(själv):
 self.is_collected = Sann
# Kod för att hantera samlarobjektets effekt på spelaren


klassNivå ett:
def__i det__(själv):
 self.collectible = Samlarobjekt(300, 300)
# ...


defuppdatering(själv):
# Kontrollera om spelaren hämtar föremålet
om arcade.check_for_collision (self.player, self.collectible):
 self.collectible.collect()
defdra(själv):
 self.collectible.draw()
# ...

Hinder

Hinder kan vara statiska föremål eller rörliga enheter som hindrar spelarens väg. De kräver att spelaren lägger strategier och hittar sätt att övervinna dem. Här är ett exempel på hur hinderfunktionen implementeras:

klassHinder:
def__i det__(själv, x, y, bredd, höjd):
 själv.x = x
 själv.y = y
 self.width = bredd
 själv.höjd = höjd
defdra(själv):
 arcade.draw_rectangle_filled (self.x, self.y, self.width, self.height, arcade.color. GRÅ)
klassNivå ett:
def__i det__(själv):
 self.obstacles = [Obstacle(400, 200, 100, 50), Hinder(600, 500, 80, 120)]
# ...

Power-ups

Power-ups kan förbättra spelarens förmågor eller ge tillfälliga fördelar. Här är ett exempel på hur du implementerar en startfunktion:

klassPowerUp:
def__i det__(själv, x, y):
 själv.x = x
 själv.y = y
 self.radius = 10
 self.is_active = Sann
defdra(själv):
om self.is_active:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GUL)


defactivate_power_up(själv):
 self.is_active = Sann


defdeactivate_power_up(själv):
 self.is_active = Falsk


klassNivå ett:
def__i det__(själv):
 self.power_up = PowerUp(200, 200)
# ...


defuppdatering(själv):
# Kontrollera om spelaren kolliderar med strömmen
om arcade.check_for_collision (self.player, self.power_up):
 self.player.activate_power_up()
 self.power_up.deactivate_power_up()
defdra(själv):
 self.power_up.draw()
# ...

Bästa praxis för nivådesign

Nivådesign spelar en avgörande roll för att skapa engagerande och roliga spelupplevelser. Här är några bästa metoder att tänka på när du utformar nivåer för ditt spel:

Tydliga mål

Varje nivå bör ha ett tydligt mål eller mål för spelaren att uppnå. Oavsett om det är att nå en specifik plats, besegra fiender eller lösa pussel, bör målet vara väldefinierat och kommunicerat till spelaren.

Gradvis svårighetskurva

Designnivåer med en gradvis ökning av svårighetsgraden för att ge en smidig inlärningskurva för spelare. Börja med enklare utmaningar och introducera gradvis ny mekanik eller hinder allt eftersom spelaren går framåt. Plötsliga toppar i svårighetsgrad kan frustrera spelare, så det är viktigt att upprätthålla en balanserad utveckling.

Visuell klarhet

Se till att nivådesignen och de visuella elementen tydligt kommunicerar viktig information till spelaren. Inkluderar musik och ljudeffekter kan också förmedla viktiga ledtrådar och ge viktig information till spelaren.

Speltestning och iteration

Regelbundna speltestning är avgörande för att förfina och förbättra nivådesignen. Samla in feedback från spelare och observera deras erfarenheter för att identifiera områden som kan kräva justeringar. Iterera din nivådesign baserat på denna feedback för att skapa ett roligare och mer balanserat spel.

Balansera belöning och utmaning

Belöna spelare för att övervinna utmaningar på dina nivåer. Detta kan uppnås genom power-ups, samlarföremål, låsa upp nya områden eller narrativ progression. Att balansera svårigheten med utmaningarna med meningsfulla belöningar hjälper till att motivera spelare och ger en känsla av prestation.

Gör spel mer engagerande med nivåer

Genom att implementera spelnivåer kan du förbättra den övergripande spelarupplevelsen och skapa en mer engagerande spelmiljö. Nivåer ger progression, utmaning och variation, vilket håller spelarna investerade och motiverade. De låter dig introducera ny mekanik, hinder, fiender och belöningar, vilket säkerställer att varje nivå känns distinkt och spännande.