Cómo implementar un sistema de diálogo en Pygame

Implementar un sistema de diálogo en Pygame puede mejorar enormemente la experiencia interactiva de un juego. Un sistema de diálogo permite que el juego presente conversaciones, mensajes y opciones al jugador, creando un juego más inmersivo y atractivo.

La biblioteca Pygame proporciona las herramientas necesarias para crear una interfaz gráfica de usuario (GUI) y manejar la entrada del usuario, lo que la convierte en una opción ideal para implementar un sistema de diálogo.

Crea un juego simple

Antes de comenzar, asegúrese de tener pip instalado en su sistema. Use este comando para instalar el Pygame biblioteca:

pip instalar pygame

Después de eso, comience creando un juego simple en el que el jugador pueda moverse hacia la izquierda y hacia la derecha mientras evita a un enemigo.

El código utilizado en este artículo está disponible en este repositorio GitHub y es gratis para su uso bajo la licencia MIT.

El fragmento de código a continuación configura la ventana del juego, inicializa las propiedades del jugador y del enemigo, y ejecuta el ciclo del juego.

# Importar bibliotecas necesarias
importar Pygame
de pygame.locals importar *
pygame.init()
# Configurar la ventana del juego
ancho_de_pantalla, alto_de_pantalla = 800, 600
pantalla = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Mi juego")
# Definir colores
NEGRO = (0, 0, 0)
BLANCO = (255, 255, 255)
GRIS = (128, 128, 128)
# Propiedades del jugador
jugador_x = 400
jugador_y = 500
jugador_velocidad = 5
# Propiedades del enemigo
enemigo_x = 400
enemigo_y = 100
velocidad_enemiga = 3
corriendo = Verdadero
reloj = pygame.hora. Reloj()
mientras correr:
para evento en pygame.event.get():
si event.type == SALIR:
 corriendo = FALSO
 llaves = pygame.key.get_pressed()
# Movimiento del jugador
si teclas[K_IZQUIERDA] y jugador_x > 0:
 jugador_x -= jugador_velocidad
si llaves[K_DERECHA] y player_x < screen_width - player_speed:
 jugador_x += jugador_velocidad
# Actualizar la posición del enemigo
 enemigo_y += velocidad_enemigo
si enemigo_y > pantalla_altura:
 enemigo_y = -50
# Comprobar colisión
si pygame. Rect (jugador_x, jugador_y, 50, 50).colliderect (pygame. Rect (enemigo_x, enemigo_y, 50, 50)):
# Implementar cuadro de diálogo aquí
aprobar
 pantalla.llenar (NEGRO)
 pygame.draw.rect (pantalla, BLANCO, (jugador_x, jugador_y, 50, 50))
 pygame.draw.rect (pantalla, BLANCO, (enemigo_x, enemigo_y, 50, 50))
 pygame.display.flip()
 reloj.tick(60)
pygame.quit()

A continuación se muestra la salida:

Crear cuadro de diálogo

Para implementar un cuadro de diálogo, debes mostrarlo cada vez que el jugador toque al enemigo. Añade el dialog_box variable, que controla si el cuadro de diálogo debe mostrarse o no.

Dentro del circuito del juego, comprobar si hay colisión entre el jugador y el enemigo, y si hay una colisión, establecer dialog_box a Verdadero. Dentro de la condición en que dialog_box es Verdadero, dibuje un rectángulo gris en la pantalla usando pygame.dibujar.rect() para representar el cuadro de diálogo.

Crear un nuevo archivo llamado dialogo.py y agregue el código con las siguientes actualizaciones:

# Propiedades del cuadro de diálogo
dialog_box_width = 400
dialog_box_height = 200
dialog_box_x = (pantalla_ancho - dialog_box_ancho) // 2
dialog_box_y = (pantalla_altura - dialog_box_height) // 2
dialog_box = FALSO
# ...
mientras correr:
para evento en pygame.event.get():
si event.type == SALIR:
 corriendo = FALSO
 llaves = pygame.key.get_pressed()
# Movimiento del jugador
si teclas[K_IZQUIERDA] y jugador_x > 0:
 jugador_x -= jugador_velocidad
si llaves[K_DERECHA] y player_x < screen_width - player_speed:
 jugador_x += jugador_velocidad
