Hvordan man implementerer et dialogsystem i Pygame

Implementering af et dialogsystem i Pygame kan i høj grad forbedre den interaktive oplevelse af et spil. Et dialogsystem giver spillet mulighed for at præsentere samtaler, beskeder og valg for spilleren, hvilket skaber et mere fordybende og engagerende gameplay.

Pygame-biblioteket giver de nødvendige værktøjer til at skabe en grafisk brugergrænseflade (GUI) og håndtere brugerinput, hvilket gør det til et ideelt valg til implementering af et dialogsystem.

Opret et simpelt spil

Før du starter, skal du sikre dig, at du har pip installeret på dit system. Brug denne kommando til at installere pygame bibliotek:

pip installer pygame

Start derefter med at lave et simpelt spil, hvor spilleren kan bevæge sig til venstre og højre, mens han undgår en fjende.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

Kodestykket nedenfor opsætter spilvinduet, initialiserer spillerens og fjendens egenskaber og kører spilløkken.

# Importer nødvendige biblioteker
importere pygame
fra pygame.locals importere *
pygame.init()
# Indstil spilvinduet
screen_width, screen_height = 800, 600
skærm = pygame.display.set_mode((skærmbredde, skærmhøjde))
pygame.display.set_caption("Mit spil")
# Definer farver
SORT = (0, 0, 0)
HVID = (255, 255, 255)
GRÅ = (128, 128, 128)
# Spilleregenskaber
player_x = 400
player_y = 500
player_speed = 5
# Fjendtlige egenskaber
enemy_x = 400
enemy_y = 100
enemy_speed = 3
kører = Rigtigt
ur = pygame.time. Ur()
mens kører:
til begivenhed i pygame.event.get():
hvis event.type == AFSLUT:
 kører = Falsk
 keys = pygame.key.get_pressed()
# Spillerbevægelse
hvis nøgler[K_LEFT] og player_x > 0:
 player_x -= player_speed
hvis nøgler[K_RIGHT] og player_x < screen_width - player_speed:
 player_x += player_speed
# Opdater fjendens position
 enemy_y += enemy_speed
hvis enemy_y > screen_height:
 enemy_y = -50
