play_vs_ai.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\n",
       "\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       ".container { width: 100% }\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Philosopher', sans-serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 2.2em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(0, 80, 120);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 1.9em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(200,100,0);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    margin-top:12px;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: italic;\n",
       "    color: rgb(94,127,192);\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {\n",
       "    font-family: 'Alegreya Sans', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 16pt;\n",
       "    color: grey;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 {\n",
       "    font-family: 'PT Mono', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 10pt;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: \"PT Mono\";\n",
       "        font-size: 100%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "import os\n",
    "from IPython.display import clear_output\n",
    "\n",
    "# Define Styles\n",
    "from IPython.display import display\n",
    "from IPython.core.display import HTML\n",
    "\n",
    "with open('style.css', 'r') as file:\n",
    "    css = file.read()\n",
    "HTML(css)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Play vs The AI Chess Engine\n",
    "This notebook allows to play games against the chess engine. The depth can be manually set and the game results/log will be written into a logfile.\n",
    "\n",
    "### Basic setup: running the notebook `chess_core` and creating a new `board`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run chess_core.ipynb\n",
    "board = chess.Board()\n",
    "board = board.root()\n",
    "clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change depth here if desired\n",
    "Disclaimer: a depth above 5 or 6 (depending on the computer this notebook is running on) can result in much higher computation times, possibly making the game unplayable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "depth = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change player color if desired (you have to run the \"basic setup\" again to restart the game)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "player_color = chess.WHITE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Play against the AI\n",
    "The following is the code to play against the AI. It can be divided into four parts:\n",
    " - preparing the log file\n",
    " - taking the player move and calculating/executing the AI move\n",
    " - printing and logging\n",
    " - checking for game over\n",
    " \n",
    "First, the logfile for the recently started game is being created. For that reason, in case the directory does not exist yet, it will be created as well. After creating the logfile, the main `while` loop starts and always follows the same pattern: first, it takes the player move as a text input. **Note: the move has to follow the _long algebraic notation_ e.g. `d2d4` or `c3f6`**. If the move is illegal, the player has to input a new one. After that, the move will be executed and the resulting board will be passed to the `minimax_input` function, together with the earlier defined `depth`.  The move (as well as the value) will be returned by this function and the former will be executed. After that, many values for debugging and information purposes will be evaluated and printed: the overall time needed, the chosen move together with the value, and the amount of cache hits in relation to the overall number of calls of the minimax function. This data, together with the board (in _fen_ notation) will then also be written to the created logfile. Lastly, the function checks for a game over state and prints it, if present.\n",
    "\n",
    "After this, the loop will start over again. This happens until the game is over, also using the `winning_state` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "skip_player_move = not player_color # Shold not skip a move for the player if the color is white - should skip once for black\n",
    "player_had_last_move = False # Flag to correctly interpret the result of the winning_state function; if True, then the result will be calculated for the ai, thus creating an inverted result\n",
    "display(board)\n",
    "log_dir_name = \".logs\"\n",
    "filepath = os.path.join(log_dir_name,\"log_\" + str(time.time()) + \".log\")\n",
    "if not os.path.exists(log_dir_name):\n",
    "    os.makedirs(log_dir_name)\n",
    "with open(filepath,'a') as logfile:\n",
    "    logfile.write(\"Depth: \" + str(depth) + \" - Player Color: \" + (\"WHITE\" if player_color else \"BLACK\") + \"\\n\\n\")\n",
    "    while winning_state(board) is None:\n",
    "        if skip_player_move:\n",
    "            skip_player_move = False\n",
    "            player_move = \"\"\n",
    "        else:\n",
    "            print(\"Player Move:\")\n",
    "            player_move = input()\n",
    "            player_uci_move = chess.Move.from_uci(player_move)\n",
    "            if not player_uci_move in board.legal_moves:\n",
    "                print(\"Illegal Move, try again\")\n",
    "                continue\n",
    "            board.push(player_uci_move)\n",
    "            clear_output(wait=True)\n",
    "            display(board)\n",
    "        start_time = time.time()\n",
    "        if winning_state(board) is None:\n",
    "            value, move = minimax_input(board, depth)\n",
    "            board.push(move)\n",
    "        else: # Game is already over, player had the last move and thus the result of winning_state shall be inverted\n",
    "            player_had_last_move = True\n",
    "        clear_output(wait=True)\n",
    "        display(board)\n",
    "        time_for_move = time.time() - start_time\n",
    "        minimax_cache_ratio = CACHE_HITS / MINIMAX_CALLS * 100\n",
    "        print(\"AI Time:\", round(time_for_move, 2), \"seconds\")\n",
    "        print(\"AI Move:\\n\", move, \"| Value:\", value)\n",
    "        print(\"Minimax calls:\", MINIMAX_CALLS)\n",
    "        print(\"CACHE_HITS:\", CACHE_HITS, \"(\", (minimax_cache_ratio), \"%)\")\n",
    "        print(f\"Total Cache items: {len(CACHE)}\")\n",
    "        logfile.write(\"Player move:\" + str(player_move) +\n",
    "                      \" | FEN: \" + str(board.fen()) +\n",
    "                      \"\\nAI move: \" + str(move) + \n",
    "                      \" | Projected value: \" + str(value) + \n",
    "                      \" | Current value: \" + str(static_eval(board,is_endgame(board))) +\n",
    "                      \" | Time: \" + str(time_for_move) + \" seconds.\" +\n",
    "                      \"\\nMinimax accesses: \" + str(MINIMAX_CALLS) +  \n",
    "                      \" | Cache accesses: \" + str(CACHE_HITS) + \n",
    "                      \" | Ratio: \" + str(minimax_cache_ratio) + \"%\" + \n",
    "                      \"\\n==================== \\n\")\n",
    "        win_state = winning_state(board)\n",
    "        if win_state == None:\n",
    "            pass\n",
    "        elif win_state == 0:\n",
    "            print(\"=====Game over, draw!=====\")\n",
    "            logfile.write(\"Draw\")\n",
    "        elif win_state < 0:\n",
    "            if player_had_last_move:\n",
    "                print(\"=====Game over, you won!=====\")\n",
    "                logfile.write(\"AI lost\")\n",
    "            else:\n",
    "                print(\"=====Game over, you lost!=====\")\n",
    "                logfile.write(\"AI won\")\n",
    "print(\"Log has been written to\", filepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}