Een timer maken met behulp van de Arcade-bibliotheek van Python voor op tijd gebaseerde evenementen

Bij het ontwikkelen van games kan het toevoegen van op tijd gebaseerde evenementen de gameplay-mechanica aanzienlijk verbeteren en games aantrekkelijker maken voor spelers. Door timers op te nemen, kun je uitdagingen introduceren, tijdgebonden doelen creëren of een gevoel van urgentie toevoegen aan bepaalde spelelementen.

Maak een eenvoudig spel

Begin met het maken van een eenvoudig spel om de basis te begrijpen. Bouw een spel waarbij de speler naar links en rechts kan bewegen, en er zal één platform zijn. Maak een nieuw bestand met de naam simpel-spel.py en importeer de arcademodule, die de nodige functionaliteiten biedt voor het maken van het spel.

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.

Definieer vervolgens de GameWindow klasse, wat een subklasse is van arcade. Raam. Definieer binnen de klasse GameWindow de

__in het__ methode, die het venster initialiseert met de opgegeven breedte, hoogte en titel.

De on_key_press methode detecteert het indrukken van de linker- of rechterpijltoets. Links drukken neemt af speler_x met 10 eenheden terwijl u naar rechts drukt om het met 10 eenheden te verhogen. Dit laat de speler bewegen horizontaal in het spelvenster.

Om het spel uit te voeren, definieert u de hoofdfunctie, maakt u een instantie van GameWindow, roept u de setup-methode op om het spelvenster in te stellen en start u ten slotte de spellus met speelhal.run().

Het ontwerpen van de Timer Class-structuur

Om timers in je game te implementeren, kun je een Timer-klasse maken met de benodigde attributen en methoden. Deze klasse biedt functies voor het starten van de timer, het stoppen ervan, het ophalen van de verstreken tijd en het controleren of de timer is verlopen. Dit is de basisstructuur voor de klasse Timer:

importeren tijd
klasTimer:
def__in het__(zelf, duur):
 self.duration = duur
 self.start_time = 0
 self.is_running = Vals
defbegin(zelf):
 self.start_time = tijd.tijd()
 self.is_running = WAAR
defstop(zelf):
 self.is_running = Vals
defkrijg_verstreken_tijd(zelf):
als self.is_running:
opbrengst tijd.tijd() - zelf.start_tijd
opbrengst0
defis verlopen(zelf):
opbrengst self.get_elapsed_time() >= self.duration

De klasse Timer neemt een duur parameter in seconden tijdens initialisatie. De klasse bevat attributen zoals starttijd om de tijd op te slaan waarop de timer startte, en is aan het rennen om de status van de timer te volgen.

De begin() methode stelt de start_time in op de huidige tijd met behulp van tijd.tijd() en zet is_running to WAAR. De stop() methode stelt eenvoudigweg is_running in op Vals. De get_elapsed_time() methode berekent de verstreken tijd door de start_time af te trekken van de huidige tijd.

Als de timer loopt, wordt de verstreken tijd geretourneerd; anders retourneert het 0. De is verlopen() methode controleert of de verstreken tijd groter is dan of gelijk is aan de duur, wat aangeeft dat de timer is verstreken.

Countdown-timers implementeren

Om het aftellen in uw spel te demonstreren, kunt u de timer starten wanneer de speler op een specifieke toets drukt, zoals de spatiebalk. Druk het aftellen af ​​naar de console met behulp van de printopdracht van Python. Maak een nieuw bestand met de naam timer.py en voeg de code toe met deze updates:

importeren tijd
klasGameWindow(arcade. Raam):
def__in het__(zelf):
 super().__init__(BREEDTE, HOOGTE, "Eenvoudig spel")
 self.player_x = BREEDTE // 2
 self.player_y = HOOGTE // 2
 zelfontspanner = Timer(10)
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. RUIMTE:
 zelfontspanner.start()
defon_draw(zelf):
# Bestaande code
als zelfontspanner.is_running:
 verstreken_tijd = self.timer.get_elapsed_time()
 r_time = zelfontspanner.duur - verstreken_tijd
 resterende_tijd = max (r_tijd, 0)
 afdrukken(f"Aftellen: {overgebleven tijd:.1F} seconden")

Zorg ervoor dat u het terminalvenster en het spelvenster tegelijkertijd kunt zien. Druk vervolgens op de spatiebalk en je ziet de timer aftellen:

Omgaan met timergebeurtenissen en activerende acties

U kunt ook een functie activeren die tekent een rechthoek wanneer de afteltimer afloopt. Maak een nieuw bestand met de naam handle-event.py en voeg de code toe met de onderstaande updates:

defon_draw(zelf):
# Bestaande code
als zelfontspanner.is_verlopen():
 zelf.tekenen_rechthoek()
