De Arcade-bibliotheek van Python biedt een eenvoudige en effectieve manier om spelniveaus in uw projecten te implementeren.

Game-ontwikkeling is een opwindend en creatief proces waarmee je je fantasierijke ideeën tot leven kunt brengen. Bij het ontwerpen van een spel is de implementatie van spelniveaus een van de belangrijkste elementen die de spelerservaring enorm kunnen verbeteren.

Niveaus bieden structuur, voortgang en uitdagingen, waardoor spelers een gevoel van prestatie en betrokkenheid krijgen terwijl ze door verschillende stadia van het spel navigeren.

Maak een eenvoudig spel

Controleer voordat u begint of u dat hebt gedaan pip op uw apparaat geïnstalleerd. Gebruik deze opdracht om het arcade bibliotheek:

pip installeer arcade

Maak een basisspel waarbij de speler naar links en rechts kan bewegen.

De code die in dit artikel wordt gebruikt, is hierin beschikbaar GitHub-opslagplaats en is gratis voor u om te gebruiken onder de MIT-licentie.

Gebruik de mogelijkheden van de Arcade-bibliotheek om gebruikersinvoer te verwerken en de spelstatus dienovereenkomstig bij te werken. Maak een nieuw bestand met de naam

instagram viewer
simpel-spel.py en voeg onderstaande code toe:

importeren arcade
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600


klasMijn spel(arcade. Raam):
def__in het__(zelf):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mijn spel")
 arcade.set_background_color (arcade.kleur. WIT)
 self.player_x = SCREEN_WIDTH // 2


defon_draw(zelf):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arcade.kleur. BLAUW)


defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 zelf.speler_x -= 10
elif sleutel == arcade.sleutel. RECHTS:
 zelf.speler_x += 10


defon_key_release(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS of sleutel == arcade.sleutel. RECHTS:
doorgang


defvoornaamst():
 spel = MijnSpel()
 speelhal.run()
als __naam__ == "__voornaamst__":
 voornaamst()

Hieronder is de uitvoer:

Maak meerdere niveaus

Breid het spel nu uit door meerdere niveaus toe te voegen. Elk niveau heeft zijn eigen unieke kenmerken en biedt verschillende uitdagingen voor de speler. U kunt de vorige code wijzigen om extra niveaus op te nemen. Hier is een voorbeeld:

klasNiveau een:
def__in het__(zelf):
 self.player_x = SCREEN_WIDTH // 2
defupdate(zelf):
doorgang


deftekenen(zelf):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arcade.kleur. BLAUW)


klasNiveau Twee:
def__in het__(zelf):
 self.player_x = SCREEN_WIDTH // 2


defupdate(zelf):
doorgang


deftekenen(zelf):
 arcade.draw_rectangle_filled (self.player_x, 50, 50, 50, arcade.kleur. ROOD)


klasMijn spel(arcade. Raam):
def__in het__(zelf):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mijn spel")
 arcade.set_background_color (arcade.kleur. WIT)
 self.levels = [LevelOne(), LevelTwo()]
 self.current_level = 0


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


defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 self.levels[self.current_level].player_x -= 10
elif sleutel == arcade.sleutel. RECHTS:
 self.levels[self.current_level].player_x += 10


defon_key_release(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS of sleutel == arcade.sleutel. RECHTS:
doorgang


defupdate(zelf, delta_tijd):
 self.levels[self.current_level].update()


defvoornaamst():
 spel = MijnSpel()
 speelhal.run()
als __naam__ == "__voornaamst__":
 voornaamst()

Overgang tussen niveaus

Detecteer wanneer de speler een bepaalde grens overschrijdt om een ​​soepele overgang tussen niveaus te creëren. Jij kan volg de beweging van de speler, en zodra de speler de grens overschrijdt, kun je overschakelen naar het volgende niveau. Maak een nieuw bestand met de naam overgang-tussen-niveaus.py en voeg de code toe met de onderstaande updates:

klasMijn spel(arcade. Raam):
# ...
defupdate(zelf, delta_tijd):
 self.levels[self.current_level].update()


# Controleer of de speler de grens heeft overschreden
als 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
# ...

Hieronder is de uitvoer:

Inclusief extra functies

Om je spelniveaus aantrekkelijker te maken, kun je extra functies toevoegen, zoals power-ups en doelstellingen.

Doelstellingen

Doelstellingen bieden specifieke doelen of doelen die de speler binnen een niveau moet bereiken. Ze voegen een gevoel van doel en vooruitgang toe. Hier is een voorbeeld van het implementeren van een objectieve functie:

klasObjectief:
def__in het__(zelf, x, y):
 zelf.x = x
 zelf.y = y
 zelf.radius = 20
deftekenen(zelf):
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GROENTE)


klasNiveau een:
def__in het__(zelf):
 zelf.doelstelling = Doelstelling(600, 400)
# ...


defupdate(zelf):
# Controleer of de speler het doel bereikt
als arcade.check_for_collision (self.player, self.objective):
 self.complete_objective()


deftekenen(zelf):
 zelf.objective.draw()
# ...
defcompleet_doel(zelf):
# Code om objectieve voltooiing af te handelen
doorgang

Verzamelobjecten

