Vad är poängen med ett spel utan poäng? Vissa kan klara sig utan, men de flesta spel du kommer att skapa måste berätta för spelaren hur bra de klarar sig.
Poäng är en integrerad del av många spel eftersom de ger ett mått på framsteg och prestationer för spelare.
I Python erbjuder Arcade-biblioteket ett enkelt och effektivt sätt att hantera poäng i spel. Genom att effektivt hantera poäng kan du förbättra användarnas engagemang och ge en mer uppslukande spelupplevelse.
Skapa ett enkelt spel
Innan du börjar, se till att du har pip installerad på din enhet. Använd detta kommando för att installera arkadbiblioteket:
pip installera arkadSkapa nu ett enkelt spel med Pythons Arcade-bibliotek.
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 det här spelet kan spelaren flytta åt vänster och höger med hjälp av piltangenterna, medan ett hinder placeras på samma y-axel.
importera arkad# Ställ in fönstermått
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
super().__init__(bredd, höjd)
self.player_x = bredd // 3
self.score = 0defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
self.player_x -= 10
elif nyckel == arkad.nyckel. HÖGER:
self.player_x += 10defuppdatering(själv, delta_tid):
# Uppdatera spellogik här
passeradefon_draw(själv):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, 50, 20, arkad.färg. BLÅ)
arcade.draw_rectangle_filled(400, 50, 100, 50, arkad.färg. RÖD)defhuvud():
spel = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
om __namn__ == "__huvud__":
main()
Poängspårning och beräkning
För att spåra poängen i ditt spel kan du skapa en mekanism för att öka poängen när ett specifikt villkor är uppfyllt. Till exempel ökar poängen närhelst spelarens rörelser i ditt spel och lyckas vidröra hindret. Du kan ändra uppdatering metod för att inkludera logik för poängberäkning:
klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
super().__init__(bredd, höjd)
self.player_x = bredd // 3
self.score = 0defon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
self.player_x -= 10
elif nyckel == arkad.nyckel. HÖGER:
self.player_x += 10
defuppdatering(själv, delta_tid):
om self.player_x > 330och self.player_x < 470:
self.score += 1
Visar poängen
För att visa poängen för spelaren, ändra on_draw metod för att inkludera en textåtergivning:
klassMitt spel(arkad. Fönster):
# ...defon_draw(själv):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, 50, 20, arkad.färg. BLÅ)
arcade.draw_rectangle_filled(400, 300, 100, 50, arkad.färg. RÖD)
poäng_text = f"Betyg: {self.score}"
arcade.draw_text (score_text, 10, 10, arkad.färg. VIT, 14)
Genom att lägga till ovanstående kod kan du visa poängen i det nedre vänstra hörnet av spelfönstret.
Lagra högsta poängen
För att ge en känsla av prestation och konkurrens för spelare är det viktigt att lagra och visa de höga poängen. Du kan använda en enkel filbaserad metod för detta.
Använd load_high_score metod för att läsa den högsta poängen från en fil som heter high_score.txt och lämna tillbaka den. Efter det kan du spara den nya högsta poängen i filen med hjälp av save_high_score metod.
klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
super().__init__(bredd, höjd)
self.player_x = bredd // 3
self.score = 0
self.high_score = self.load_high_score()defload_high_score(själv):
Prova:
med öppen("high_score.txt", "r") som fil:
lämna tillbaka int (file.read())
bortsett från FileNotFoundError:
lämna tillbaka0defsave_high_score(själv):
med öppen("high_score.txt", "w") som fil:
file.write (str (self.high_score))defuppdatering(själv, delta_tid):
# ...
om self.score > self.high_score:
self.high_score = self.score
self.save_high_score()
Visar höga poäng
På samma sätt som att visa den aktuella poängen kan du lägga till en textåtergivning för att visa den höga poängen:
klassMitt spel(arkad. Fönster):
# ...defon_draw(själv):
# ...
high_score_text = f"Hög poäng: {self.high_score}"
arcade.draw_text (high_score_text, 10, 30, arkad.färg. VIT, 14)
Genom att inkludera ovanstående kod i on_draw metoden kan du visa den höga poängen strax ovanför den aktuella poängen.
Inklusive ytterligare funktioner
Att hantera poäng i spel innebär ofta att man införlivar ytterligare funktioner för att göra spelet mer engagerande och dynamiskt. Låt oss utforska några exempel på hur du kan introducera ytterligare funktioner vid sidan av poänghantering i ditt spel.
Power-ups
Power-ups är speciella föremål som ger spelare tillfälliga fördelar eller bonuspoäng. Skapa en activate_power_up metod som utlöser aktiveringen av power-up, inställning av power_up_active flagga till True.
Du kan schemalägga deactivate_power_up metod för att köra efter en viss varaktighet (t.ex. 10 sekunder) med hjälp av arcade.schedule fungera. Under uppstartens aktiva period kan du använda applicera_power_up_effekter metod för att implementera specifika spelförbättringar.
Här är ett exempel på hur du implementerar en power-up-funktion i ditt spel.
klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
super().__init__(bredd, höjd)
self.player_x = bredd // 3
self.score = 0
self.power_up_active = Falskdefuppdatering(själv, delta_tid):
om self.power_up_active:
# Tillämpa power-up-effekter under spelet
self.apply_power_up_effects()
self.score += 10defapplicera_power_up_effekter(själv):
# Lägg till uppstartsspecifik logik här
passeradefactivate_power_up(själv):
self.power_up_active = Sann
# Ställ in en timer eller varaktighet för uppstartseffekten
arcade.schedule (self.deactivate_power_up, 10.0)
defdeactivate_power_up(själv, delta_tid):
self.power_up_active = Falsk
Combo System
Ett kombinationssystem belönar spelare för att de uppnår framgångsrika åtgärder i följd eller poängmultiplikatorer. Skapa en öka_kombo_räknare metod som ökar kombinationsräknaren och ökar poängen baserat på den aktuella kombinationsnivån.
Du kan ringa till reset_combo_counter metod och återställ kombinationsräknaren till noll närhelst en misslyckad åtgärd inträffar. Här är en enkel implementering av ett kombinationssystem:
klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
super().__init__(bredd, höjd)
self.player_x = bredd // 3
self.score = 0
self.combo_counter = 0defuppdatering(själv, delta_tid):
# Kontrollera efter framgångsrika åtgärder
om self.check_successful_action():
self.increase_combo_counter()
annan:
self.reset_combo_counter()deföka_kombo_räknare(själv):
self.combo_counter += 1
self.score += self.combo_counter
defreset_combo_counter(själv):
self.combo_counter = 0
Genom att inkludera ytterligare funktioner som power-ups och combo-system kan du lägga till djup och spänning till ditt spel, ger spelare extra incitament att förbättra sina prestationer, lägga strategi på sina handlingar och uppnå högre poäng.
Bästa praxis för resultathantering
När det gäller att hantera poäng i spel, kan följande bästa praxis bidra till att skapa en roligare och mer engagerande upplevelse för spelare. Här är några viktiga metoder att tänka på:
Meningsfulla poängsättningsmekanismer
Designa poängmekanismer som är i linje med spelets mål och ger meningsfull feedback till spelarna. Poängsystemet bör återspegla spelarens framsteg, skicklighet och prestationer inom spelet.
Överväg att tilldela olika poängvärden till olika handlingar eller händelser baserat på deras svårighetsgrad eller betydelse för spelet.
Visuell feedback
Ge visuell feedback till spelarna när poängen ändras. Du kan uppnå detta genom meddelanden på skärmen, animationer eller partikeleffekter. Visuella signaler skapar en känsla av prestation och förstärker spelarens handlingar, vilket ökar deras engagemang i spelet.
Ljudeffekter och animationer
Införliva ljudeffekter i ditt spel relaterat till poänguppdateringar för att göra upplevelsen mer uppslukande. Spela till exempel en högtidlig ljudeffekt eller visa en skur av konfetti när spelaren når en betydande milstolpe. Dessa audiovisuella element ger spänning och förstärker den positiva feedback-loopen för spelare.
Balanseringssvårigheter och poängskalning
Säkerställ ett balanserat förhållande mellan svårighetsgrad och poängskalning. När spelare går vidare genom spelet eller stöter på mer utmanande hinder, justera poängsystemet därefter. Att skala poängen baserat på spelets svårighetskurva hjälper till att upprätthålla en rättvis och givande upplevelse för spelarna.
Genom att följa dessa bästa metoder kan du effektivt hantera ditt spels poäng, ge spelare meningsfull feedback och skapa en givande och engagerande upplevelse.
Förbättra spelengagemang med resultatspårning
Genom att implementera poängspårning i ditt spel kan du förbättra spelarens engagemang avsevärt. Poäng ger en känsla av prestation, uppmuntrar omspelbarhet och främjar konkurrens mellan spelare.
Visa poäng framträdande och belöna höga prestationer – du kommer att motivera spelare att sträva efter bättre prestationer och förbättra sina färdigheter.