PDF de programación - Python (Práctica 5)

Python (Práctica 5)

Objetivo: Escribiendo un Juego Conversacional
Vamos a seguir los pasos necesarios, con los conocimientos adquiridos, para esbozar un pequeño
juego conversacional. Vamos a ponernos en la piel del programador, pensando cómo quiere que sea el
juego e implementando el código de acuerdo a esas necesidades.

Programa 6: La Mansión
En La Mansión queremos tener una historia en la que el jugador debe recorrer una casa maldita con el
objetivo de encontrar un tesoro, una piedra preciosa de incalculable valor. Estará encerrada en un cofre
y protegida por un troll.

Haremos el juego sencillo, de manera que la casa tendrá sólo 2 pisos y, en cada piso, 6 habitaciones.
Debemos decidir qué hay en cada lugar y qué obstáculos va a encontrar, así que lo mejor es esbozar
un plano y situar allí los elementos. Éste va a ser el nuestro:

(*) Dentro del baúl hay una espada.
(**) Debajo de la mesa hay una llave.

Por cierto, los bombones están envenenados, también. La comida y la bebida son necesarias pues
nuestro protagonista tendrá que beber y comer para sobrevivir...

Bien. Los juegos conversacionales (el término técnico es ficción interactiva) funcionan en base a
una comunicación escrita. Eso quiere decir que se pide al jugador que escriba las acciones que quiere
realizar. Como vamos a usar el idioma español con sus acentos, caracteres especiales y similares, es
evidente que una de las primeras líneas del programa tendrá que ser la familiar

# -*- coding: utf-8 -*-

Sigamos. Nuestro parser (palabra también técnica que indica la parte del programa que procesa la
comunicación entre el usuario y el ordenador) debe entender frases sencillas, pongamos que en
infinitivo. Así que tendremos que almacenar los verbos en una lista. ¿Por qué? Por que bastará ver si el
verbo que ha introducido el jugador está en la lista para saber qué hacer o indicar que no se entiende.
¿Qué verbos usar? Ésta va a ser nuestra lista:

verbos = ['ir', 'coger', 'abrir', 'atacar', 'hablar', 'beber', 'comer', 'saltar', \
'subir', 'bajar', 'inventario','examinar']

La mayor parte de los verbos son autoexplicativos. Por ejemplo, tenemos un verbo 'atacar' por que
tendremos que luchar con el troll del segundo piso. Y un verbo 'saltar' por que tendremos que atravesar
el pozo (mágico) sin caernos...