# Actualizar la posición del enemigo
 enemigo_y += velocidad_enemigo
si enemigo_y > pantalla_altura:
 enemigo_y = -50
# Comprobar colisión
si pygame. Rect (jugador_x, jugador_y, 50, 50).colliderect (pygame. Rect (enemigo_x, enemigo_y, 50, 50)):
 dialog_box = Verdadero
 pantalla.llenar (NEGRO)
si caja_diálogo:
 pygame.draw.rect (pantalla, GRIS, (dialogue_box_x,
 dialog_box_y,
 ancho_cuadro_diálogo,
 altura_cuadro_diálogo))

# Agregue texto de diálogo y botones aquí
demás:
 pygame.draw.rect (pantalla, BLANCO, (jugador_x, jugador_y, 50, 50))
 pygame.draw.rect (pantalla, BLANCO, (enemigo_x, enemigo_y, 50, 50))
 pygame.display.flip()
 reloj.tick(60)
pygame.quit()

A continuación se muestra la salida:

Ahora, para que el cuadro de diálogo sea más funcional e interactivo, puede agregar botones y texto.

Agregar botones usando la interfaz gráfica de usuario de Python

Para agregar botones al cuadro de diálogo, puede utilizar una biblioteca GUI de Python como Pygame GUI o PySimpleGUI.

Instalar e importar el pygame_gui módulo, luego cree un administrador de GUI de Pygame usando pygame_gui. UIManager. Después de eso, crea un botón usando el Botón de interfaz de usuario clase proporcionada por la biblioteca GUI de Python.

Dentro del bucle del juego, añade administrador.actualización (pygame.time.get_ticks() / 1000.0) para actualizar el administrador de GUI, y manager.draw_ui (pantalla) para dibujar los elementos de la GUI en la pantalla.

Crear un nuevo archivo llamado botones.py y agregue el código con las siguientes actualizaciones:

importar pygame_gui 
# Administrador de GUI de Pygame
administrador = pygame_gui. UIManager((pantalla_ancho, pantalla_altura))
# Crear un botón
ancho_boton = 100
altura_boton = 30
button_x = dialog_box_x + (dialogue_box_width - button_width) // 2
button_y = dialog_box_y + (dialogue_box_height - button_height) // 2
botón = pygame_gui.elements. UIButton (relative_rect=pygame. Rect (botón_x, botón_y, ancho_botón, altura_botón),
 texto='Haz click en mi',
 gerente = gerente)
corriendo = Verdadero
reloj = pygame.hora. Reloj()
mientras correr:
para evento en pygame.event.get():
si evento.tipo == pygame. ABANDONAR:
 corriendo = FALSO
 manager.process_events (evento)
 llaves = pygame.key.get_pressed()
# Comprobar colisión
si pygame. Rect (jugador_x, jugador_y, 50, 50).colliderect (pygame. Rect (enemigo_x, enemigo_y, 50, 50)):
 dialog_box = Verdadero
 pantalla.llenar (NEGRO)
si caja_diálogo:
 pygame.draw.rect (pantalla, GRIS, (dialogue_box_x, 
 dialog_box_y, 
 ancho_cuadro_diálogo, 
 altura_cuadro_diálogo))
 administrador.actualizar (pygame.time.get_ticks() / 1000.0)
 manager.draw_ui (pantalla)
demás:
 pygame.draw.rect (pantalla, BLANCO, (jugador_x, jugador_y, 50, 50))
 pygame.draw.rect (pantalla, BLANCO, (enemigo_x, enemigo_y, 50, 50))
 pygame.display.flip()
 reloj.tick(60)
pygame.quit()

A continuación se muestra la salida:

Con estos cambios, el botón ahora debería estar visible dentro del cuadro de diálogo cuando aparezca.

Agregar texto usando la interfaz gráfica de usuario de Python

Para mostrar texto personalizado en el cuadro de diálogo, puede usar la funcionalidad de texto proporcionada por la biblioteca GUI de Python.

Defina las propiedades de la fuente usando pygame.fuente. Fuente(). Crear un texto variable con el contenido deseado y, a continuación, reprodúzcalo con la fuente y el color especificados.

Crear un nuevo archivo llamado texto.py y agregue el código con las siguientes actualizaciones:

