1.7_labyrinth_game.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare the digital labyrinth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "labyrinth = \"\"\"OOOOOOOOOO\n",
    "O O    O O\n",
    "O . OO   O\n",
    "O O O   XO\n",
    "O OOOO O.O\n",
    "O O O    U\n",
    "O OOOOOO.O\n",
    "O O      O\n",
    "O O OOOOOO\n",
    "O . O    O\n",
    "OOOOOOOOOO\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's assume the labyrinth has a rectangular shape and find its number of lines and columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(11, 10)\n",
      "['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n"
     ]
    }
   ],
   "source": [
    "lines = [ list(line) for line in labyrinth.split('\\n')]\n",
    "\n",
    "nb_columns = len(lines[0])\n",
    "nb_lines = len(lines)\n",
    "\n",
    "print(nb_lines, nb_columns)\n",
    "print(lines[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the coordinates of 'X', assuming there is exactly one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 8)\n"
     ]
    }
   ],
   "source": [
    "def find_x():\n",
    "    for i, line in enumerate(lines):\n",
    "        if 'X' in line:\n",
    "            x_line = i\n",
    "            x_column = line.index('X')\n",
    "    return x_line, x_column\n",
    "\n",
    "print(find_x())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O\n",
      "X\n"
     ]
    }
   ],
   "source": [
    "def whats_in_square(x, y):\n",
    "    return lines[x][y]\n",
    "\n",
    "print(whats_in_square(0,0))\n",
    "print(whats_in_square(3,8))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOOOOOOOOO\n",
      "O O    O O\n",
      "O . OO   O\n",
      "O O O   XO\n",
      "O OOOO O.O\n",
      "O O O    U\n",
      "O OOOOOO.O\n",
      "O O      O\n",
      "O O OOOOOO\n",
      "O . O    O\n",
      "OOOOOOOOOO\n"
     ]
    }
   ],
   "source": [
    "def generate_labyrinth():\n",
    "    return \"\\n\".join([''.join(line) for line in lines ])\n",
    "\n",
    "print generate_labyrinth()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define moving functions: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def move_right():\n",
    "    x_line, x_column = find_x()\n",
    "    if x_line == 0:\n",
    "        raise IndexError\n",
    "    if x_line > 0:\n",
    "        # Test if the square is empty:\n",
    "        target_square_content = whats_in_square(x_line - 1, x_column)\n",
    "        if target_square_content == 'O': #hitting a wall \n",
    "            raise IndexError\n",
    "        elif target_square_content == 'U': #found the exit\n",
    "            return True\n",
    "        #perform the move\n",
    "        lines[x_line][x_column - 1] = 'X'\n",
    "        lines[x_line][x_column] = ' '\n",
    "        return False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOOOOOOOOO\n",
      "O O    O O\n",
      "O . OO   O\n",
      "O O O  X O\n",
      "O OOOO O.O\n",
      "O O O    U\n",
      "O OOOOOO.O\n",
      "O O      O\n",
      "O O OOOOOO\n",
      "O . O    O\n",
      "OOOOOOOOOO\n"
     ]
    }
   ],
   "source": [
    "move_right()\n",
    "print generate_labyrinth()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your turn to code\n",
    "Write the functions move_up, move_down and move_left"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interactive user input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method raw_input in module ipykernel.kernelbase:\n",
      "\n",
      "raw_input(self, prompt='') method of ipykernel.ipkernel.IPythonKernel instance\n",
      "    Forward raw_input to frontends\n",
      "    \n",
      "    Raises\n",
      "    ------\n",
      "    StdinNotImplentedError if active frontend doesn't support stdin.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(raw_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a command: \n",
      "\n"
     ]
    }
   ],
   "source": [
    "user_input = raw_input(\"Enter a command: \")\n",
    "print(user_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a command: q\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'q'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_user_input():\n",
    "    user_input = raw_input(\"Enter a command: \")\n",
    "    bCmdValid = re.match(r'^([asdwq])$', user_input, flags=re.I) is not None\n",
    "    if bCmdValid == False:\n",
    "        raise IndexError\n",
    "    return user_input\n",
    "\n",
    "get_user_input()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's play"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entering command: a\n",
      "Aouch !\n",
      "OOOOOOOOOO\n",
      "O O    O O\n",
      "O . OO   O\n",
      "O O OX   O\n",
      "O OOOO O.O\n",
      "O O O    U\n",
      "O OOOOOO.O\n",
      "O O      O\n",
      "O O OOOOOO\n",
      "O . O    O\n",
      "OOOOOOOOOO\n"
     ]
    }
   ],
   "source": [
    "quitGame = False\n",
    "while quitGame == False:\n",
    "    try:\n",
    "        user_input = get_user_input()\n",
    "    except IndexError:\n",
    "        print(\"Wrong input\")\n",
    "        continue\n",
    "    clear_output()\n",
    "    if (user_input == 'q'):\n",
    "        quitGame = True\n",
    "    print(\"Entering command: {}\".format(user_input))\n",
    "    try:\n",
    "        if user_input == 'a':\n",
    "            move_right()\n",
    "    except IndexError:\n",
    "        print(\"Aouch !\")\n",
    "        quitGame = True\n",
    "    print generate_labyrinth()\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}