De fleste platformspil bruger en eller anden form for spring, med variationer, herunder dobbeltspring og spring med variabel højde. Opdag teknikkerne bag disse bevægelser.

Springmekanik spiller en afgørende rolle i at forbedre gameplay-oplevelsen af ​​et platformspil. Ved at implementere forskellige springmekanikker med Pythons Arcade Library kan du tilføje dybde og spænding til dine spil.

Arcade-biblioteket giver en intuitiv og nem at bruge ramme til at skabe spil, hvilket gør det til et ideelt valg til at skabe din platformer.

Opret et simpelt spil

Inden start, installer pip på din enhed og brug denne kommando til at installere arkade modul:

pip installere arkade

For at udforske, hvordan springmekanik fungerer, skal du starte med at skabe et simpelt spil, hvor spilleren kan bevæge sig til venstre og højre med tyngdekraften og en statisk platform.

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

I spillet vil spilleren kollidere med platformen og stå oven på den. Opret en ny fil med navnet

instagram viewer
simple-game.py og tilføj nedenstående kode:

importere arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 20
PLATFORM_WIDTH = 200
PLATFORM_HEIGHT = 20
GRAVITY = 0.5
blå = arkade.farve. BLÅ
grøn = arkade.farve. GRØN


klasseGameWindow(arkade. Vindue):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Hoppemekanik")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.player_dy = 0
 self.platform_x = SCREEN_WIDTH // 2
 self.platform_y = SCREEN_HEIGHT // 4


defon_draw(selv):
 arcade.start_render()


 arcade.draw_circle_filled (self.player_x, self.player_y, 
 PLAYER_RADIUS, blå)


 arcade.draw_rectangle_filled (self.platform_x, self.platform_y, 
 PLATFORM_WIDTH, PLATFORM_HEIGHT, grøn)


defon_update(selv, delta_tid):
 self.player_dy -= GRAVITY
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


hvis self.player_y < dist:
 self.player_y = dist
 self.player_dy = 0
spil = GameWindow()
arcade.run()

Når du kører programmet, vil du se afspillerobjektet hurtigt falde ned på platformen og derefter blive hvilende oven på det.

Tilføjelse af en simpel hoppefunktion

Tilføj nu en simpel springfunktion til spillet. Tjek kollisionen mellem afspilleren og platformen og udløs hoppehandlingen, når spilleren trykker på pil op-tasten. For at opnå dette skal du oprette en ny fil med navnet jump.py og koden med nedenstående opdateringer:

klasseGameWindow(arkade. Vindue):
def__i det__(selv):
# ...
defon_key_press(selv, nøgle, modifikatorer):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


hvis nøgle == arkade.nøgle. OP og self.player_y == on_ground:
 self.player_dy = 10

defon_update(selv, delta_tid):
 self.player_dy -= GRAVITY
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
hvis self.player_y < dist:
 self.player_y = dist
 self.player_dy = 0
 self.jump_count = 0

Tilføjelse af en dobbeltspringsfunktion

For at tilføje en dobbeltspringsfunktion skal du udvide den eksisterende springlogik. Når spilleren er på platformen og trykker på pil op-tasten for første gang, udfører de et almindeligt hop. Men hvis de trykker på pil op igen, mens de er i luften, vil spilleren udføre et dobbeltspring.

Opret en ny fil med navnet dobbelt-jump.py og koden med nedenstående opdateringer:

klasseGameWindow(arkade. Vindue):
def__i det__(selv):
 self.jump_count = 0# Spor antallet af hop
defon_key_press(selv, nøgle, modifikatorer):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
hvis nøgle == arkade.nøgle. OP:
hvis self.player_y == on_ground eller self.jump_count < 2:
 self.player_dy = 10
 self.jump_count += 1

Inklusiv yderligere funktioner

Udover de enkle og dobbelte spring, er der mange funktioner, du kan tilføje for at forbedre springmekanikken i dit spil.

Implementering af variabel springhøjde

At tillade spilleren at kontrollere højden af ​​deres hop baseret på, hvor længe de holder springknappen nede, kan tilføje mere kontrol og strategi til gameplayet. Her er et eksempel på, hvordan du kan implementere variabel springhøjde. Opret en ny fil med navnet variabel-jump.py og koden med nedenstående opdateringer:

GRAVITY = 0.5
JUMP_POWER_INCREMENT = 0.2
MAX_JUMP_POWER = 100
klasseGameWindow(arkade. Vindue):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Hoppemekanik")
 self.jump_pressed = Falsk
 self.jump_power = 0


defon_key_press(selv, nøgle, modifikatorer):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


