De flesta plattformsspel använder någon typ av hopp, med variationer inklusive dubbelhopp och hopp med variabel höjd. Upptäck teknikerna bakom dessa rörelser.

Hoppmekanik spelar en avgörande roll för att förbättra spelupplevelsen i ett plattformsspel. Genom att implementera olika hoppmekaniker med Pythons Arcade Library kan du lägga till djup och spänning till dina spel.

Arcade-biblioteket tillhandahåller ett intuitivt och lättanvänt ramverk för att skapa spel, vilket gör det till ett idealiskt val för att skapa ditt plattformsspel.

Skapa ett enkelt spel

Innan du startar, installera pip på din enhet och använd det här kommandot för att installera arkad modul:

pip installera arkad

För att utforska hur hoppmekanik fungerar, börja med att skapa ett enkelt spel där spelaren kan röra sig åt vänster och höger med gravitation och en statisk plattform.

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.

I spelet kommer spelaren att kollidera med plattformen och stå ovanpå den. Skapa en ny fil med namnet

instagram viewer
simple-game.py och lägg till koden nedan:

importera arkad
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 20
PLATFORM_WIDTH = 200
PLATFORM_HEIGHT = 20
GRAVITET = 0.5
blå = arkad.färg. BLÅ
grön = arkad.färg. GRÖN


