Majoritatea jocurilor de platformă folosesc un anumit tip de săritură, cu variații inclusiv sărituri duble și sărituri cu înălțime variabilă. Descoperiți tehnicile din spatele acestor mișcări.

Mecanica de sărituri joacă un rol crucial în îmbunătățirea experienței de joc a unui joc platformer. Prin implementarea diferitelor mecanisme de sărituri cu Biblioteca Arcade de la Python, puteți adăuga profunzime și emoție jocurilor dvs.

Biblioteca Arcade oferă un cadru intuitiv și ușor de utilizat pentru crearea de jocuri, făcându-l o alegere ideală pentru a vă crea platforma.

Creați un joc simplu

Înainte de a începe, instalați pip pe dispozitivul dvs și utilizați această comandă pentru a instala arcadă modul:

pip install arcade

Pentru a explora modul în care funcționează mecanica săriturii, începeți prin a crea un joc simplu în care jucătorul se poate mișca la stânga și la dreapta cu gravitația și o platformă statică.

Codul folosit în acest articol este disponibil în acest articol Depozitul GitHub și este gratuit pentru utilizare sub licența MIT.

instagram viewer

În joc, jucătorul se va ciocni cu platforma și va sta deasupra ei. Creați un fișier nou numit joc simplu.py si adauga codul de mai jos:

import arcadă
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 20
PLATFORM_WIDTH = 200
PLATFORM_HEIGHT = 20
GRAVITATEA = 0.5
albastru = arcade.culoare. ALBASTRU
verde = arcade.culoare. VERDE


clasăGame Window(arcadă. Fereastră):
def__init__(de sine):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, „Mecanica săriturii”)
 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(de sine):
 arcade.start_render()


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


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


defon_update(self, delta_time):
 self.player_dy -= GRAVITATE
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


dacă self.player_y < dist:
 self.player_y = dist
 self.player_dy = 0
joc = GameWindow()
arcade.run()

Când rulați programul, veți vedea obiectul player căzând rapid pe platformă, apoi rămâneți odihnit deasupra acestuia.

Adăugarea unei funcții de salt simplu

Acum, adăugați o funcție simplă de salt la joc. Verificați coliziunea dintre jucător și platformă și declanșează acțiunea de săritură atunci când jucătorul apasă tasta săgeată în sus. Pentru a realiza acest lucru, creați un fișier nou numit sari.py și codul cu actualizările de mai jos:

clasăGame Window(arcadă. Fereastră):
def__init__(de sine):
# ...
defon_key_press(sine, cheie, modificatori):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


dacă cheie == arcade.key. SUS și self.player_y == on_ground:
 self.player_dy = 10

defon_update(self, delta_time):
 self.player_dy -= GRAVITATE
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
dacă self.player_y < dist:
 self.player_y = dist
 self.player_dy = 0
 self.jump_count = 0

Adăugarea unei caracteristici de salt dublu

Pentru a adăuga o funcție de salt dublu, extindeți logica de salt existentă. Când jucătorul se află pe platformă și apasă tasta săgeată în sus pentru prima dată, va efectua un salt obișnuit. Cu toate acestea, dacă apăsă din nou tasta săgeată în sus în timp ce se află în aer, jucătorul va executa un salt dublu.

Creați un fișier nou numit dublu-salt.py și codul cu actualizările de mai jos:

clasăGame Window(arcadă. Fereastră):
def__init__(de sine):
 self.jump_count = 0# Urmăriți numărul de sărituri
defon_key_press(sine, cheie, modificatori):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
dacă cheie == arcade.key. SUS:
dacă self.player_y == on_ground sau self.jump_count < 2:
 self.player_dy = 10
 self.jump_count += 1

Inclusiv caracteristici suplimentare

În afară de săriturile simple și duble, există multe caracteristici pe care le puteți adăuga pentru a îmbunătăți mecanica de sărituri a jocului dvs.

Implementarea înălțimii de salt variabile

Permiterea jucătorului să controleze înălțimea săriturilor în funcție de cât timp ține apăsat butonul de salt poate adăuga mai mult control și strategie jocului. Iată un exemplu despre cum puteți implementa înălțimea de săritură variabilă. Creați un fișier nou numit variabil-salt.py și codul cu actualizările de mai jos:

GRAVITATEA = 0.5
JUMP_POWER_INCREMENT = 0.2
MAX_JUMP_POWER = 100
clasăGame Window(arcadă. Fereastră):
def__init__(de sine):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, „Mecanica săriturii”)
 self.jump_pressed = Fals
 self.jump_power = 0


defon_key_press(sine, cheie, modificatori):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


dacă cheie == arcade.key. SUS și self.player_y == on_ground:
 self.jump_pressed = Adevărat