# Tjek kollision
hvis pygame. Rect (player_x, player_y, 50, 50).kolliderect (pygame. Rekt (enemy_x, enemy_y, 50, 50)):
# Implementer dialogboksen her
passere
 screen.fill (SORT)
 pygame.draw.rect (skærm, HVID, (player_x, player_y, 50, 50))
 pygame.draw.rect (skærm, HVID, (enemy_x, enemy_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Nedenfor er output:

Opret dialogboks

For at implementere en dialogboks skal du vise den, hver gang spilleren rører fjenden. Tilføj dialogboks variabel, som styrer om dialogboksen skal vises eller ej.

Inde i spilløkken, kontrollere for kollision mellem spilleren og fjenden, og hvis der er en kollision, indstil dialogboks til Rigtigt. Inden for tilstanden hvor dialogboks er Rigtigt, tegn et gråt rektangel på skærmen vha pygame.draw.rect() at repræsentere dialogboksen.

Opret en ny fil med navnet dialog.py og tilføj koden med nedenstående opdateringer:

# Dialogboksegenskaber
dialogboksbredde = 400
dialogboks_højde = 200
dialogue_box_x = (skærmbredde - dialogboks_bredde) // 2
dialogue_box_y = (skærmhøjde - dialogboks_højde) // 2
dialogboks = Falsk
# ...
mens kører:
til begivenhed i pygame.event.get():
hvis event.type == AFSLUT:
 kører = Falsk
 keys = pygame.key.get_pressed()
# Spillerbevægelse
hvis nøgler[K_LEFT] og player_x > 0:
 player_x -= player_speed
hvis nøgler[K_RIGHT] og player_x < screen_width - player_speed:
 player_x += player_speed
# Opdater fjendens position
 enemy_y += enemy_speed
hvis enemy_y > screen_height:
 enemy_y = -50
# Tjek kollision
hvis pygame. Rect (player_x, player_y, 50, 50).kolliderect (pygame. Rekt (enemy_x, enemy_y, 50, 50)):
 dialogboks = Rigtigt
 screen.fill (SORT)
hvis dialogboks:
 pygame.draw.rect (skærm, GRÅ, (dialogue_box_x,
 dialogboks_y,
 dialogboksbredde,
 dialogboks_højde))

# Tilføj dialogtekst og knapper her
andet:
 pygame.draw.rect (skærm, HVID, (player_x, player_y, 50, 50))
 pygame.draw.rect (skærm, HVID, (enemy_x, enemy_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Nedenfor er output:

Nu, for at gøre dialogboksen mere funktionel og interaktiv, kan du fortsætte med at tilføje knapper og tekst.

Tilføj knapper ved hjælp af Python GUI

For at tilføje knapper til dialogboksen kan du bruge et Python GUI-bibliotek som Pygame GUI eller PySimpleGUI.

Installer og importer pygame_gui modul, og opret derefter en Pygame GUI-manager ved hjælp af pygame_gui. UIManager. Derefter skal du oprette en knap ved hjælp af UIBnap klasse leveret af Python GUI-biblioteket.

Tilføj inde i spilløkken manager.update (pygame.time.get_ticks() / 1000.0) at opdatere GUI-manageren, og manager.draw_ui (skærm) at tegne GUI-elementerne på skærmen.

Opret en ny fil med navnet buttons.py og tilføj koden med nedenstående opdateringer:

importere pygame_gui 
# Pygame GUI-manager
manager = pygame_gui. UIManager((skærmbredde, skærmhøjde))
# Opret en knap
button_width = 100
knap_højde = 30
button_x = dialogue_box_x + (dialogue_box_width - button_width) // 2
button_y = dialogue_box_y + (dialogue_box_height - button_height) // 2
knap = pygame_gui.elements. UIButton (relative_rect=pygame. Ret (knap_x, knap_y, knap_bredde, knap_højde),
 tekst='Klik på mig',
 manager=manager)
kører = Rigtigt
ur = pygame.time. Ur()
mens kører:
til begivenhed i pygame.event.get():
hvis event.type == pygame. AFSLUT:
 kører = Falsk
 manager.proces_events (hændelse)
 keys = pygame.key.get_pressed()
# Tjek kollision
hvis pygame. Rect (player_x, player_y, 50, 50).kolliderect (pygame. Rekt (enemy_x, enemy_y, 50, 50)):
 dialogboks = Rigtigt
 screen.fill (SORT)
hvis dialogboks:
 pygame.draw.rect (skærm, GRÅ, (dialogue_box_x, 
 dialogboks_y, 
 dialogboksbredde, 
 dialogboks_højde))
 manager.update (pygame.time.get_ticks() / 1000.0)
 manager.draw_ui (skærm)
andet:
 pygame.draw.rect (skærm, HVID, (player_x, player_y, 50, 50))
 pygame.draw.rect (skærm, HVID, (enemy_x, enemy_y, 50, 50))
 pygame.display.flip()
 clock.tick(60)
pygame.quit()

Nedenfor er output:

Med disse ændringer skulle knappen nu være synlig inde i dialogboksen, når den vises.

Tilføj tekst ved hjælp af Python GUI

For at vise tilpasset tekst i dialogboksen kan du bruge tekstfunktionaliteten fra Python GUI-biblioteket.

Definer skrifttypeegenskaberne vha pygame.font. Skrifttype(). Lave en tekst variabel med det ønskede indhold, og gengiv det derefter med den angivne skrifttype og farve.

Opret en ny fil med navnet text.py og tilføj koden med nedenstående opdateringer:

# Initialiser Pygame GUI-manager
manager = pygame_gui. UIManager((skærmbredde, skærmhøjde))
# Definer skrifttypeegenskaber
font = pygame.font. Skrifttype(Ingen, 24)
tekst_farve = SORT
# ...
mens kører:
# ...
hvis dialogboks:
 pygame.draw.rect (skærm, GRÅ, (dialogue_box_x, 
 dialogboks_y, 
 dialogboksbredde, 
 dialogboks_højde))
# Tilføj tekst til dialogboksen
 tekst = "Hej, velkommen til spillet!"
 rendered_text = font.render (tekst, Rigtigt, tekst_farve)
 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)

Nedenfor er output:

Inklusiv yderligere funktioner

Ud over knapper og tekst er der flere andre funktioner, du kan overveje at tilføje til dit dialogsystem i Pygame. Her er et par flere eksempler:

Karakters følelser

Vis følelser eller ansigtsudtryk for karakterer under dialog for at formidle deres humør eller reaktioner. Dette kan opnås ved at bruge animerede sprites eller billedoverlejringer, der ændrer sig baseret på konteksten for samtalen.

Betingede dialoger

Brug betingede udsagn til at udløse specifikke dialoger baseret på bestemte kriterier, såsom spillerens fremskridt, tidligere valg eller begivenheder i spillet. Dette tilføjer dybde og personlige interaktioner baseret på spillerens handlinger.

Voiceovers

Forbedre fordybelsen af ​​dialogsystemet ved at inkorporere stemmeskuespil til karakterdialoger. Afspil lydklip i Pygame der matcher den tekst, der vises i dialogboksen, for at give karakterer en tydelig stemme.

Ved at inkorporere disse ekstra funktioner kan du skabe et mere dynamisk og engagerende dialogsystem, der forbedrer spillerens fordybelse og giver en unik spiloplevelse.

Bedste praksis for tilføjelse af dialogsystem

Når du implementerer et dialogsystem i Pygame, er det vigtigt at følge visse bedste praksisser for at sikre effektivitet, vedligeholdelse og en jævn spilleroplevelse. Her er nogle yderligere bedste praksisser at overveje:

Brug datadrevet design

Gem dialogindhold, herunder tekst, højttaleroplysninger og dialogindstillinger, i eksterne datafiler (f.eks. JSON, XML). Dette giver mulighed for nem ændring, lokalisering og styring af dialogens indhold uden at kræve kodeændringer.

Implementer en Dialog Manager

Opret en dedikeret dialogstyringsklasse eller -modul, der håndterer logikken til styring af dialoginteraktioner. Dette hjælper med at holde koden organiseret og muliggør lettere vedligeholdelse og udvidelsesmuligheder.

Legetest og balancering

Spiltest og afbalancer dialogsystemet regelmæssigt for at sikre, at dialoger flyder naturligt, valg har meningsfulde konsekvenser, og tempoet stemmer overens med den overordnede spiloplevelse. Indsaml feedback fra spillere og gentag dialogens indhold og struktur for at forbedre spillerengagementet.

Lokaliseringsstøtte

Design dialogsystemet med lokalisering for øje fra begyndelsen. Adskil tekststrenge fra koden, og brug sprogfiler eller lokaliseringsbiblioteker til at understøtte flere sprog. Dette giver mulighed for lettere oversættelse og lokalisering af dialogens indhold.

Ved at følge disse bedste praksisser kan du sikre, at dit dialogsystem er veldesignet, effektivt og fleksibelt, hvilket giver mulighed for lettere vedligeholdelse og opdateringer, efterhånden som dit spil udvikler sig.

Gør spil mere engagerende med dialogsystem

Tilføjelse af et dialogsystem til dit spil kan gøre det mere engagerende ved at give spillere mulighed for at interagere med ikke-spillerfigurer (NPC'er), afdække historielinjer, træffe valg og få værdifuld information.

Husk at designe dialogstrukturen med omtanke, brug en modulær tilgang, og overvej at integrere samleobjekter og niveauer for yderligere at berige spilleroplevelsen.