Como implementar um sistema de diálogo em Pygame

A implementação de um sistema de diálogo no Pygame pode melhorar muito a experiência interativa de um jogo. Um sistema de diálogo permite que o jogo apresente conversas, mensagens e escolhas ao jogador, criando uma jogabilidade mais envolvente e envolvente.

A biblioteca Pygame fornece as ferramentas necessárias para criar uma interface gráfica do usuário (GUI) e lidar com a entrada do usuário, tornando-a uma escolha ideal para implementar um sistema de diálogo.

Crie um jogo simples

Antes de começar, certifique-se de ter pip instalado em seu sistema. Use este comando para instalar o pygame biblioteca:

pip instalar pygame

Depois disso, comece criando um jogo simples onde o jogador pode se mover para a esquerda e para a direita evitando um inimigo.

O código usado neste artigo está disponível neste Repositório GitHub e é gratuito para você usar sob a licença do MIT.

O trecho de código abaixo configura a janela do jogo, inicializa as propriedades do jogador e do inimigo e executa o loop do jogo.

# Importe as bibliotecas necessárias
importar pygame
de pygame.locals importar *
pygame.init()
# Configure a janela do jogo
largura_tela, altura_tela = 800, 600
tela = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Meu jogo")
# Definir cores
PRETO = (0, 0, 0)
BRANCO = (255, 255, 255)
CINZA = (128, 128, 128)
# Propriedades do jogador
jogador_x = 400
jogador_y = 500
jogador_velocidade = 5
# Propriedades inimigas
inimigo_x = 400
inimigo_y = 100
inimigo_velocidade = 3
correndo = Verdadeiro
clock = pygame.time. Relógio()
enquanto correndo:
para evento em pygame.event.get():
se event.type == SAIR:
 correndo = Falso
 keys = pygame.key.get_pressed()
# Movimento do jogador
se chaves[K_LEFT] e jogador_x > 0:
 jogador_x -= jogador_velocidade
se teclas[K_RIGHT] e player_x < screen_width - player_speed:
 jogador_x += jogador_velocidade
# Atualize a posição do inimigo
 inimigo_y += inimigo_velocidade
se inimigo_y > altura_da_tela:
 inimigo_y = -50
# Verificar colisão
se pygame. Rect (jogador_x, jogador_y, 50, 50).colliderect (pygame. Rect (inimigo_x, inimigo_y, 50, 50)):
# Implemente a caixa de diálogo aqui
passar
 screen.fill (PRETO)
 pygame.draw.rect (tela, BRANCO, (player_x, player_y, 50, 50))
 pygame.draw.rect (tela, BRANCO, (inimigo_x, inimigo_y, 50, 50))
 pygame.display.flip()
 relógio.tick(60)
pygame.quit()

Abaixo está a saída:

Criar caixa de diálogo

Para implementar uma caixa de diálogo, você precisa exibi-la sempre que o jogador tocar no inimigo. Adicione o dialog_box variável, que controla se a caixa de diálogo deve ser exibida ou não.

Dentro do loop do jogo, verifique se há colisão entre o jogador e o inimigo, e se houver uma colisão, defina dialog_box para Verdadeiro. Dentro da condição onde dialog_box é Verdadeiro, desenhe um retângulo cinza na tela usando pygame.draw.rect() para representar a caixa de diálogo.

Crie um novo arquivo chamado dialog.py e adicione o código com as atualizações abaixo:

# Propriedades da caixa de diálogo
dialog_box_width = 400
dialog_box_height = 200
dialog_box_x = (screen_width - dialog_box_width) // 2
dialog_box_y = (screen_height - dialog_box_height) // 2
dialog_box = Falso
# ...
enquanto correndo:
para evento em pygame.event.get():
se event.type == SAIR:
 correndo = Falso
 keys = pygame.key.get_pressed()
# Movimento do jogador
se chaves[K_LEFT] e jogador_x > 0:
 jogador_x -= jogador_velocidade
se teclas[K_RIGHT] e player_x < screen_width - player_speed:
 jogador_x += jogador_velocidade