defon_key_release(sine, cheie, modificatori):
dacă cheie == arcade.key. SUS:
 self.jump_pressed = Fals


defupdate_jump_power(de sine):
# Creșteți puterea de săritură în timp ce butonul de săritură este apăsat
dacă self.jump_pressed:
 self.jump_power += JUMP_POWER_INCREMENT


dacă self.jump_power > MAX_JUMP_POWER:
 self.jump_power = MAX_JUMP_POWER
altfel:
dacă self.jump_power > 0:
 self.jump_power -= 1


defon_update(self, delta_time):
 self.player_dy -= GRAVITATE
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


dacă self.player_y == dist și self.jump_power > 0:
 self.player_dy = self.jump_power
 self.player_y += self.player_dy
 self.update_jump_power()

Implementarea funcției Air Dash

Adăugarea unui mecanic de liniuță de aer poate oferi jucătorului opțiuni suplimentare de mobilitate în timp ce se află în aer. Creați un fișier nou numit air-dash.py și codul cu actualizările de mai jos:

AIR_DASH_DISTANCE = 100
MAX_AIR_DASHES = 2
clasăGame Window(arcadă. Fereastră):
def__init__(de sine):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, „Mecanica săriturii”)
 self.on_ground = Fals
 self.air_dashes = 0
 self.can_air_dash = Adevărat


defon_key_press(sine, cheie, modificatori):
dacă cheie == arcade.key. SUS și self.on_ground:
 self.player_dy = 10
elif cheie == arcade.key. SUS și \
 self.air_dashes < MAX_AIR_DASHES și \
 self.can_air_dash:
 self.player_dx = AIR_DASH_DISTANCE 
 sine.liniute_aerului += 1
 self.can_air_dash = Fals


defon_update(self, delta_time):
 self.player_dy -= GRAVITATE
 self.player_y += self.player_dy


 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


dacă self.player_y <= dist:
 self.player_y = dist
 self.player_dy = 0
 self.on_ground = Adevărat
altfel:
 self.on_ground = Fals


 self.player_x += self.player_dx


dacă 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
dacă self.on_ground:
 self.air_dashes = 0
 self.can_air_dash = Adevărat

Când executați cursa de aer, personajul dvs. de jucător se va îndepărta mult de platformă:

Cele mai bune practici pentru mecanicii de sărituri

Implementarea mecanicii de sărituri într-un joc necesită o atenție atentă pentru a asigura o experiență de joc fluidă și plăcută. Iată câteva dintre cele mai bune practici de reținut:

Echilibrați înălțimea și durata săriturii

Pentru a menține un sentiment de realism și dificultatea jocului, este important să echilibrați înălțimea și durata săriturii. Un salt prea mare sau prea scurt poate avea un impact negativ asupra jocului. Experimentați cu diferite înălțimi și durate de sărituri pentru a găsi echilibrul potrivit pentru jocul dvs.

Luați în considerare fizica jocului, abilitățile personajelor și designul general al nivelului atunci când determinați mecanica de săritură adecvată.

Oferiți feedback vizual și audio

Feedback-ul vizual și audio este esențial pentru ca săriturile să se simtă receptive și satisfăcătoare. Utilizați animații sau efecte de particule pentru a reprezenta mișcarea de săritură și aterizarea jucătorului.

În plus, luați în considerare adăugarea de efecte sonore sau muzică de fundal care îmbunătățește experiența de sărituri. Aceste indicii vizuale și audio contribuie la imersiunea și implicarea jucătorilor.

Ajustare fină a detectării coliziunilor

Detectarea precisă a coliziunilor între jucător și platforme este esențială pentru o mecanică de sărituri precisă și fiabilă. Asigurați-vă că algoritmul de detectare a coliziunilor este robust și gestionează în mod corespunzător diverse scenarii, cum ar fi aterizarea pe o platformă, ciocnirea cu obstacole sau alunecarea de-a lungul pereților.

Testați și repetați codul de detectare a coliziunilor pentru a elimina eventualele erori sau inconsecvențe care pot afecta mecanica de sărituri.

Faceți jocurile mai distractive cu mecanismele de sărituri

Adăugarea mecanicii de sărituri poate spori foarte mult angajamentul și plăcerea unui joc. Deschide noi posibilități pentru design de nivel, puzzle-uri și obstacole provocatoare. Prin implementarea diferitelor mecanisme de sărituri în Biblioteca de jocuri arcade din Python, puteți crea jocuri de platformă captivante care îi țin pe jucători distrați ore întregi.

Amintiți-vă, experimentarea cu diferite mecanisme de sărituri și încorporarea unor caracteristici unice vă pot diferenția jocul și îl pot face o experiență captivantă și memorabilă pentru jucători.