Scores beheren in een game met de Arcade-bibliotheek van Python

Scores zijn een integraal onderdeel van veel spellen, omdat ze een maatstaf zijn voor de voortgang en prestatie van spelers.

In Python biedt de Arcade-bibliotheek een eenvoudige en efficiënte manier om scores in games te beheren. Door scores effectief te beheren, kunt u de betrokkenheid van gebruikers vergroten en een meer meeslepende game-ervaring bieden.

Maak een eenvoudig spel

Controleer voordat u begint of u dat hebt gedaan pip op uw apparaat geïnstalleerd. Gebruik deze opdracht om de arcadebibliotheek te installeren:

pip installeer arcade

Maak nu een eenvoudig spel met de Arcade-bibliotheek van Python.

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.

In dit spel kan de speler met de pijltjestoetsen naar links en rechts bewegen, terwijl een obstakel op dezelfde y-as wordt geplaatst.

importeren arcade
# Raamafmetingen instellen
SCREEN_WIDTH = 800
SCHERM_HOOGTE = 600
klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.player_x = breedte // 3
 zelf.score = 0
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 zelf.speler_x -= 10
elif sleutel == arcade.sleutel. RECHTS:
 zelf.speler_x += 10
defupdate(zelf, delta_tijd):
# Werk de spellogica hier bij
doorgang
defon_draw(zelf):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, 50, 20, arcade.kleur. BLAUW)
 arcade.draw_rectangle_filled(400, 50, 100, 50, arcade.kleur. ROOD)
defvoornaamst():
 spel = Mijnspel (SCREEN_WIDTH, SCREEN_HEIGHT)
 speelhal.run()
als __naam__ == "__voornaamst__":
 voornaamst()

Score bijhouden en berekenen

Om de score in je spel bij te houden, kun je een mechanisme maken om de score te verhogen wanneer aan een specifieke voorwaarde is voldaan. De score stijgt bijvoorbeeld wanneer de spelerbewegingen in uw spel en met succes het obstakel raakt. U kunt de update methode om logica voor scoreberekening op te nemen:

klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.player_x = breedte // 3
 zelf.score = 0
defon_key_press(zelf, sleutel, modifiers):
als sleutel == arcade.sleutel. LINKS:
 zelf.speler_x -= 10
elif sleutel == arcade.sleutel. RECHTS:
 zelf.speler_x += 10
defupdate(zelf, delta_tijd):
als self.player_x > 330En self.player_x < 470:
 zelfscore += 1

De score weergeven

Wijzig de om de score aan de speler weer te geven on_draw methode om een ​​tekstweergave op te nemen:

klasMijn spel(arcade. Raam):
# ...
defon_draw(zelf):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, 50, 20, arcade.kleur. BLAUW)
 arcade.draw_rectangle_filled(400, 300, 100, 50, arcade.kleur. ROOD)
 score_tekst = f"Score: {zelfscore}"
 arcade.draw_text (score_text, 10, 10, arcade.kleur. WIT, 14)

Door de bovenstaande code toe te voegen, kunt u de score in de linkerbenedenhoek van het spelvenster weergeven.

De hoogste score opslaan

Om spelers een gevoel van prestatie en competitie te geven, is het essentieel om de hoogste score op te slaan en weer te geven. U kunt hiervoor een eenvoudige bestandsgebaseerde aanpak gebruiken.

Gebruik de load_high_score methode om de hoogste score te lezen uit een bestand met de naam hoge_score.txt en stuur het terug. Daarna kunt u de nieuwe hoogste score in het bestand opslaan met behulp van de save_high_score methode.

klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.player_x = breedte // 3
 zelf.score = 0
 self.high_score = self.load_high_score()
defload_high_score(zelf):
poging:
met open("hoge_score.txt", "R") als bestand:
opbrengst int (bestand.lezen())
behalve FileNotFoundError:
opbrengst0
defsave_high_score(zelf):
met open("hoge_score.txt", "w") als bestand:
 bestand.schrijven (str (zelf.hoge_score))
defupdate(zelf, delta_tijd):
# ...
als zelf.score > zelf.hoge_score:
 zelf.hoge_score = zelf.score
 zelf.save_high_score()

Hoge score weergeven

Net als bij het weergeven van de huidige score, kunt u een tekstweergave toevoegen om de hoogste score weer te geven:

klasMijn spel(arcade. Raam):
# ...
defon_draw(zelf):
# ...
 high_score_text = f"Hoge score: {zelf.high_score}"
 arcade.draw_text (high_score_text, 10, 30, arcade.kleur. WIT, 14)

Door bovenstaande code op te nemen in de on_draw methode kunt u de hoogste score net boven de huidige score weergeven.

Inclusief extra functies

Het beheren van scores in games omvat vaak het opnemen van extra functies om de gameplay boeiender en dynamischer te maken. Laten we eens kijken naar enkele voorbeelden van hoe je naast scorebeheer extra functies in je spel kunt introduceren.

Power-ups

