Implementar MazeGame y completar la implementación del juego básico

El juego funciona de forma satisfactoria, pero el control de errores no se
ha agregado aún.

1 files changed, 85 insertions, 18 deletions

diff --git a/maze.py b/maze.py
index 68941ce..c540e6c 100644
--- a/maze.py
+++ b/maze.py
@@ -17,24 +17,23 @@ una cuadrícula entera de tamaño dado. (0, 0) es el nodo de inicio y
 (size, size) es el nodo de acabado. Esta es una forma estándar para representar
 un grafo en un programa.
 
-La próxima clase para implementar es Maze. Para mantener la separación entre
-los componentes del programa, no debe incluir ningún código que procesa los
-jugadores o su comportamiento --- que debe estar en la clase del jugador.
-
-El código de la clase Maze debe implementar un grafo simétrico bastante
-estándar, como se explica aquí:
-    http://es.wikipedia.org/wiki/Grafo
-No hay suficiente espacio para explicar la teoría de grafos en estas notas, por
-favor ver Wikipedia para más información sobre los grafos (a diferencia de los
-gráficos de datos), la reflexividad, simetría de grafos y planeidad.
-
-El grafo se almacena como una lista de adyacencia, ya que es un grafo
-moderadamente escasa:
-    http://es.wikipedia.org/wiki/Grafo_%28estructura_de_datos%29
-
-Tenga en cuenta que la clase de laberinto ha sido diseñado para ser
-completamente inmutable: el tamaño y la forma del grafo no se pueden cambiar
-después de que el laberinto se ha construido.
+Por último, la clase MazeGame debe ser escrito para unir ambas Maze y Player.
+Esta clase debe implementar la interfaz de usuario, preguntando repetidamente
+el jugador que se mueven van a hacer, a continuación, actualizar la ubicación
+del jugador en consecuencia.
+
+La implementación de este requiere un método que se añade a Maze para recuperar
+una lista de los nodos que legítimamente el jugador puede mover a partir de su
+ubicación actual. Para evitar romper la compartimentación y la codificación de
+la conducta del jugador en la clase Maze, el método toma un nodo como un
+parámetro en lugar de acceder a la ubicación del reproductor directamente.
+
+Una característica del lenguaje a destacar es el uso de "while...else" in
+MazeGame.run(). El código en el bloque 'else' se ejecutará inmediatamente
+después de la última iteración del bucle 'while', pero no se ejecutará si la
+ejecución sale de la curva mediante la ejecución de la instrucción 'break'.
+Esto significa que el "que ha ganado" el mensaje no se imprimirá si el usuario
+sale el juego antes de tiempo.
 """
 
 import random
@@ -183,3 +182,71 @@ class Maze(object):
         return self._finish_node
 
     finish_node = property(get_finish_node)
+
+    def get_adjacents_to_node(self, node):
+        """Obtener una lista de nodos que son adyacentes al nodo dado.
+
+        Esta lista puede incluir el propio nodo, como se permiten enlaces
+        reflexivos. Si se pasa un nodo no válido como parámetro, se devuelve
+        una lista vacía.
+        """
+        return self._links.get(node, [])
+
+
+class MazeGame(object):
+    """Aplicación de línea de comandos del juego del laberinto.
+
+    Esto conecta el Player al Maze y ejecuta el bucle de entrada que maneja
+    opciones de movimiento del jugador.
+    """
+    def __init__(self):
+        name = raw_input('Introduzca su nombre: ')
+        size = int(raw_input('Introduzca el tamaño del laberinto (5–20): '))
+
+        self._player = Player(name)
+        self._maze = Maze(size)
+
+    def __choose_next_location(self):
+        """Preguntar al usuario para la siguiente ubicación para moverse.
+
+        El lugar elegido se devuelve como una tupla (X, Y), que está
+        garantizado para ser un nodo válido en el laberinto. Si el usuario opta
+        por salir del juego, se devuelve None.
+        """
+
+        # Obtenga una lista de los nodos conncted a la ubicación actual del
+        # jugador.
+        adjacent_nodes = \
+            self._maze.get_adjacents_to_node(self._player.location)
+
+        # Imprimir las opciones, numeradas.
+        option = 1
+        print('Usted se encuentra en %s. Puede acceder a:' %
+            str(self._player.location))
+        for node in adjacent_nodes:
+            print(' %u) %s' % (option, str(node)))
+            option += 1
+
+        print(' 0) Salir del juego')
+
+        # Pida al usuario la opción que quieran.
+        chosen_option = int(raw_input('Ingrese el número de su elección: '))
+        if chosen_option == 0:
+            return None  # salir del juego
+        else:
+            return adjacent_nodes[chosen_option - 1]
+
+    def run(self):
+        """Ejecutar el juego hasta que el jugador gana o se cierra."""
+        while self._player.location != self._maze.finish_node:
+            chosen_node = self.__choose_next_location()
+            if chosen_node is None:
+                break  # salir del juego
+
+            self._player.location = chosen_node
+        else:
+            print('Has ganado, %s!' % self._player.name)
+
+
+# Ejecutar el juego.
+MazeGame().run()