Collectibles zijn items of bonussen die de speler door de levels heen kan verzamelen. Hier is een voorbeeld van het implementeren van een verzamelfunctie:

klasVerzamelbaar:
def__in het__(zelf, x, y):
 zelf.x = x
 zelf.y = y
 zelf.radius = 10
 self.is_collected = Vals
deftekenen(zelf):
alsniet self.is_collected:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. ORANJE)


defverzamelen(zelf):
 self.is_collected = WAAR
# Code om het effect van het verzamelobject op de speler af te handelen


klasNiveau een:
def__in het__(zelf):
 self.collectible = Verzamelbaar(300, 300)
# ...


defupdate(zelf):
# Controleer of de speler het item verzamelt
als arcade.check_for_collision (self.player, self.collectible):
 self.collectible.collect()
deftekenen(zelf):
 self.collectible.draw()
# ...

Obstakels

Obstakels kunnen statische objecten zijn of bewegende entiteiten die het pad van de speler belemmeren. Ze vereisen dat de speler strategieën uitwerkt en manieren vindt om ze te overwinnen. Hier is een voorbeeld van het implementeren van de obstakelfunctie:

klasObstakel:
def__in het__(zelf, x, y, breedte, hoogte):
 zelf.x = x
 zelf.y = y
 zelfbreedte = breedte
 zelf.hoogte = hoogte
deftekenen(zelf):
 arcade.draw_rectangle_filled (self.x, self.y, self.width, self.height, arcade.color. GRIJS)
klasNiveau een:
def__in het__(zelf):
 zelf.obstakels = [Obstakel(400, 200, 100, 50), Obstakel(600, 500, 80, 120)]
# ...

Power-ups

Power-ups kunnen de vaardigheden van de speler verbeteren of tijdelijke voordelen bieden. Hier is een voorbeeld van het implementeren van een opstartfunctie:

klasOpstarten:
def__in het__(zelf, x, y):
 zelf.x = x
 zelf.y = y
 zelf.radius = 10
 zelf.is_actief = WAAR
deftekenen(zelf):
als zelf.is_actief:
 arcade.draw_circle_filled (self.x, self.y, self.radius, arcade.color. GEEL)


defactiveer_power_up(zelf):
 zelf.is_actief = WAAR


defdeactiveren_power_up(zelf):
 zelf.is_actief = Vals


klasNiveau een:
def__in het__(zelf):
 zelf.power_up = PowerUp(200, 200)
# ...


defupdate(zelf):
# Controleer of de speler in botsing komt met de power-up
als arcade.check_for_collision (self.player, self.power_up):
 self.player.activate_power_up()
 zelf.power_up.deactivate_power_up()
deftekenen(zelf):
 zelf.power_up.draw()
# ...

Best practices voor levelontwerp

Levelontwerp speelt een cruciale rol bij het creëren van boeiende en plezierige gameplay-ervaringen. Hier zijn enkele best practices waarmee u rekening moet houden bij het ontwerpen van levels voor uw game:

Doelen wissen

Elk niveau moet een duidelijk doel of doel hebben dat de speler moet bereiken. Of het nu gaat om het bereiken van een specifieke locatie, het verslaan van vijanden of het oplossen van puzzels, het doel moet goed gedefinieerd zijn en aan de speler worden meegedeeld.

Geleidelijke moeilijkheidsgraad

Ontwerp niveaus met een geleidelijke toename van de moeilijkheidsgraad om spelers een soepele leercurve te bieden. Begin met eenvoudigere uitdagingen en introduceer geleidelijk nieuwe mechanismen of obstakels naarmate de speler vordert. Plotselinge pieken in moeilijkheidsgraad kunnen spelers frustreren, dus het is belangrijk om een ​​evenwichtige voortgang te behouden.

Visuele helderheid

Zorg ervoor dat het levelontwerp en de visuele elementen belangrijke informatie duidelijk overbrengen aan de speler. Inclusief muziek en geluidseffecten kan ook cruciale aanwijzingen overbrengen en essentiële informatie aan de speler verstrekken.

Playtesten en Iteratie

Regelmatige playtests zijn essentieel voor het verfijnen en verbeteren van het levelontwerp. Verzamel feedback van spelers en observeer hun ervaringen om gebieden te identificeren die mogelijk moeten worden aangepast. Herhaal je levelontwerp op basis van deze feedback om een ​​leukere en evenwichtigere gameplay te creëren.

Breng beloning en uitdaging in evenwicht

Beloon spelers voor het overwinnen van uitdagingen in je levels. Dit kan worden bereikt door middel van power-ups, verzamelobjecten, het ontgrendelen van nieuwe gebieden of verhalende voortgang. Door de moeilijkheidsgraad van de uitdagingen in evenwicht te brengen met zinvolle beloningen, worden spelers gemotiveerd en krijgen ze een gevoel van voldoening.

Maak games boeiender met niveaus

Door spelniveaus te implementeren, kun je de algehele spelerservaring verbeteren en een boeiendere gameplay-omgeving creëren. Niveaus zorgen voor progressie, uitdaging en afwisseling, waardoor spelers geïnvesteerd en gemotiveerd blijven. Hiermee kun je nieuwe mechanica, obstakels, vijanden en beloningen introduceren, zodat elk niveau apart en opwindend aanvoelt.