Gör din spelupplevelse mer uppslukande genom att implementera ett dialogsystem.

Att implementera ett dialogsystem i Pygame kan avsevärt förbättra den interaktiva upplevelsen av ett spel. Ett dialogsystem låter spelet presentera konversationer, meddelanden och val för spelaren, vilket skapar ett mer uppslukande och engagerande spel.

Pygame-biblioteket tillhandahåller de nödvändiga verktygen för att skapa ett grafiskt användargränssnitt (GUI) och hantera användarinmatning, vilket gör det till ett idealiskt val för att implementera ett dialogsystem.

Skapa ett enkelt spel

Innan du börjar, se till att du har pip installerad på ditt system. Använd det här kommandot för att installera pygame bibliotek:

pip installera pygame

Efter det, börja med att skapa ett enkelt spel där spelaren kan flytta åt vänster och höger samtidigt som han undviker en fiende.

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.

Kodavsnittet nedan ställer in spelfönstret, initierar spelarens och fiendens egenskaper och kör spelslingan.

instagram viewer 
# Importera nödvändiga bibliotek
importera pygame
från pygame.locals importera *
pygame.init()


# Ställ in spelfönstret
screen_width, screen_height = 800, 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Mitt spel")


# Definiera färger
SVART = (0, 0, 0)
VIT = (255, 255, 255)
GRÅ = (128, 128, 128)


# Spelaregenskaper
player_x = 400
player_y = 500
player_speed = 5


# Fiendeegenskaper
enemy_x = 400
enemy_y = 100
enemy_speed = 3


springer = Sann
klocka = pygame.time. Klocka()


medan löpning:
för händelse i pygame.event.get():
om event.type == AVSLUTA:
 springer = Falsk


 keys = pygame.key.get_pressed()


# Spelarens rörelse
om nycklar[K_LEFT] och player_x > 0:
 player_x -= player_speed
om nycklar[K_RIGHT] och player_x < screen_width - player_speed:
 player_x += player_speed


# Uppdatera fiendens position
 enemy_y += enemy_speed
om enemy_y > screen_height:
 enemy_y = -50


