Realistiska karaktärer interagerar, vanligtvis genom att prata med varandra. Se till att du presenterar din dialog på ett tillgängligt och kompletterande sätt.
Om ditt spel innehåller karaktärer, vill du förmodligen att de ska prata med varandra. Ett dialogsystem ger interaktiva samtal, berättelseutveckling och karaktärsutveckling. Python Arcade-biblioteket gör det enkelt att integrera ett dialogsystem i din befintliga kodbas.
Med ett dialogsystem kan du skapa konversationer mellan spelaren och icke-spelare karaktärer (NPC). Spelaren kan välja svar eller fatta beslut som påverkar spelets berättelse eller resultat.
Detta system låter dig skapa övertygande berättelser och skapa dynamiska interaktioner, vilket ger en mer uppslukande spelupplevelse.
Skapa ett enkelt spel
Börja med att skapa ett enkelt spel med hjälp av Arcade-biblioteket. Detta kommer att utgöra grunden för implementeringen av dialogsystemet.
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.
Skapa en ny fil med namnet simple-game.py och definiera a Spel klass som ärver från arkad. Fönster. Ställ in skärmmåtten, initiera spelarens och plattformens positioner och implementera den grundläggande ritningsfunktionen. De spelaren kan flytta åt vänster och höger med hjälp av piltangenterna.
Här är utgången:
Lägga till en dialogruta
Nu när du har en grundläggande spelstruktur, lägg till en dialogruta som visas när spelaren kolliderar med en fiende. Du kan skapa en dialogruta med enkla former och visa den på skärmen.
Lägg till en dialog_aktiv flagga till Spel klass, som anger om dialogrutan ska visas. I den on_update metod, kontrollera fiendens kollision, och om det upptäcks, ställ in dialog_aktiv till Sann.
I den on_draw metod, ring draw_dialogue_box metod om dialogen är aktiv. De draw_dialogue_box metoden ritar en rektangel som bakgrund i dialogrutan och visar ett textmeddelande.
Skapa en ny fil med namnet dialog-box.py och lägg till koden med följande uppdateringar:
# Inuti spelklassenklassSpel(arkad. Fönster):
def__i det__(själv):
# ...self.dialogue_active = Falsk
defon_update(själv, delta_tid):
om self.check_enemy_collision():
self.dialogue_active = Sanndefon_draw(själv):
# ...om self.dialogue_active:
self.draw_dialogue_box()defcheck_enmy_collision(själv):
player_radius = 25
distans_x = abs (self.player_x - self.platform_x)
distans_y = abs (self.player_y - self.platform_y)
combined_radius = player_radius + 25om avstånd_x < kombinerad_radie och distans_y < kombinerad_radie:
lämna tillbakaSann
annan:
lämna tillbakaFalsk
defdraw_dialogue_box(själv):
text = "Hej spelare! Hur mår du?"
arcade.draw_rectangle_filled (SCREEN_WIDTH // 2,
SCREEN_HEIGHT // 2, 500, 200, vit)
arcade.draw_text (text, SCREEN_WIDTH // 2,
SCREEN_HEIGHT // 2 + 20, svart, font_size=16,
anchor_x="Centrum", anchor_y="Centrum")
Nedan är utgången:
Visar dialogtext
Nu kan du förbättra ditt dialogsystem genom att visa dynamiska textmeddelanden. Skapa en lista med dialogsträngar och iterera genom dem för att simulera en konversation. Varje gång dialogrutan visas visar den ett nytt meddelande.
# Inuti spelklassenklassSpel(arkad. Fönster):
def__i det__(själv):
# ...self.dialogue_active = Falsk
self.dialogue_messages = [
"Hej spelare! Hur mår du?",
"Fint väder idag, eller hur?",
"Se upp för fienderna som lurar framför!"
]
self.dialogue_index = 0
defdraw_dialogue_box(själv):
arcade.draw_rectangle_filled (SCREEN_WIDTH // 2,
SCREEN_HEIGHT // 2, 500, 200, vit)
arcade.draw_text (self.dialogue_messages[self.dialogue_index],
SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 + 20, svart, font_size=16,
anchor_x="Centrum", anchor_y="Centrum")
Introducera tre nya variabler: dialog_meddelanden, dialog_index, och dialog_aktiv. Listan dialogue_messages innehåller de textmeddelanden som dialogrutan kommer att visa. Dialogue_index håller reda på det aktuella meddelandet som ska visas. Varje gång dialogrutan visas kan du öka dialogen_index för att visa nästa meddelande.
Lägga till en knapp
För att göra dialogsystemet mer interaktivt, lägg till en knapp för att ändra dialogtexten när spelaren trycker på den. Skapa en ny fil med namnet multi-text.py och lägg till koden med följande uppdateringar:
# Inuti spelklassenklassSpel(arkad. Fönster):
def__i det__(själv):
# ...self.dialogue_active = Falsk
self.dialogue_messages = [
"Hej spelare! Hur mår du?",
"Fint väder idag, eller hur?",
"Se upp för fienderna som lurar framför!"
]self.dialogue_index = 0
defon_mouse_press(själv, x, y, knapp, modifierare):
index = (self.dialogue_index + 1) % len (self.dialogue_messages)om self.dialogue_active:
om knapp == arkad. MOUSE_BUTTON_LEFT:
self.dialogue_index = indexdefdraw_dialogue_box(själv):
# ...
arcade.draw_text("Nästa", SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 - 50,
svart, font_size=16, anchor_x="Centrum", anchor_y="Centrum")
Lägg till on_mouse_press metod för att Spel klass. När dialogen är aktiv och du trycker på vänster musknapp, ökar denna metod dialog_index för att visa nästa meddelande i dialog_meddelanden lista. De % len (self.dialogue_messages) säkerställer att indexet går runt till början av listan när det når slutet.
Inklusive ytterligare funktioner
För att förbättra dialogsystemet ytterligare kan du överväga att lägga till följande ytterligare funktioner:
Flera val
Istället för ett enda meddelande kan du tillhandahålla flera val för spelaren att välja mellan. Detta gör att spelaren kan påverka resultatet av konversationen eller fatta beslut som påverkar spelets utveckling.
För att implementera detta kan du ändra draw_dialogue_box metod för att visa en lista med val och hantera spelarens val därefter.
Karaktärsporträtt
För att lägga till visuell stil till ditt dialogsystem kan du infoga karaktärsporträtt vid sidan av texten. Varje karaktär kan ha en motsvarande bild eller sprite som representerar dem under konversationen. Att visa karaktärsporträtt kan hjälpa spelare att identifiera talaren och lägga till djup till berättarupplevelsen.
Textanimering
Du kan animera texten för att göra den mer visuellt tilltalande. Du kan till exempel få texten att visas gradvis, ett tecken i taget, för att simulera skrivning. Detta skapar en känsla av förväntan och kan göra dialogen mer engagerande för spelaren.
Ljudeffekter
Lägga till ljudeffekter till ditt dialogsystem kan förbättra den övergripande atmosfären i spelet. Du kan till exempel spela upp ljudeffekter när dialogrutan visas eller när spelaren väljer ett dialogalternativ. Dessa ljudsignaler kan få konversationen att kännas mer uppslukande och slagkraftig.
Bästa praxis för dialogsystemet
När du implementerar ett dialogsystem, tänk på följande bästa praxis:
Rensa användargränssnitt
Se till att dialogrutan och texten är läsbar och korrekt placerad på skärmen. Använd lämpliga teckensnitt, färger och storlekar för att göra texten lätt att läsa.
Konsekvent karaktärsröst
Behåll konsistens i hur karaktärerna talar och tonen de använder under hela dialogen. Detta hjälper till att skapa trovärdiga och engagerande samtal.
Relevans för spel
Se till att dialogen bidrar på ett meningsfullt sätt till spelets narrativ eller ger relevant information till spelaren. Undvik överdrivna eller irrelevanta konversationer som kan störa spelflödet.
Testning och iteration
Speltesta ditt dialogsystem noggrant för att identifiera eventuella problem eller inkonsekvenser. Upprepa din dialog baserat på spelarfeedback för att förbättra den övergripande kvaliteten och effekten av samtalen.
Gör spel roligare med dialogsystem
Att lägga till ett dialogsystem till dina spel med hjälp av Arcade-biblioteket i Python kan avsevärt förbättra spelarens upplevelse. Det möjliggör interaktiva konversationer, berättande och karaktärsutveckling, vilket gör dina spel mer uppslukande, engagerande och roligare att spela.