hvis nøgle == arkade.nøgle. OP og self.player_y == on_ground:
 self.jump_pressed = Rigtigt


defon_key_release(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. OP:
 self.jump_pressed = Falsk


defupdate_jump_power(selv):
# Øg springstyrken, mens springknappen holdes nede
hvis self.jump_pressed:
 self.jump_power += JUMP_POWER_INCREMENT


hvis self.jump_power > MAX_JUMP_POWER:
 self.jump_power = MAX_JUMP_POWER
andet:
hvis self.jump_power > 0:
 self.jump_power -= 1


defon_update(selv, delta_tid):
 self.player_dy -= GRAVITY
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


hvis self.player_y == dist og self.jump_power > 0:
 self.player_dy = self.jump_power
 self.player_y += self.player_dy
 self.update_jump_power()

Implementering af Air Dash-funktion

Tilføjelse af en air dash-mekaniker kan give spilleren yderligere mobilitetsmuligheder, mens han er i luften. Opret en ny fil med navnet air-dash.py og koden med nedenstående opdateringer:

AIR_DASH_DISTANCE = 100
MAX_AIR_DASHES = 2
klasseGameWindow(arkade. Vindue):
def__i det__(selv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Hoppemekanik")
 self.on_ground = Falsk
 self.air_dashes = 0
 self.can_air_dash = Rigtigt


defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. OP og self.on_ground:
 self.player_dy = 10
elif nøgle == arkade.nøgle. OP og \
 self.air_dashes < MAX_AIR_DASHES og \
 self.can_air_dash:
 self.player_dx = AIR_DASH_DISTANCE 
 self.air_dashes += 1
 self.can_air_dash = Falsk


defon_update(selv, delta_tid):
 self.player_dy -= GRAVITY
 self.player_y += self.player_dy


 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


hvis self.player_y <= dist:
 self.player_y = dist
 self.player_dy = 0
 self.on_ground = Rigtigt
andet:
 self.on_ground = Falsk


 self.player_x += self.player_dx


hvis self.player_x < PLAYER_RADIUS:
 self.player_x = PLAYER_RADIUS
 self.player_dx = 0
elif self.player_x > SCREEN_WIDTH - PLAYER_RADIUS:
 self.player_x = SCREEN_WIDTH - PLAYER_RADIUS
 self.player_dx = 0
hvis self.on_ground:
 self.air_dashes = 0
 self.can_air_dash = Rigtigt

Når du udfører luftdysten, vil din spillerkarakter bevæge sig langt væk fra platformen:

Bedste praksis for springmekanik

Implementering af springmekanik i et spil kræver nøje overvejelse for at sikre en jævn og fornøjelig spiloplevelse. Her er nogle bedste fremgangsmåder at huske på:

Balance Jump Højde og Varighed

For at bevare en følelse af realisme og spilvanskeligheder er det vigtigt at balancere springhøjden og varigheden. Et hop, der er for højt eller for kort, kan påvirke gameplayet negativt. Eksperimenter med forskellige springhøjder og varigheder for at finde den rigtige balance til dit spil.

Overvej spillets fysik, karakterevner og overordnede niveaudesign, når du bestemmer den passende springmekanik.

Giv visuel og lydfeedback

Visuel og lydfeedback er afgørende for at få hop til at føles responsive og tilfredsstillende. Brug animationer eller partikeleffekter til at skildre spillerens hoppebevægelse og landing.

Overvej desuden tilføje lydeffekter eller baggrundsmusik der forbedrer springoplevelsen. Disse visuelle og lydsignaler bidrager til spillernes fordybelse og engagement.

Finjuster kollisionsdetektion

Nøjagtig kollisionsdetektion mellem afspilleren og platformene er afgørende for præcis og pålidelig springmekanik. Sørg for, at kollisionsdetektionsalgoritmen er robust og korrekt håndterer forskellige scenarier, såsom at lande på en platform, kollidere med forhindringer eller glide langs vægge.

Test og gentag din kollisionsdetekteringskode for at eliminere eventuelle fejl eller uoverensstemmelser, der kan påvirke springmekanikken.

Gør spil sjovere med Jumping Mechanics

Tilføjelsen af ​​springmekanik kan i høj grad øge engagementet og nydelsen af ​​et spil. Det åbner op for nye muligheder for niveaudesign, puslespil og udfordrende forhindringer. Ved at implementere forskellige springmekanikker i Pythons Arcade Game Library kan du skabe fængslende platformspil, der holder spillerne underholdt i timevis.

Husk, at eksperimentere med forskellige springmekanikker og inkorporering af unikke funktioner kan adskille dit spil og gøre det til en fordybende og mindeværdig oplevelse for spillere.