klassGameWindow(arkad. Fönster):
def__i det__(själv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Hoppmekanik")
 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(själv):
 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(själv, delta_tid):
 self.player_dy -= GRAVITY
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


om self.player_y < dist:
 self.player_y = dist
 self.player_dy = 0
game = GameWindow()
arcade.run()

När du kör programmet kommer du att se spelarobjektet snabbt falla ner på plattformen och sedan ligga kvar ovanpå det.

Lägga till en enkel hoppfunktion

Lägg nu till en enkel hoppfunktion till spelet. Kontrollera kollisionen mellan spelaren och plattformen och utlösa hoppningen när spelaren trycker på uppåtpilen. För att uppnå detta, skapa en ny fil med namnet jump.py och koden med nedanstående uppdateringar:

klassGameWindow(arkad. Fönster):
def__i det__(själv):
# ...
defon_key_press(själv, nyckel, modifierare):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


om nyckel == arkad.nyckel. UPP och self.player_y == on_ground:
 self.player_dy = 10

defon_update(själv, delta_tid):
 self.player_dy -= GRAVITY
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
om self.player_y < dist:
 self.player_y = dist
 self.player_dy = 0
 self.jump_count = 0

Lägga till en dubbelhoppsfunktion

För att lägga till en dubbelhoppsfunktion, utöka den befintliga hopplogiken. När spelaren är på plattformen och trycker på uppåtpilen för första gången kommer de att göra ett vanligt hopp. Men om de trycker på uppåtpilen igen medan de är i luften kommer spelaren att utföra ett dubbelhopp.

Skapa en ny fil med namnet double-jump.py och koden med nedanstående uppdateringar:

klassGameWindow(arkad. Fönster):
def__i det__(själv):
 self.jump_count = 0# Spåra antalet hopp
defon_key_press(själv, nyckel, modifierare):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
om nyckel == arkad.nyckel. UPP:
om self.player_y == on_ground eller self.jump_count < 2:
 self.player_dy = 10
 self.jump_count += 1

Inklusive ytterligare funktioner

Förutom de enkla och dubbla hoppen, finns det många funktioner du kan lägga till för att förbättra hoppmekaniken i ditt spel.

Implementering av variabel hopphöjd

Att låta spelaren styra höjden på sina hopp baserat på hur länge de håller hoppknappen nedtryckt kan ge mer kontroll och strategi till spelet. Här är ett exempel på hur du kan implementera variabel hopphöjd. Skapa en ny fil med namnet variabel-jump.py och koden med nedanstående uppdateringar:

GRAVITET = 0.5
JUMP_POWER_INCREMENT = 0.2
MAX_JUMP_POWER = 100
klassGameWindow(arkad. Fönster):
def__i det__(själv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Hoppmekanik")
 self.jump_pressed = Falsk
 self.jump_power = 0


defon_key_press(själv, nyckel, modifierare):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


om nyckel == arkad.nyckel. UPP och self.player_y == on_ground:
 self.jump_pressed = Sann


defon_key_release(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. UPP:
 self.jump_pressed = Falsk


defupdate_jump_power(själv):
# Öka hoppkraften medan hoppknappen hålls nedtryckt
om self.jump_pressed:
 self.jump_power += JUMP_POWER_INCREMENT


om self.jump_power > MAX_JUMP_POWER:
 self.jump_power = MAX_JUMP_POWER
annan:
om self.jump_power > 0:
 self.jump_power -= 1


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


om self.player_y == dist och self.jump_power > 0:
 self.player_dy = self.jump_power
 self.player_y += self.player_dy
 self.update_jump_power()

Implementering av Air Dash-funktionen

Att lägga till en air dash-mekaniker kan ge spelaren ytterligare mobilitetsmöjligheter när han är i luften. Skapa en ny fil med namnet air-dash.py och koden med nedanstående uppdateringar:

AIR_DASH_DISTANCE = 100
MAX_AIR_DASHES = 2
klassGameWindow(arkad. Fönster):
def__i det__(själv):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Hoppmekanik")
 self.on_ground = Falsk
 self.air_dashes = 0
 self.can_air_dash = Sann


defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. UPP och self.on_ground:
 self.player_dy = 10
elif nyckel == arkad.nyckel. UPP och \
 self.air_dashes < MAX_AIR_DASHES och \
 self.can_air_dash:
 self.player_dx = AIR_DASH_DISTANCE 
 self.air_dashes += 1
 self.can_air_dash = Falsk


defon_update(själv, delta_tid):
 self.player_dy -= GRAVITY
 self.player_y += self.player_dy


 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


om self.player_y <= dist:
 self.player_y = dist
 self.player_dy = 0
 self.on_ground = Sann
annan:
 self.on_ground = Falsk


 self.player_x += self.player_dx


om 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
om self.on_ground:
 self.air_dashes = 0
 self.can_air_dash = Sann

När du utför luftstrecket kommer din spelarkaraktär att röra sig långt bort från plattformen:

Bästa praxis för hoppmekanik

Att implementera hoppmekanik i ett spel kräver noggrant övervägande för att säkerställa en smidig och njutbar spelupplevelse. Här är några bästa metoder att tänka på:

Balanshopp höjd och varaktighet

För att bibehålla en känsla av realism och spelsvårigheter är det viktigt att balansera hopphöjden och varaktigheten. Ett hopp som är för högt eller för kort kan påverka spelet negativt. Experimentera med olika hopphöjder och varaktigheter för att hitta rätt balans för ditt spel.

Tänk på spelets fysik, karaktärsförmågor och övergripande nivådesign när du bestämmer lämplig hoppmekanik.

Ge visuell och ljudåterkoppling

Visuell och ljudåterkoppling är avgörande för att få hopp att kännas lyhörda och tillfredsställande. Använd animationer eller partikeleffekter för att skildra spelarens hoppande rörelse och landning.

Tänk dessutom på lägga till ljudeffekter eller bakgrundsmusik som förbättrar hoppupplevelsen. Dessa visuella och ljudsignaler bidrar till spelarnas fördjupning och engagemang.

Finjustera kollisionsdetektion

Exakt kollisionsdetektering mellan spelaren och plattformarna är avgörande för exakt och pålitlig hoppmekanik. Se till att kollisionsdetekteringsalgoritmen är robust och korrekt hanterar olika scenarier, som att landa på en plattform, kollidera med hinder eller glida längs väggar.

Testa och upprepa din kollisionsdetekteringskod för att eliminera eventuella fel eller inkonsekvenser som kan påverka hoppmekaniken.

Gör spel roligare med hoppmekanik

Tillägget av hoppmekanik kan avsevärt förbättra engagemanget och njutningen av ett spel. Det öppnar upp nya möjligheter för nivådesign, pussel och utmanande hinder. Genom att implementera olika hoppmekaniker i Pythons arkadspelbibliotek kan du skapa fängslande plattformsspel som håller spelarna underhållna i timmar.

Kom ihåg att experiment med olika hoppmekaniker och inkorporering av unika funktioner kan särskilja ditt spel och göra det till en uppslukande och minnesvärd upplevelse för spelare.