Para desplazarnos, tendremos que usar direcciones (una forma típica es decir cosas del estilo de 'ir
norte' etc). Añadamos de la misma forma

direcciones = ["norte", "sur", "este", "oeste"]

Como puede imaginarse, un juego real es bastante más complejo (se usan incluso librerías específicas
que facilitan la vida al programador) y la forma de comunicarse es mucho más elaborada y flexible.
Pero, de momento, nos valdrá lo que tenemos.

También tendremos que interaccionar con cosas. Necesitamos una lista de objetos que podamos
coger:

objetos = ['llave', 'espada', 'copa', 'vaso', 'galletas', 'bombones']

Hemos optado por poner los objetos comestibles y bebibles (tendremos que cogerlos primero para
poder tomarlos), la llave que nos permitirá abrir el cofre y la espada para luchar.

Esto nos lleva al concepto de variables de estado. ¿Cómo podrá saber Python si el jugador lleva la
llave? Este tipo de cuestiones se suelen solucionar con variables booleanas, es decir, las que pueden
tomar solamente valores True o False. Inicialmente, el jugador no tiene la llave. Así que en algún lugar
del comienzo del juego definiremos una variable de la manera siguiente:

tieneLlave = False

Consecuentemente, en el momento en el que durante el juego se coja la llave, la variable tendrá que
cambiarse a True. Y siempre que deseemos saber si el jugador tiene o no la llave, solo tendremos que
consultar el estado de tieneLlave.

¿Se te ocurren otras variables de estado? La necesidad de algunas surge a poco que pensemos:

tieneEspada = False
haComido = False
haBebido = False

Y otras le aparecen al programador a medida que va implementando el programa o le surgen
necesidades. Un ejemplo muy típico es

juegoAcabado = False

¿Para qué lo necesitamos? En los juegos, y en otros muchos programas, generalmente no sabemos
cuánto va a durar la ejecución. En nuestro caso, el jugador va realizando acciones una y otra vez, y
solo cuando surja una circunstancia extrema (como una muerte o una victoria) hay que detenerlo. Pero
esa causa puede surgir en muchos sitios distintos.

La manera de abordar este problema es usar esa variable de estado que acabamos de definir,
juegoAcabado. Metemos el desarrollo del juego dentro de un bucle infinito, para que el jugador realice
sus acciones repetidamente, y cuando juegoAcabado sea True, salimos con un break y procedemos a
terminar el juego.

while True:
…
…
if juegoAcabado:

break

Otra forma es que el propio bucle while controle la variable de estado:

while not juegoAcabado:

…
…

Por cierto, en este tipo de juegos, es fácil que el jugador muera y tenga que probar muchas veces
hasta conseguir superarlo, así que el propio programa debería ofrecer la posibilidad de volver a jugar.
¿Qué significa esto? Meter todo lo anterior en otro bucle while que controle el comienzo del juego
tantas veces como haga falta.

El esquema de cómo debe estar organizado el programa sería algo así:

Importar librerías

definir variables generales

definir funciones

Bucle while que gestiona las partidas

definir variables del juego

Iniciar juego

Bucle while que gestiona el juego

Las que no cambian

nunca

p. ej. verbos = [...

Las que cambian durante

el juego y hay que
reinicar al empezar

cada partida

p. ej. tieneLlave = False

¿Cómo llevar el seguimiento de la posición del protagonista? Lo más simple es una cuadrícula. El
mapa de dicha cuadrícula, es un apartado importante del juego:

No solo debemos almacenar las habitaciones que tenemos, si no que para cada una de ellas, tenemos
que almacenar por dónde se puede salir. Esta información debemos definirla en el apartado de
variables generales, ya que es común para todo el juego y no cambia.

salidas = {}
salidas[(1,1,1)] = ["este"]
salidas[(1,1,2)] = ["oeste","sur"]
…

(Observa que, entre las diferentes formas de hacerlo, hemos optado por usar un diccionario; las claves
son la posición en la cuadrícula y los valores las direcciones).

Y para empezar el juego, en el apartado de inicializar sus variables, como el jugador comienza en la
entrada, pondremos:

piso = 1
fila =1
columna = 2

Indiquemos ahora dónde están los objetos que pueden cogerse (cuya definición también tendrá que
estar aquí pues el jugador puede cambiar su posición durante el juego). Para ello podemos usar otro
diccionario, que llamaremos mapa, en el que las claves serán la posición en la cuadrícula y el valor
correspondiente el objeto:

mapa ={}
mapa[(1,1,1)] = []
mapa[(1,1,2)] = []
mapa[(1,1,3)] = []
mapa[(1,2,1)] = ["galletas"]
...

¡Pasemos a las funciones! ¿Cuales necesitamos?

En el curso del juego, al entrar en cada habitación, necesitaremos que el jugador reciba una
descripción de lo que se ve. Eso nos induce a definir una función que lo haga:

def describir(piso, fila, columna):

...

(como ves, le pasamos a la función como argumentos el piso, la fila y la columna de la habitación que
hay que describir).

Por cierto, el juego tiene que tener una introducción:

def intro():
...

y esto nos recuerda que hay que hacer pausas para presentar el texto, de ahí que al comienzo del
código importemos la librería time y usemos la función time.sleep() para hacerlas cuando lo
necesitamos.

No podemos olvidarnos tampoco de nuestro parser, la función que se encarga de tomar el texto que
escribe el jugador, analizarlo, y realizar las tareas pertinentes:

def procesar(instrucciones):

…

Para que la función procesar no quede demasiado larga (ya lo es de hecho, ¿verdad?) y por claridad,
vamos a hacer dos cosas más aparte. La primera es la parte que se encarga de felicitar al jugador
cuando gana...

def ganar():
…

… y la segunda es la parte que se encarga de gestionar la comida y la bebida, ya que el tema es
delicado al existir veneno y comida sana al mismo tiempo.

def comerBeber(v,c):

…

(para saber si hay que comer o beber y el qué usamos los dos argumentos de la función; v es el verbo
y c lo que hay que comer o beber).

Pero no retrasemos más la presentación del código; el resto de consideraciones es mejor verlas en
acción. Lo tienes a continuación. Cópialo en un archivo (ten cuidado con las indentaciones al hacerlo y
asegúrate que respetas el PEP8, eliminando en Ninja-IDE los errores y las advertencias) y ponle el
nombre TheHouse.py . Ejecútalo, comprueba que funciona y envíaselo al profesor:

#! /usr/bin/env python
# -*- coding: utf-8 -*-

# Importar los módulos que necesitaremos
import time

# Varias listas con terminología usada en el juego
verbos = ['ir', 'coger', 'abrir', 'atacar', 'hablar', 'beber', 'comer', 'saltar', \
'subir', 'bajar', 'inventario','examinar']
objetos = ['llave', 'espada', 'copa', 'vaso', 'galletas', 'bombones']
direcciones = ["norte", "sur", "este", "oeste"]

# Mapa de salidas de cada habitación, identificadas por 3 números, respectivamente,
# el piso, la fila y la columna
salidas = {}
salidas[(1,1,1)] = ["este"]
salidas[(1,1,2)] = ["oeste","sur"]
salidas[(1,1,3)] = ["sur"]
salidas[(1,2,1)] = ["este"]
salidas[(1,2,2)] = ["oeste","norte","este"]
salidas[(1,2,3)] = ["oeste","norte"]

salidas[(2,1,1)] = ["sur"]
salidas[(2,1,2)] = ["este"]
salidas[(2,1,3)] = ["oeste","norte","sur"]
salidas[(2,2,1)] = ["norte","este"]
salidas[(2,2,2)] = ["oeste","este"]
salidas[(2,2,3)] = ["oeste","norte"]

# Función que se encarga de describir cada sala, identificada como previamente
# se ha comentado por una tupla de tres números.
def describir(p,f,c):
# p es el piso
# f la fila
# c la columna
sala = (p,f,c)
print "-----------------------------------------------------------------------"
if sala == (1,1,1):
print "La habitación está oscura. Hay u