Lär dig hur du mäter tid och använder den för att kontrollera olika aspekter av ditt spel.
I spelutveckling kan lägga till tidsbaserade händelser avsevärt förbättra spelmekaniken och göra spel mer engagerande för spelare. Genom att inkludera timers kan du introducera utmaningar, skapa tidsbegränsade mål eller lägga till en känsla av brådska till vissa spelelement.
Skapa ett enkelt spel
Börja med att skapa ett enkelt spel för att förstå grunderna. Bygg ett spel där spelaren kan röra sig åt vänster och höger, och det kommer att finnas en enda plattform. Skapa en ny fil med namnet simple-game.py och importera arkadmodulen, som tillhandahåller de nödvändiga funktionerna för att skapa spelet.
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.
Därefter definierar du GameWindow klass, som är en underklass till arkad. Fönster. Inuti GameWindow-klassen definierar du __i det__ metod, som initierar fönstret med angiven bredd, höjd och titel.
De on_key_press metoden upptäcker vänster- eller högerpiltangentstryckningar. Att trycka vänster minskar player_x med 10 enheter medan du trycker på höger ökar den med 10 enheter. Detta låter spelaren röra sig horisontellt i spelfönstret.
För att köra spelet, definiera huvudfunktionen, skapa en instans av GameWindow, anropa inställningsmetoden för att ställa in spelfönstret och slutligen starta spelslingan med arcade.run().
Designa timerns klassstruktur
För att implementera timers i ditt spel kan du skapa en Timer-klass med de nödvändiga attributen och metoderna. Denna klass kommer att tillhandahålla funktioner för att starta timern, stoppa den, hämta den förflutna tiden och kontrollera om timern har gått ut. Här är den grundläggande strukturen för Timer-klassen:
importera tidklassTimer:
def__i det__(själv, varaktighet):
self.duration = varaktighet
self.start_time = 0
self.is_running = FalskdefStart(själv):
self.start_time = time.time()
self.is_running = Sanndefsluta(själv):
self.is_running = Falskdefget_elapsed_time(själv):
om self.is_running:
lämna tillbaka time.time() - self.start_time
lämna tillbaka0
defis_expired(själv):
lämna tillbaka self.get_elapsed_time() >= self.duration
Timer-klassen tar en varaktighet parameter i sekunder under initiering. Klassen innehåller attribut som t.ex starttid för att lagra tiden när timern startade, och körs för att spåra timerns tillstånd.
De Start() metod ställer in start_time till den aktuella tiden med hjälp av time.time() och ställer är_kör till Sann. De sluta() metoden ställer helt enkelt is_running till Falsk. De get_elapsed_time() metoden beräknar den förflutna tiden genom att subtrahera start_time från den aktuella tiden.
Om timern är igång, returnerar den förfluten tid; annars returnerar den 0. De is_expired() metoden kontrollerar om den förflutna tiden är längre än eller lika med varaktigheten, vilket indikerar att timern har gått ut.
Implementering av nedräkningstimer
För att demonstrera en nedräkning i ditt spel kan du starta timern när spelaren trycker på en specifik tangent, till exempel mellanslagstangenten. Skriv ut nedräkningen till konsolen med Pythons utskriftskommando. Skapa en ny fil med namnet timer.py och lägg till koden med dessa uppdateringar:
importera tidklassGameWindow(arkad. Fönster):
def__i det__(själv):
super().__init__(WIDTH, HEIGHT, "Enkelt spel")
self.player_x = WIDTH // 2
self.player_y = HÖJD // 2
self.timer = Timer(10)defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. PLATS:
self.timer.start()
defon_draw(själv):
# Befintlig kod
om self.timer.is_running:
elapsed_time = self.timer.get_elapsed_time()
r_time = self.timer.duration - förfluten_tid
återstående_tid = max (r_tid, 0)
skriva ut(f"Nedräkning: {återstående tid:.1f} sekunder")
Se till att du kan se terminalfönstret och spelfönstret samtidigt. Tryck sedan på mellanslag och du kommer att se timern räknas ned:
Hantera timerhändelser och utlösande åtgärder
Du kan också trigga en funktion som ritar en rektangel när nedräkningstimern går ut. Skapa en ny fil med namnet handle-event.py och lägg till koden med följande uppdateringar:
defon_draw(själv):
# Befintlig kod
om self.timer.is_expired():
self.draw_rectangle()
defdraw_rektangel(själv):
arcade.draw_rectangle_filled (WIDTH // 2, HÖJD // 2, 100, 100, röd)
Nedan är utgången:
Pausa, återställa och återuppta timern
För att lägga till funktionalitet för att pausa, återställa och återuppta timern kan du utöka Timer klass med lämpliga metoder. Här är ett exempel:
klassTimer:
# Befintlig koddefpaus(själv):
self.duration -= self.get_elapsed_time()
self.is_running = Falskdefåterställa(själv):
self.start_time = 0
self.is_running = Falsk
defåteruppta(själv):
self.start_time = time.time()
self.is_running = Sann
Lägga till visuell feedback till timern
För att ge visuell feedback för timern kan du infoga text eller grafiska element på spelskärmen. Skapa en ny fil med namnet visual.py och lägg till koden med följande uppdateringar:
defon_draw(själv):
# Befintlig kod
om self.timer.is_running:
text = f"Nedräkning: {återstående tid:.1f} sekunder"
arcade.draw_text (text, 10, 10, svart, 18)Du kommer nu att se timern direkt i spelfönstret istället för konsolen:
Inklusive ytterligare funktioner
För att ytterligare förbättra tidsbaserade händelser kan du överväga att implementera följande ytterligare funktioner i dina spel.
Tidsbaserade power-ups eller bonusar
Introducera power-ups eller bonusar som dyker upp med jämna mellanrum under hela spelet. Dessa power-ups kan ge tillfälliga förmågor, extra poäng, ökad hastighet eller förbättrade vapen.
Genom att göra dem tidsbegränsade måste spelarna strategiskt samla dem inom en specifik tidsram för att få en fördel. Detta tillför spänning och belönar snabbt tänkande.
Tidsbegränsade utmaningar
Skapa tidsbegränsade utmaningar där spelare måste slutföra en uppgift inom en viss tidsram. Till exempel, ett pussel eller plattformsavsnitt som kräver att lösas inom en given tid.
Detta utmanar spelare att tänka och agera snabbt, vilket ger en spännande känsla av brådska till spelet. Ett framgångsrikt genomförande av dessa utmaningar kan låsa upp belöningar eller utveckla berättelsen.
Tidsinställda hinder eller fiender
Implementera tidsinställda hinder eller fiender som utgör ett hot mot spelaren. Till exempel rörliga plattformar som dyker upp och försvinner med jämna mellanrum, eller fiender som blir oövervinnerliga under en begränsad tid.
Spelare måste tajma sina handlingar och rörelser korrekt för att navigera i dessa hinder eller besegra fiender innan tiden rinner ut. Detta lägger till ett lager av strategi och koordination till spelet.
Bästa metoder för tidsbaserade evenemang
När du implementerar tidsbaserade händelser i dina spel är det viktigt att följa dessa bästa praxis.
Testa och balansera
Testa dina tidsbaserade evenemang noggrant för att säkerställa att de är rättvisa och balanserade. Finjustera varaktigheten, svårigheten och belöningarna för att skapa roliga spelupplevelser.
Användarfeedback
Ge tydlig och intuitiv feedback till spelare angående timerns status och eventuella tidsbaserade händelser. Lägger till ljudeffekter, visuella indikatorer eller textmässiga signaler kan hjälpa spelare att förstå tidsbegränsningarna och konsekvenserna av deras handlingar.
Konsekvent tidsmätning
Använd ett konsekvent tidsmätningssystem genom hela ditt spel. Använd till exempel sekunder som enhet för alla timers och tidsrelaterade beräkningar. Detta säkerställer konsekvens och enkel förståelse för både spelarna och utvecklarna.
Handtag kantfodral
Tänk på scenarier där spelet kan pausas, minimeras eller körs i bakgrunden. Hantera dessa situationer graciöst för att bibehålla korrekt timing och förhindra oavsiktligt beteende när spelet återupptas.
Genom att följa dessa bästa metoder kan du skapa tidsbaserade evenemang som förbättrar spelet, utmanar spelare och ger en balanserad och njutbar upplevelse.
Gör spel roligare med tidsbaserade evenemang
Genom att införliva tidsbaserade händelser i dina spel kan du skapa en dynamisk och engagerande upplevelse för spelare. Tidsbegränsade utmaningar ger spänning och brådska, medan tidsbegränsade power-ups eller hinder kan skapa strategiska beslutsmöjligheter.
Experimentera med olika tidsbaserade mekaniker för att hitta den rätta balansen för ditt spel, och kom ihåg att testa och iterera för att maximera nöje och njutning.