# Atualize a posição do inimigo
 inimigo_y += inimigo_velocidade
se inimigo_y > altura_da_tela:
 inimigo_y = -50
# Verificar colisão
se pygame. Rect (jogador_x, jogador_y, 50, 50).colliderect (pygame. Rect (inimigo_x, inimigo_y, 50, 50)):
 dialog_box = Verdadeiro
 screen.fill (PRETO)
se dialog_box:
 pygame.draw.rect (tela, GREY, (dialogue_box_x,
 dialog_box_y,
 dialog_box_width,
 dialog_box_height))

# Adicione texto de diálogo e botões aqui
outro:
 pygame.draw.rect (tela, BRANCO, (player_x, player_y, 50, 50))
 pygame.draw.rect (tela, BRANCO, (inimigo_x, inimigo_y, 50, 50))
 pygame.display.flip()
 relógio.tick(60)
pygame.quit()

Abaixo está a saída:

Agora, para tornar a caixa de diálogo mais funcional e interativa, você pode adicionar botões e texto.

Adicionar botões usando Python GUI

Para adicionar botões à caixa de diálogo, você pode utilizar uma biblioteca Python GUI como Pygame GUI ou PySimpleGUI.

Instale e importe o pygame_gui módulo e, em seguida, crie um gerenciador de GUI do Pygame usando pygame_gui. UIManager. Depois disso, crie um botão usando o UIButton classe fornecida pela biblioteca Python GUI.

Dentro do loop do jogo, adicione manager.update (pygame.time.get_ticks() / 1000.0) para atualizar o gerenciador de GUI e manager.draw_ui (tela) para desenhar os elementos GUI na tela.

Crie um novo arquivo chamado botões.py e adicione o código com as atualizações abaixo:

importar pygame_gui 
# Gerenciador de GUI do Pygame
gerente = pygame_gui. UIManager((screen_width, screen_height))
# Criar um botão
largura_do_botão = 100
altura_do_botão = 30
button_x = dialog_box_x + (dialogue_box_width - button_width) // 2
button_y = dialog_box_y + (dialogue_box_height - button_height) // 2
botão = pygame_gui.elements. UIButton (relative_rect=pygame. Rect (button_x, button_y, button_width, button_height),
 texto='Clique em mim',
 gerente=gerente)
correndo = Verdadeiro
clock = pygame.time. Relógio()
enquanto correndo:
para evento em pygame.event.get():
se event.type == pygame. DESISTIR:
 correndo = Falso
 manager.process_events (evento)
 keys = pygame.key.get_pressed()
# Verificar colisão
se pygame. Rect (jogador_x, jogador_y, 50, 50).colliderect (pygame. Rect (inimigo_x, inimigo_y, 50, 50)):
 dialog_box = Verdadeiro
 screen.fill (PRETO)
se dialog_box:
 pygame.draw.rect (tela, GREY, (dialogue_box_x, 
 dialog_box_y, 
 dialog_box_width, 
 dialog_box_height))
 manager.update (pygame.time.get_ticks() / 1000.0)
 manager.draw_ui (tela)
outro:
 pygame.draw.rect (tela, BRANCO, (player_x, player_y, 50, 50))
 pygame.draw.rect (tela, BRANCO, (inimigo_x, inimigo_y, 50, 50))
 pygame.display.flip()
 relógio.tick(60)
pygame.quit()

Abaixo está a saída:

Com essas alterações, o botão agora deve estar visível dentro da caixa de diálogo quando aparecer.

Adicionar texto usando Python GUI

Para exibir texto personalizado na caixa de diálogo, você pode usar a funcionalidade de texto fornecida pela biblioteca Python GUI.

Defina as propriedades da fonte usando pygame.font. Fonte(). Criar uma texto variável com o conteúdo desejado e, em seguida, renderize-a usando a fonte e a cor especificadas.

Crie um novo arquivo chamado text.py e adicione o código com as atualizações abaixo:

# Inicializa o gerenciador de GUI do Pygame
gerente = pygame_gui. UIManager((screen_width, screen_height))
# Definir propriedades da fonte
fonte = pygame.font. Fonte(Nenhum, 24)
text_color = PRETO
# ...
enquanto correndo:
# ...
se dialog_box:
 pygame.draw.rect (tela, GREY, (dialogue_box_x, 
 dialog_box_y, 
 dialog_box_width, 
 dialog_box_height))
# Adicione texto à caixa de diálogo
 texto = "Olá, bem-vindo ao jogo!"
 renderizado_texto = fonte.render (texto, Verdadeiro, cor do texto)
 text_rect = renderizado_text.get_rect (center=(dialogue_box_x + dialog_box_width // 2,
 dialog_box_y + dialog_box_height // 2))
 screen.blit (rendered_text, text_rect)

Abaixo está a saída:

Incluindo Recursos Adicionais

Além de botões e texto, existem vários outros recursos que você pode considerar adicionar ao seu sistema de diálogo no Pygame. Aqui estão mais alguns exemplos:

Emoções do Personagem

Exiba emoções ou expressões faciais para os personagens durante o diálogo para transmitir seu humor ou reações. Isso pode ser feito usando sprites animados ou sobreposições de imagens que mudam com base no contexto da conversa.

diálogos condicionais

Use declarações condicionais para acionar diálogos específicos com base em determinados critérios, como o progresso do jogador, escolhas anteriores ou eventos do jogo. Isso adiciona profundidade e interações personalizadas com base nas ações do jogador.

Dublagens

Melhore a imersão do sistema de diálogo incorporando dublagem para os diálogos dos personagens. Reproduzir clipes de áudio no Pygame que correspondem ao texto exibido na caixa de diálogo para dar aos personagens uma voz distinta.

Ao incorporar esses recursos adicionais, você pode criar um sistema de diálogo mais dinâmico e envolvente que aprimora a imersão do jogador e oferece uma experiência de jogo única.

Melhores práticas para adicionar sistema de diálogo

Ao implementar um sistema de diálogo no Pygame, é importante seguir certas práticas recomendadas para garantir eficiência, facilidade de manutenção e uma experiência de jogador tranquila. Aqui estão algumas práticas recomendadas adicionais a serem consideradas:

Use o design orientado a dados

Armazene o conteúdo do diálogo, incluindo texto, informações do locutor e opções de diálogo, em arquivos de dados externos (por exemplo, JSON, XML). Isso permite fácil modificação, localização e gerenciamento do conteúdo do diálogo sem exigir alterações de código.

Implemente um gerenciador de diálogo

Crie uma classe ou módulo de gerenciador de diálogo dedicado que lide com a lógica para gerenciar interações de diálogo. Isso ajuda a manter o código organizado e facilita a manutenção e a extensibilidade.

Playtesting e balanceamento

Teste regularmente e equilibre o sistema de diálogo para garantir que os diálogos fluam naturalmente, as escolhas tenham consequências significativas e o ritmo se alinhe com a experiência geral do jogo. Colete feedback dos jogadores e repita o conteúdo e a estrutura do diálogo para melhorar o envolvimento do jogador.

Suporte de localização

Projete o sistema de diálogo com a localização em mente desde o início. Separe as strings de texto do código e use arquivos de idioma ou bibliotecas de localização para dar suporte a vários idiomas. Isso permite uma tradução e localização mais fáceis do conteúdo do diálogo.

Ao seguir essas práticas recomendadas, você pode garantir que seu sistema de diálogo seja bem projetado, eficiente e flexível, permitindo uma manutenção e atualizações mais fáceis à medida que seu jogo evolui.

Torne os jogos mais envolventes com o sistema de diálogo

Adicionar um sistema de diálogo ao seu jogo pode torná-lo mais envolvente, permitindo que os jogadores interajam com personagens não-jogadores (NPCs), descubram histórias, façam escolhas e obtenham informações valiosas.

Lembre-se de projetar a estrutura do diálogo cuidadosamente, usar uma abordagem modular e considerar a integração de itens colecionáveis ​​e níveis para enriquecer ainda mais a experiência do jogador.