De meeste platformspellen gebruiken een soort sprong, met variaties zoals dubbele sprong en sprong met variabele hoogte. Ontdek de technieken achter deze bewegingen.

Springmechanismen spelen een cruciale rol bij het verbeteren van de gameplay-ervaring van een platformspel. Door verschillende springmechanismen te implementeren met Python's Arcade Library, kun je diepte en opwinding toevoegen aan je games.

De Arcade-bibliotheek biedt een intuïtief en gebruiksvriendelijk raamwerk voor het maken van games, waardoor het een ideale keuze is om uw platformgame te maken.

Maak een eenvoudig spel

Voor het starten, installeer pip op uw apparaat en gebruik deze opdracht om het arcade moduul:

pip installeer arcade

Om te ontdekken hoe springmechanismen werken, begin je met het maken van een eenvoudig spel waarin de speler naar links en rechts kan bewegen met zwaartekracht en een statisch platform.

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.

instagram viewer

In het spel botst de speler tegen het platform en gaat er bovenop staan. Maak een nieuw bestand met de naam simpel-spel.py en voeg onderstaande code toe:

importeren arcade
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
SPELER_RADIUS = 20
PLATFORM_WIDTH = 200
PLATFORM_HEIGHT = 20
ZWAARTEKRACHT = 0.5
blauw = arcade.kleur. BLAUW
groen = arcade.kleur. GROENTE


klasGameWindow(arcade. Raam):
def__in het__(zelf):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Springende mechanica")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 zelf.speler_dy = 0
 self.platform_x = SCREEN_WIDTH // 2
 self.platform_y = SCREEN_HEIGHT // 4


defon_draw(zelf):
 arcade.start_render()


 arcade.draw_circle_filled (self.player_x, self.player_y, 
 PLAYER_RADIUS, blauw)


 arcade.draw_rectangle_filled (self.platform_x, self.platform_y, 
 PLATFORM_WIDTH, PLATFORM_HEIGHT, groen)


defop_update(zelf, delta_tijd):
 self.player_dy -= ZWAARTEKRACHT
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


als self.player_y < dist:
 self.player_y = dist
 zelf.speler_dy = 0
spel = GameWindow()
speelhal.run()

Wanneer je het programma uitvoert, zie je het spelerobject snel op het platform vallen en er vervolgens bovenop blijven rusten.

Een eenvoudige springfunctie toevoegen

Voeg nu een eenvoudige springfunctie toe aan het spel. Controleer de botsing tussen de speler en het platform en activeer de springactie wanneer de speler op de pijl-omhoog drukt. Maak hiervoor een nieuw bestand met de naam spring.py en de code met de onderstaande updates:

klasGameWindow(arcade. Raam):
def__in het__(zelf):
# ...
defon_key_press(zelf, sleutel, modifiers):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


als sleutel == arcade.sleutel. OMHOOG En self.player_y == op_grond:
 zelf.speler_dy = 10

defop_update(zelf, delta_tijd):
 self.player_dy -= ZWAARTEKRACHT
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
als self.player_y < dist:
 self.player_y = dist
 zelf.speler_dy = 0
 self.jump_count = 0

Een functie voor dubbele sprong toevoegen

Om een ​​dubbele sprongfunctie toe te voegen, breidt u de bestaande spronglogica uit. Wanneer de speler op het platform staat en voor de eerste keer op de pijl-omhoog-toets drukt, zal hij een normale sprong uitvoeren. Als ze echter opnieuw op de pijltjestoets omhoog drukken terwijl ze in de lucht zijn, voert de speler een dubbele sprong uit.

Maak een nieuw bestand met de naam dubbele sprong.py en de code met de onderstaande updates:

klasGameWindow(arcade. Raam):
def__in het__(zelf):
 self.jump_count = 0# Volg het aantal sprongen
defon_key_press(zelf, sleutel, modifiers):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
als sleutel == arcade.sleutel. OMHOOG:
als self.player_y == op_grond of self.jump_count < 2:
 zelf.speler_dy = 10
 self.jump_count += 1

Inclusief extra functies

Afgezien van de eenvoudige en dubbele sprongen, zijn er veel functies die je kunt toevoegen om de springmechanismen van je spel te verbeteren.

Variabele spronghoogte implementeren

Door de speler de hoogte van zijn sprongen te laten bepalen op basis van hoe lang hij de springknop ingedrukt houdt, kan er meer controle en strategie aan de gameplay worden toegevoegd. Hier is een voorbeeld van hoe u variabele spronghoogte kunt implementeren. Maak een nieuw bestand met de naam variabele-sprong.py en de code met de onderstaande updates:

ZWAARTEKRACHT = 0.5
JUMP_POWER_INCREMENT = 0.2
MAX_JUMP_POWER = 100
klasGameWindow(arcade. Raam):
def__in het__(zelf):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Springende mechanica")
 self.jump_pressed = Vals
 self.jump_power = 0


defon_key_press(zelf, sleutel, modifiers):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