defteken_rechthoek(zelf):
 arcade.draw_rectangle_filled (BREEDTE // 2, HOOGTE // 2, 100, 100, rood)

Hieronder is de uitvoer:

De timer pauzeren, resetten en hervatten

Om functionaliteit toe te voegen voor het pauzeren, resetten en hervatten van de timer, kunt u de Timer klasse met de juiste methoden. Hier is een voorbeeld:

klasTimer:
# Bestaande code
defpauze(zelf):
 self.duration -= self.get_elapsed_time()
 self.is_running = Vals
defresetten(zelf):
 self.start_time = 0
 self.is_running = Vals
defcv(zelf):
 self.start_time = tijd.tijd()
 self.is_running = WAAR

Visuele feedback toevoegen aan de timer

Om visuele feedback voor de timer te geven, kun je tekst of grafische elementen op het spelscherm opnemen. Maak een nieuw bestand met de naam visueel.py en voeg de code toe met de onderstaande updates:

defon_draw(zelf):
# Bestaande code
als zelfontspanner.is_running:
 tekst = f"Aftellen: {overgebleven tijd:.1F} seconden"
 arcade.draw_text (tekst, 10, 10, zwart, 18)

Je ziet de timer nu direct in het spelvenster in plaats van op de console:

Inclusief extra functies

Om op tijd gebaseerde evenementen verder te verbeteren, kunt u overwegen de volgende aanvullende functies in uw games te implementeren.

Op tijd gebaseerde power-ups of bonussen

Introduceer power-ups of bonussen die periodiek tijdens het spel verschijnen. Deze power-ups kunnen tijdelijke vaardigheden, extra punten, verhoogde snelheid of verbeterde wapens opleveren.

Door ze in de tijd te beperken, moeten spelers ze strategisch binnen een bepaald tijdsbestek verzamelen om voordeel te behalen. Dit voegt opwinding toe en beloont snel denken.

Tijdgebonden uitdagingen

Creëer tijdgebonden uitdagingen waarbij spelers een taak binnen een bepaald tijdsbestek moeten voltooien. Bijvoorbeeld een puzzel- of platformgedeelte dat binnen een bepaalde tijd moet worden opgelost.

Dit daagt spelers uit om snel te denken en te handelen, wat een opwindend gevoel van urgentie toevoegt aan de gameplay. Succesvolle voltooiing van deze uitdagingen kan beloningen ontgrendelen of het verhaal verder brengen.

Getimede obstakels of vijanden

Implementeer getimede obstakels of vijanden die een bedreiging vormen voor de speler. Bijvoorbeeld bewegende platforms die met regelmatige tussenpozen verschijnen en verdwijnen, of vijanden die voor een beperkte tijd onoverwinnelijk worden.

Spelers moeten hun acties en bewegingen correct timen om door deze obstakels te navigeren of vijanden te verslaan voordat de tijd om is. Dit voegt een laag strategie en coördinatie toe aan de gameplay.

Best practices voor op tijd gebaseerde evenementen

Bij het implementeren van op tijd gebaseerde gebeurtenissen in uw games, is het essentieel om deze best practices te volgen.

Testen en balanceren

Test uw op tijd gebaseerde evenementen grondig om er zeker van te zijn dat ze eerlijk en evenwichtig zijn. Verfijn de duur, moeilijkheidsgraad en beloningen om plezierige gameplay-ervaringen te creëren.

Gebruikersfeedback

Geef spelers duidelijke en intuïtieve feedback over de status van de timer en eventuele op tijd gebaseerde gebeurtenissen. Geluidseffecten toevoegen, visuele indicatoren of tekstuele aanwijzingen kunnen spelers helpen de tijdsbeperkingen en de gevolgen van hun acties te begrijpen.

Consistente tijdmeting

Gebruik tijdens het spel een consistent tijdmeetsysteem. Gebruik bijvoorbeeld seconden als eenheid voor alle timers en tijdgerelateerde berekeningen. Dit zorgt voor consistentie en begrijpelijkheid voor zowel de spelers als de ontwikkelaars.

Randgevallen behandelen

Overweeg scenario's waarin het spel kan worden gepauzeerd, geminimaliseerd of op de achtergrond wordt uitgevoerd. Behandel deze situaties gracieus om nauwkeurige timing te behouden en onbedoeld gedrag te voorkomen wanneer het spel wordt hervat.

Door deze best practices te volgen, kun je op tijd gebaseerde evenementen creëren die de gameplay verbeteren, spelers uitdagen en een evenwichtige en plezierige ervaring bieden.

Games leuker maken met op tijd gebaseerde evenementen

Door op tijd gebaseerde evenementen in uw games op te nemen, kunt u een dynamische en boeiende ervaring voor spelers creëren. Tijdgebonden uitdagingen voegen spanning en urgentie toe, terwijl getimede power-ups of obstakels strategische besluitvormingskansen kunnen creëren.

Experimenteer met verschillende op tijd gebaseerde mechanica om de juiste balans voor je spel te vinden, en vergeet niet om te spelen en te herhalen om plezier en plezier te maximaliseren.