games.ipynb

       "3"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game52.play_game(alphabeta_player, alphabeta_player)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game52.play_game(alphabeta_player, random_player)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current state:\n",
      "A\n",
      "available moves: ['a1', 'a2', 'a3']\n",
      "\n",
      "Your move? a1\n",
      "B1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game52.play_game(query_player, alphabeta_player)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current state:\n",
      "B\n",
      "available moves: ['b1', 'b2', 'b3']\n",
      "\n",
      "Your move? b1\n",
      "B1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game52.play_game(alphabeta_player, query_player)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that if you are the first player then alphabeta_player plays as MIN, and if you are the second player then alphabeta_player plays as MAX. This happens because that's the way the game is defined in the class Fig52Game. Having a look at the code of this class should make it clear."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TicTacToe\n",
    "\n",
    "Now let's play `TicTacToe`. First we initialize the game by creating an instance of the subclass TicTacToe inherited from the class Game:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ttt = TicTacToe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can print a state using the display method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ". . . \n",
      ". . . \n",
      ". . . \n"
     ]
    }
   ],
   "source": [
    "ttt.display(ttt.initial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hmm, so that's the initial state of the game; no X's and no O's.\n",
    "\n",
    "Let us create a new game state by ourselves to experiment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_state = GameState(\n",
    "    to_move = 'X',\n",
    "    utility = '0',\n",
    "    board = {(1,1): 'X', (1,2): 'O', (1,3): 'X',\n",
    "             (2,1): 'O',             (2,3): 'O',\n",
    "             (3,1): 'X',\n",
    "            },\n",
    "    moves = [(2,2), (3,2), (3,3)]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, how does this game state look like?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X O X \n",
      "O . O \n",
      "X . . \n"
     ]
    }
   ],
   "source": [
    "ttt.display(my_state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `random_player` will behave how he is supposed to i.e. *pseudo-randomly*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_player(ttt, my_state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_player(ttt, my_state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But the `alphabeta_player` will always give the best move, as expected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabeta_player(ttt, my_state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's make two players play against each other. We use the `play_game` function for this. The `play_game` function makes players play the match against each other and returns the utility for the first player, of the terminal state reached when the game ends. Hence, for our `TicTacToe` game, if we get the output +1, the first player wins, -1 if the second player wins, and 0 if the match ends in a draw."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O O . \n",
      "X O X \n",
      "X X O \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ttt.play_game(random_player, alphabeta_player)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output is (usually) -1, because `random_player` loses to `alphabeta_player`. Sometimes, however, `random_player` manages to draw with `alphabeta_player`.\n",
    "\n",
    "Since an `alphabeta_player` plays perfectly, a match between two `alphabeta_player`s should always end in a draw. Let's see if this happens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n",
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n",
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n",
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n",
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n",
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n",
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n",
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n",
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n",
      "X X O \n",
      "O O X \n",
      "X O X \n",
      "0\n"
     ]
    }
   ],
   "source": [
    "for _ in range(10):\n",
    "    print(ttt.play_game(alphabeta_player, alphabeta_player))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `random_player` should never win against an `alphabeta_player`. Let's test that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X O O \n",
      "X O . \n",
      "O X X \n",
      "-1\n",
      "O X . \n",
      "O X X \n",
      "O . . \n",
      "-1\n",
      "X X O \n",
      "O O X \n",
      "O X . \n",
      "-1\n",
      "O O O \n",
      ". X X \n",
      "X . . \n",
      "-1\n",
      "O O O \n",
      ". . X \n",
      "X . X \n",
      "-1\n",
      "O X O \n",
      "X O X \n",
      "X . O \n",
      "-1\n",
      "O X X \n",
      "O X X \n",
      "O O . \n",
      "-1\n",
      "O O X \n",
      "X O X \n",
      "X O . \n",
      "-1\n",
      "O O X \n",
      "X O . \n",
      "X O X \n",
      "-1\n",
      "O O X \n",
      "X X O \n",
      "O X X \n",
      "0\n"
     ]
    }
   ],
   "source": [
    "for _ in range(10):\n",
    "    print(ttt.play_game(random_player, alphabeta_player))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Canvas_TicTacToe(Canvas)\n",
    "\n",
    "This subclass is used to play TicTacToe game interactively in Jupyter notebooks. TicTacToe class is called while initializing this subclass.\n",
    "\n",
    "Let's have a match between `random_player` and `alphabeta_player`. Click on the board to call players to make a move."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from notebook import Canvas_TicTacToe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script type=\"text/javascript\" src=\"./js/canvas.js\"></script>\n",
       "<div>\n",
       "<canvas id=\"bot_play\" width=\"300\" height=\"350\" style=\"background:rgba(158, 167, 184, 0.2);\" onclick='click_callback(this, event, \"bot_play\")'></canvas>\n",
       "</div>\n",
       "\n",
       "<script> var bot_play_canvas_object = new Canvas(\"bot_play\");</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>\n",
       "bot_play_canvas_object.strokeWidth(5);\n",
       "bot_play_canvas_object.font(\"20px Arial\");\n",
       "bot_play_canvas_object.clear();\n",
       "bot_play_canvas_object.stroke(0, 0, 0);\n",
       "bot_play_canvas_object.line(15, 100, 285, 100);\n",
       "bot_play_canvas_object.line(15, 200, 285, 200);\n",
       "bot_play_canvas_object.line(100, 15, 100, 285);\n",
       "bot_play_canvas_object.line(200, 15, 200, 285);\n",
       "bot_play_canvas_object.fill_text(\"Player X's move(random)\", 15, 318);\n",
       "</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bot_play = Canvas_TicTacToe('bot_play', 'random', 'alphabeta')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's play a game ourselves against a `random_player`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script type=\"text/javascript\" src=\"./js/canvas.js\"></script>\n",
       "<div>\n",
       "<canvas id=\"rand_play\" width=\"300\" height=\"350\" style=\"background:rgba(158, 167, 184, 0.2);\" onclick='click_callback(this, event, \"rand_play\")'></canvas>\n",
       "</div>\n",
       "\n",
       "<script> var rand_play_canvas_object = new Canvas(\"rand_play\");</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>\n",
       "rand_play_canvas_object.strokeWidth(5);\n",
       "rand_play_canvas_object.font(\"20px Arial\");\n",
       "rand_play_canvas_object.clear();\n",
       "rand_play_canvas_object.stroke(0, 0, 0);\n",
       "rand_play_canvas_object.line(15, 100, 285, 100);\n",
       "rand_play_canvas_object.line(15, 200, 285, 200);\n",
       "rand_play_canvas_object.line(100, 15, 100, 285);\n",
       "rand_play_canvas_object.line(200, 15, 200, 285);\n",
       "rand_play_canvas_object.fill_text(\"Player X's move(human)\", 15, 318);\n",
       "</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rand_play = Canvas_TicTacToe('rand_play', 'human', 'random')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yay! We (usually) win. But we cannot win against an `alphabeta_player`, however hard we try."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script type=\"text/javascript\" src=\"./js/canvas.js\"></script>\n",
       "<div>\n",
       "<canvas id=\"ab_play\" width=\"300\" height=\"350\" style=\"background:rgba(158, 167, 184, 0.2);\" onclick='click_callback(this, event, \"ab_play\")'></canvas>\n",
       "</div>\n",
       "\n",
       "<script> var ab_play_canvas_object = new Canvas(\"ab_play\");</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>\n",
       "ab_play_canvas_object.strokeWidth(5);\n",
       "ab_play_canvas_object.font(\"20px Arial\");\n",
       "ab_play_canvas_object.clear();\n",
       "ab_play_canvas_object.stroke(0, 0, 0);\n",
       "ab_play_canvas_object.line(15, 100, 285, 100);\n",
       "ab_play_canvas_object.line(15, 200, 285, 200);\n",
       "ab_play_canvas_object.line(100, 15, 100, 285);\n",
       "ab_play_canvas_object.line(200, 15, 200, 285);\n",
       "ab_play_canvas_object.fill_text(\"Player X's move(human)\", 15, 318);\n",
       "</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ab_play = Canvas_TicTacToe('ab_play', 'human', 'alphabeta')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}