als sleutel == arcade.sleutel. OMHOOG En self.player_y == op_grond:
 self.jump_pressed = WAAR


defon_key_release(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. OMHOOG:
 self.jump_pressed = Vals


defupdate_jump_power(zelf):
# Verhoog de springkracht terwijl de springknop wordt ingedrukt
als self.jump_pressed:
 self.jump_power += JUMP_POWER_INCREMENT


als self.jump_power > MAX_JUMP_POWER:
 self.jump_power = MAX_JUMP_POWER
anders:
als self.jump_power > 0:
 zelf.jump_power -= 1


defop_update(zelf, delta_tijd):
 self.player_dy -= ZWAARTEKRACHT
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


als self.player_y == afstand En self.jump_power > 0:
 self.player_dy = self.jump_power
 self.player_y += self.player_dy
 zelf.update_jump_power()

Air Dash-functie implementeren

Door een luchtdash-monteur toe te voegen, kan de speler extra mobiliteitsopties krijgen terwijl hij in de lucht is. Maak een nieuw bestand met de naam air-dash.py en de code met de onderstaande updates:

AIR_DASH_DISTANCE = 100
MAX_AIR_DASHES = 2
klasGameWindow(arcade. Raam):
def__in het__(zelf):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Springende mechanica")
 zelf.op_grond = Vals
 zelf.lucht_streepjes = 0
 self.can_air_dash = WAAR


defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. OMHOOG En zelf.op_grond:
 zelf.speler_dy = 10
elif sleutel == arcade.sleutel. OMHOOG En \
 self.air_dashes < MAX_AIR_DASHES En \
 zelf.can_air_dash:
 self.player_dx = AIR_DASH_DISTANCE 
 self.air_dashes += 1
 self.can_air_dash = Vals


defop_update(zelf, delta_tijd):
 self.player_dy -= ZWAARTEKRACHT
 self.player_y += self.player_dy


 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


als self.player_y <= dist:
 self.player_y = dist
 zelf.speler_dy = 0
 zelf.op_grond = WAAR
anders:
 zelf.op_grond = Vals


 self.player_x += self.player_dx


als self.player_x < PLAYER_RADIUS:
 self.player_x = PLAYER_RADIUS
 zelf.speler_dx = 0
elif self.player_x > SCREEN_WIDTH - PLAYER_RADIUS:
 self.player_x = SCREEN_WIDTH - PLAYER_RADIUS
 zelf.speler_dx = 0
als zelf.op_grond:
 zelf.lucht_streepjes = 0
 self.can_air_dash = WAAR

Wanneer je de luchtdash uitvoert, beweegt je spelerspersonage ver weg van het platform:

Beste praktijken voor springmechanica

Het implementeren van springmechanismen in een game vereist een zorgvuldige afweging om een ​​soepele en plezierige gameplay-ervaring te garanderen. Hier zijn enkele praktische tips om in gedachten te houden:

Balanceer spronghoogte en -duur

Om een ​​gevoel van realisme en moeilijkheidsgraad van het spel te behouden, is het belangrijk om de spronghoogte en -duur in evenwicht te houden. Een sprong die te hoog of te kort is, kan een negatieve invloed hebben op de gameplay. Experimenteer met verschillende spronghoogtes en duur om de juiste balans voor je spel te vinden.

Houd rekening met de fysica van het spel, de karaktereigenschappen en het algehele niveauontwerp bij het bepalen van de juiste sprongmechanismen.

Geef visuele en audiofeedback

Visuele en audiofeedback is cruciaal om sprongen responsief en bevredigend te laten aanvoelen. Gebruik animaties of partikeleffecten om de springbeweging en landing van de speler weer te geven.

Overweeg bovendien geluidseffecten of achtergrondmuziek toevoegen dat komt de springervaring ten goede. Deze visuele en audiosignalen dragen bij aan de onderdompeling en betrokkenheid van spelers.

Verfijn de botsingsdetectie

Nauwkeurige botsingsdetectie tussen de speler en platforms is essentieel voor nauwkeurige en betrouwbare springmechanismen. Zorg ervoor dat het algoritme voor botsingsdetectie robuust is en goed omgaat met verschillende scenario's, zoals landen op een platform, botsen met obstakels of langs muren glijden.

Test en herhaal uw botsingsdetectiecode om eventuele glitches of inconsistenties te elimineren die van invloed kunnen zijn op het springmechanisme.

Maak games leuker met springmechanismen

De toevoeging van springmechanismen kan de betrokkenheid en het plezier van een game enorm vergroten. Het opent nieuwe mogelijkheden voor levelontwerp, puzzels en uitdagende obstakels. Door verschillende sprongmechanismen in Python's Arcade Game Library te implementeren, kun je boeiende platformgames maken die spelers urenlang bezig houden.

Onthoud dat het experimenteren met verschillende sprongmechanismen en het opnemen van unieke functies je spel kan onderscheiden en het een meeslepende en gedenkwaardige ervaring voor spelers kan maken.