# Inicializar el administrador de la GUI de Pygame
administrador = pygame_gui. UIManager((pantalla_ancho, pantalla_altura))
# Definir las propiedades de la fuente
fuente = pygame.fuente. Fuente(Ninguno, 24)
color_texto = NEGRO
# ...
mientras correr:
# ...
si caja_diálogo:
 pygame.draw.rect (pantalla, GRIS, (dialogue_box_x, 
 dialog_box_y, 
 ancho_cuadro_diálogo, 
 altura_cuadro_diálogo))
# Agregar texto al cuadro de diálogo
 texto = "¡Hola, bienvenido al juego!"
 render_text = font.render (texto, Verdadero, color de texto)
 text_rect = render_text.get_rect (center=(dialogue_box_x + dialog_box_width // 2,
 dialog_box_y + dialog_box_height // 2))
 pantalla.blit (texto_renderizado, recto_texto)

A continuación se muestra la salida:

Incluyendo características adicionales

Además de los botones y el texto, hay varias otras características que puede considerar agregar a su sistema de diálogo en Pygame. Aqui hay algunos ejemplos mas:

Emociones de carácter

Muestre emociones o expresiones faciales de los personajes durante el diálogo para transmitir su estado de ánimo o reacciones. Esto se puede lograr mediante el uso de sprites animados o superposiciones de imágenes que cambian según el contexto de la conversación.

Diálogos Condicionales

Use declaraciones condicionales para desencadenar diálogos específicos según ciertos criterios, como el progreso del jugador, las elecciones anteriores o los eventos del juego. Esto agrega profundidad e interacciones personalizadas basadas en las acciones del jugador.

Voces en off

Mejore la inmersión del sistema de diálogo incorporando la actuación de voz para los diálogos de los personajes. Reproducir clips de audio en Pygame que coincidan con el texto que se muestra en el cuadro de diálogo para dar a los personajes una voz distinta.

Al incorporar estas características adicionales, puede crear un sistema de diálogo más dinámico y atractivo que mejora la inmersión del jugador y brinda una experiencia de juego única.

Mejores prácticas para agregar un sistema de diálogo

Al implementar un sistema de diálogo en Pygame, es importante seguir ciertas prácticas recomendadas para garantizar la eficiencia, la capacidad de mantenimiento y una experiencia fluida para los jugadores. Aquí hay algunas mejores prácticas adicionales a considerar:

Usar diseño basado en datos

Almacene el contenido del diálogo, incluido el texto, la información del orador y las opciones de diálogo, en archivos de datos externos (p. ej., JSON, XML). Esto permite una fácil modificación, localización y gestión del contenido del diálogo sin necesidad de cambios en el código.

Implementar un administrador de diálogo

Cree una clase o módulo de administrador de diálogo dedicado que maneje la lógica para administrar las interacciones de diálogo. Esto ayuda a mantener el código organizado y facilita el mantenimiento y la extensibilidad.

Pruebas de juego y equilibrio

Pruebe regularmente y equilibre el sistema de diálogo para asegurarse de que los diálogos fluyan de forma natural, las elecciones tengan consecuencias significativas y el ritmo se alinee con la experiencia de juego general. Recopile comentarios de los jugadores e itere sobre el contenido y la estructura del diálogo para mejorar la participación de los jugadores.

Soporte de localización

Diseñe el sistema de diálogo teniendo en cuenta la localización desde el principio. Separe las cadenas de texto del código y use archivos de idioma o bibliotecas de localización para admitir varios idiomas. Esto permite una traducción y localización más sencilla del contenido del diálogo.

Al seguir estas mejores prácticas, puede asegurarse de que su sistema de diálogo esté bien diseñado, sea eficiente y flexible, lo que permite un mantenimiento y actualizaciones más fáciles a medida que su juego evoluciona.

Haz que los juegos sean más atractivos con el sistema de diálogo

Agregar un sistema de diálogo a su juego puede hacerlo más atractivo al permitir que los jugadores interactúen con personajes que no son jugadores (NPC), descubran historias, tomen decisiones y obtengan información valiosa.

Recuerde diseñar cuidadosamente la estructura del diálogo, use un enfoque modular y considere integrar coleccionables y niveles para enriquecer aún más la experiencia del jugador.