Power-ups zijn speciale items die spelers tijdelijke voordelen of bonuspunten geven. Creëer een activeer_power_up methode die de activering van de power-up triggert, het instellen van de power_up_actief vlag naar Waar.

U kunt de deactiveren_power_up methode om na een bepaalde duur (bijvoorbeeld 10 seconden) uit te voeren met behulp van de arcade.schema functie. Tijdens de actieve periode van de power-up kun je de pas_power_up_effecten toe methode om specifieke gameplay-verbeteringen te implementeren.

Hier is een voorbeeld van het implementeren van een power-upfunctie in je spel.

klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.player_x = breedte // 3
 zelf.score = 0
 zelf.power_up_active = Vals
defupdate(zelf, delta_tijd):
als zelf.power_up_active:
# Pas power-up-effecten toe tijdens het spelen
 self.apply_power_up_effect()
 zelfscore += 10
defpas_power_up_effecten toe(zelf):
# Voeg hier power-up specifieke logica toe
doorgang
defactiveer_power_up(zelf):
 zelf.power_up_active = WAAR
# Stel een timer of duur in voor het power-up-effect
 arcade.schedule (self.deactivate_power_up, 10.0)
defdeactiveren_power_up(zelf, delta_tijd):
 zelf.power_up_active = Vals

Combo-systeem

Een combo-systeem beloont spelers voor het behalen van opeenvolgende succesvolle acties of scorevermenigvuldigers. Creëer een toename_combo_teller methode die de combo-teller verhoogt en de score verhoogt op basis van het huidige combo-niveau.

U kunt bellen naar de reset_combo_counter methode en zet de combo-teller terug op nul wanneer er een mislukte actie plaatsvindt. Hier is een eenvoudige implementatie van een combo-systeem:

klasMijn spel(arcade. Raam):
def__in het__(zelf, breedte, hoogte):
 super().__init__(breedte, hoogte)
 self.player_x = breedte // 3
 zelf.score = 0
 zelf.combo_counter = 0
defupdate(zelf, delta_tijd):
# Controleer op succesvolle acties
als zelf.check_succesvolle_actie():
 zelf.increase_combo_counter()
anders:
 zelf.reset_combo_counter()
deftoename_combo_teller(zelf):
 self.combo_counter += 1
 self.score += self.combo_counter
defreset_combo_counter(zelf):
 zelf.combo_counter = 0

Door extra functies toe te voegen, zoals power-ups en combo-systemen, kun je diepte en opwinding toevoegen aan je spel, spelers extra prikkels geven om hun prestaties te verbeteren, hun acties te strategiseren en hoger te bereiken scoort.

Best practices voor scorebeheer

Als het gaat om het beheren van scores in games, kan het volgen van best practices helpen om een ​​leukere en boeiendere ervaring voor spelers te creëren. Hier zijn enkele belangrijke praktijken om te overwegen:

Zinvolle scoremechanismen

Ontwerp scoremechanismen die aansluiten bij de doelstellingen van het spel en die spelers zinvolle feedback geven. Het scoresysteem moet de voortgang, vaardigheid en prestaties van de speler in het spel weerspiegelen.

Overweeg verschillende puntwaarden toe te wijzen aan verschillende acties of gebeurtenissen op basis van hun moeilijkheidsgraad of belang voor de gameplay.

Visuele feedback

Geef visuele feedback aan spelers wanneer de score verandert. U kunt dit bereiken door middel van meldingen op het scherm, animaties of partikeleffecten. Visuele aanwijzingen creëren een gevoel van voldoening en versterken de acties van de speler, waardoor hun betrokkenheid bij het spel toeneemt.

Geluidseffecten en animaties

Opnemen geluidseffecten in je spel gerelateerd aan score-updates om de ervaring meeslepender te maken. Speel bijvoorbeeld een feestelijk geluidseffect of laat een uitbarsting van confetti zien wanneer de speler een belangrijke mijlpaal bereikt. Deze audiovisuele elementen voegen opwinding toe en versterken de positieve feedbackloop voor spelers.

Evenwicht tussen moeilijkheidsgraad en scoreschaling

Zorg voor een evenwichtige relatie tussen moeilijkheidsgraad en scoreschaling. Naarmate spelers verder komen in het spel of meer uitdagende obstakels tegenkomen, pas je het scoresysteem dienovereenkomstig aan. Door de score te schalen op basis van de moeilijkheidsgraad van het spel, blijft een eerlijke en lonende ervaring voor spelers behouden.

Door je aan deze best practices te houden, kun je de scores van je game effectief beheren, spelers zinvolle feedback geven en een lonende en boeiende ervaring creëren.

Verbeter de spelbetrokkenheid met het bijhouden van scores

Door het bijhouden van scores in uw game te implementeren, kunt u de betrokkenheid van spelers aanzienlijk vergroten. Scores geven een gevoel van voldoening, moedigen herspeelbaarheid aan en bevorderen de concurrentie tussen spelers.

Geef scores prominent weer en beloon hoge prestaties. Je motiveert spelers om te streven naar betere prestaties en het verbeteren van hun vaardigheden.