# Kontrollera kollision
om pygame. Rect (player_x, player_y, 50, 50).kolliderect (pygame. Rect (enemy_x, enemy_y, 50, 50)):
# Implementera dialogrutan här
passera


 screen.fill (SVART)
 pygame.draw.rect (skärm, VIT, (player_x, player_y, 50, 50))
 pygame.draw.rect (skärm, VIT, (enemy_x, enemy_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Nedan är utgången:

Skapa dialogruta

För att implementera en dialogruta måste du visa den när spelaren rör vid fienden. Lägg till dialogruta variabel, som styr om dialogrutan ska visas eller inte.

Inne i spelslingan, kontrollera för kollision mellan spelaren och fienden, och om det blir en kollision, ställ in dialogruta till Sann. Inom villkoret där dialogruta är Sann, rita en grå rektangel på skärmen med hjälp av pygame.draw.rect() för att representera dialogrutan.

Skapa en ny fil med namnet dialogue.py och lägg till koden med följande uppdateringar:

# Dialogrutaegenskaper
dialog_box_width = 400
dialog_box_height = 200
dialogue_box_x = (screen_width - dialogue_box_width) // 2
dialogue_box_y = (screen_height - dialogue_box_height) // 2
dialogbox = Falsk
# ...
medan löpning:
för händelse i pygame.event.get():
om event.type == AVSLUTA:
 springer = Falsk
 keys = pygame.key.get_pressed()
# Spelarens rörelse
om nycklar[K_LEFT] och player_x > 0:
 player_x -= player_speed
om nycklar[K_RIGHT] och player_x < screen_width - player_speed:
 player_x += player_speed
# Uppdatera fiendens position
 enemy_y += enemy_speed
om enemy_y > screen_height:
 enemy_y = -50
# Kontrollera kollision
om pygame. Rect (player_x, player_y, 50, 50).kolliderect (pygame. Rect (enemy_x, enemy_y, 50, 50)):
 dialogbox = Sann
 screen.fill (SVART)
om dialogruta:
 pygame.draw.rect (skärm, GRÅ, (dialogue_box_x,
 dialog_box_y,
 dialog_box_width,
 dialogue_box_height))

# Lägg till dialogtext och knappar här
annan:
 pygame.draw.rect (skärm, VIT, (player_x, player_y, 50, 50))
 pygame.draw.rect (skärm, VIT, (enemy_x, enemy_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Nedan är utgången:

Nu, för att göra dialogrutan mer funktionell och interaktiv, kan du fortsätta med att lägga till knappar och text.

Lägg till knappar med Python GUI

För att lägga till knappar i dialogrutan kan du använda ett Python GUI-bibliotek som Pygame GUI eller PySimpleGUI.

Installera och importera pygame_gui modul, skapa sedan en Pygame GUI-hanterare med hjälp av pygame_gui. UIManager. Efter det skapar du en knapp med hjälp av UIButton klass tillhandahållen av Python GUI-biblioteket.

Inuti spelslingan, lägg till manager.update (pygame.time.get_ticcks() / 1000.0) för att uppdatera GUI-hanteraren och manager.draw_ui (skärm) för att rita GUI-elementen på skärmen.

Skapa en ny fil med namnet buttons.py och lägg till koden med följande uppdateringar:


importera pygame_gui 
# Pygame GUI-hanterare
manager = pygame_gui. UIManager((screen_width, screen_height))


# Skapa en knapp
button_width = 100
button_height = 30
button_x = dialogue_box_x + (dialogue_box_width - button_width) // 2
button_y = dialogue_box_y + (dialogue_box_height - button_height) // 2
button = pygame_gui.elements. UIButton (relative_rect=pygame. Rect (button_x, button_y, button_width, button_height),
 text='Klicka här',
 chef=chef)


springer = Sann
klocka = pygame.time. Klocka()


medan löpning:
för händelse i pygame.event.get():
om event.type == pygame. SLUTA MED:
 springer = Falsk


 manager.process_events (händelse)


 keys = pygame.key.get_pressed()


# Kontrollera kollision
om pygame. Rect (player_x, player_y, 50, 50).kolliderect (pygame. Rect (enemy_x, enemy_y, 50, 50)):
 dialogbox = Sann


 screen.fill (SVART)


om dialogruta:
 pygame.draw.rect (skärm, GRÅ, (dialogue_box_x, 
 dialog_box_y, 
 dialog_box_width, 
 dialogue_box_height))
 manager.update (pygame.time.get_ticcks() / 1000.0)
 manager.draw_ui (skärm)
annan:
 pygame.draw.rect (skärm, VIT, (player_x, player_y, 50, 50))
 pygame.draw.rect (skärm, VIT, (enemy_x, enemy_y, 50, 50))


 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Nedan är utgången:

Med dessa ändringar ska knappen nu vara synlig i dialogrutan när den visas.

Lägg till text med Python GUI

För att visa anpassad text i dialogrutan kan du använda textfunktionaliteten som tillhandahålls av Python GUI-biblioteket.

Definiera teckensnittsegenskaperna med hjälp av pygame.font. Font(). Skapa en text variabel med önskat innehåll och rendera det sedan med det angivna teckensnittet och färgen.

Skapa en ny fil med namnet text.py och lägg till koden med följande uppdateringar:


# Initiera Pygame GUI-hanteraren
manager = pygame_gui. UIManager((screen_width, screen_height))
# Definiera teckensnittsegenskaper
font = pygame.font. Font(Ingen, 24)
text_color = SVART


# ...


medan löpning:
# ...


om dialogruta:
 pygame.draw.rect (skärm, GRÅ, (dialogue_box_x, 
 dialog_box_y, 
 dialog_box_width, 
 dialogue_box_height))


# Lägg till text i dialogrutan
 text = "Hej, välkommen till spelet!"
 rendered_text = font.render (text, Sann, text färg)
 text_rect = rendered_text.get_rect (center=(dialogue_box_x + dialogue_box_width // 2,
 dialogue_box_y + dialogue_box_height // 2))
 screen.blit (rendered_text, text_rect)

Nedan är utgången:

Inklusive ytterligare funktioner

Förutom knappar och text finns det flera andra funktioner du kan överväga att lägga till i ditt dialogsystem i Pygame. Här är några fler exempel:

Karaktärs känslor

Visa känslor eller ansiktsuttryck för karaktärer under dialog för att förmedla deras humör eller reaktioner. Detta kan uppnås genom att använda animerade sprites eller bildöverlägg som ändras baserat på konversationens kontext.

Villkorliga dialoger

Använd villkorliga uttalanden för att utlösa specifika dialoger baserat på vissa kriterier, såsom spelarens framsteg, tidigare val eller händelser i spelet. Detta lägger till djup och personliga interaktioner baserat på spelarens handlingar.

Voiceovers

Förbättra fördjupningen av dialogsystemet genom att inkludera röstskådespeleri för karaktärsdialoger. Spela ljudklipp i Pygame som matchar texten som visas i dialogrutan för att ge karaktärer en distinkt röst.

Genom att införliva dessa ytterligare funktioner kan du skapa ett mer dynamiskt och engagerande dialogsystem som förbättrar spelarens fördjupning och ger en unik spelupplevelse.

Bästa praxis för att lägga till dialogsystem

När du implementerar ett dialogsystem i Pygame är det viktigt att följa vissa bästa praxis för att säkerställa effektivitet, underhållbarhet och en smidig spelarupplevelse. Här är några ytterligare bästa metoder att överväga:

Använd datadriven design

Lagra dialoginnehåll, inklusive text, talarinformation och dialogalternativ, i externa datafiler (t.ex. JSON, XML). Detta möjliggör enkel modifiering, lokalisering och hantering av dialoginnehållet utan att kräva kodändringar.

Implementera en dialogledare

Skapa en dedikerad dialoghanterarklass eller modul som hanterar logiken för att hantera dialoginteraktioner. Detta hjälper till att hålla koden organiserad och möjliggör enklare underhåll och utbyggbarhet.

Speltestning och balansering

Spela regelbundet och balansera dialogsystemet för att säkerställa att dialoger flyter naturligt, val har betydelsefulla konsekvenser och takten överensstämmer med den övergripande spelupplevelsen. Samla feedback från spelare och upprepa dialogens innehåll och struktur för att förbättra spelarens engagemang.

Lokaliseringsstöd

Designa dialogsystemet med lokalisering i åtanke från början. Separera textsträngar från koden och använd språkfiler eller lokaliseringsbibliotek för att stödja flera språk. Detta möjliggör enklare översättning och lokalisering av dialoginnehållet.

Genom att följa dessa bästa praxis kan du säkerställa att ditt dialogsystem är väldesignat, effektivt och flexibelt, vilket möjliggör enklare underhåll och uppdateringar i takt med att ditt spel utvecklas.

Gör spel mer engagerande med dialogsystem

Att lägga till ett dialogsystem till ditt spel kan göra det mer engagerande genom att låta spelare interagera med icke-spelare karaktärer (NPC), avslöja storylines, göra val och få värdefull information.

Kom ihåg att utforma dialogstrukturen eftertänksamt, använd ett modulärt tillvägagångssätt och överväg att integrera samlarföremål och nivåer för att ytterligare berika spelarupplevelsen.