Play_Against_Engine(google_colaboratory).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X4RccAfLaula",
        "outputId": "7751927d-8d09-4d58-b10b-6c95b704b32c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting python-chess\n",
            "  Downloading python_chess-1.999-py3-none-any.whl (1.4 kB)\n",
            "Collecting chess<2,>=1 (from python-chess)\n",
            "  Downloading chess-1.10.0-py3-none-any.whl (154 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m154.4/154.4 kB\u001b[0m \u001b[31m3.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: chess, python-chess\n",
            "Successfully installed chess-1.10.0 python-chess-1.999\n",
            "Collecting cairosvg\n",
            "  Downloading CairoSVG-2.7.1-py3-none-any.whl (43 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.2/43.2 kB\u001b[0m \u001b[31m993.2 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting cairocffi (from cairosvg)\n",
            "  Downloading cairocffi-1.6.1-py3-none-any.whl (75 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.1/75.1 kB\u001b[0m \u001b[31m9.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting cssselect2 (from cairosvg)\n",
            "  Downloading cssselect2-0.7.0-py3-none-any.whl (15 kB)\n",
            "Requirement already satisfied: defusedxml in /usr/local/lib/python3.10/dist-packages (from cairosvg) (0.7.1)\n",
            "Requirement already satisfied: pillow in /usr/local/lib/python3.10/dist-packages (from cairosvg) (9.4.0)\n",
            "Requirement already satisfied: tinycss2 in /usr/local/lib/python3.10/dist-packages (from cairosvg) (1.2.1)\n",
            "Requirement already satisfied: cffi>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from cairocffi->cairosvg) (1.16.0)\n",
            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from cssselect2->cairosvg) (0.5.1)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.10/dist-packages (from cffi>=1.1.0->cairocffi->cairosvg) (2.21)\n",
            "Installing collected packages: cssselect2, cairocffi, cairosvg\n",
            "Successfully installed cairocffi-1.6.1 cairosvg-2.7.1 cssselect2-0.7.0\n"
          ]
        }
      ],
      "source": [
        "!pip3 install python-chess\n",
        "!pip3 install cairosvg"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import chess\n",
        "import chess.svg\n",
        "import cairosvg\n",
        "from cairosvg import svg2png\n",
        "from collections import OrderedDict\n",
        "from operator import itemgetter\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "from IPython.display import clear_output\n",
        "import cv2\n",
        "from google.colab.patches import cv2_imshow"
      ],
      "metadata": {
        "id": "O4IhIOymav5M"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!git clone https://github.com/Dragjon/Chess-Ai-Training.git"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u8bqQTqTa0Xe",
        "outputId": "ee051c25-a6b7-423c-f270-2ea8322da710"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'Chess-Ai-Training'...\n",
            "remote: Enumerating objects: 437, done.\u001b[K\n",
            "remote: Counting objects: 100% (437/437), done.\u001b[K\n",
            "remote: Compressing objects: 100% (244/244), done.\u001b[K\n",
            "remote: Total 437 (delta 192), reused 434 (delta 189), pack-reused 0\u001b[K\n",
            "Receiving objects: 100% (437/437), 1.59 MiB | 5.06 MiB/s, done.\n",
            "Resolving deltas: 100% (192/192), done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "path_to_model = '/content/Chess-Ai-Training/latest_model/morphy'\n",
        "\n",
        "global model\n",
        "model = tf.saved_model.load(path_to_model)\n",
        "\n",
        "\n",
        "def predict(df_eval, imported_model):\n",
        "    \"\"\"Return array of predictions for each row of df_eval\n",
        "\n",
        "    Keyword arguments:\n",
        "    df_eval -- pd.DataFrame\n",
        "    imported_model -- tf.saved_model\n",
        "    \"\"\"\n",
        "    col_names = df_eval.columns\n",
        "    dtypes = df_eval.dtypes\n",
        "    predictions = []\n",
        "    for _, row in df_eval.iterrows():  # Use the underscore to discard the row index\n",
        "        example = tf.train.Example()\n",
        "        for col_name, dtype in dtypes.items():  # Loop through column names and data types\n",
        "            value = row[col_name]  # Access the DataFrame column using col_name\n",
        "            if dtype == 'object':\n",
        "                value = bytes(value, 'utf-8')\n",
        "                example.features.feature[col_name].bytes_list.value.extend([value])\n",
        "            elif dtype == 'float':\n",
        "                example.features.feature[col_name].float_list.value.extend([value])\n",
        "            elif dtype == 'int':\n",
        "                example.features.feature[col_name].int64_list.value.extend([value])\n",
        "        predictions.append(imported_model.signatures['predict'](examples=tf.constant([example.SerializeToString()])))\n",
        "    return predictions\n",
        "\n",
        "\n",
        "def get_board_features(board):\n",
        "    \"\"\"Return array of features for a board\n",
        "\n",
        "    Keyword arguments:\n",
        "    board -- chess.Board()\n",
        "    \"\"\"\n",
        "    board_features = []\n",
        "    for square in chess.SQUARES:\n",
        "      board_features.append(str(board.piece_at(square)))\n",
        "    return board_features\n",
        "\n",
        "\n",
        "def get_move_features(move):\n",
        "    \"\"\"Return 2 arrays of features for a move\n",
        "\n",
        "    Keyword arguments:\n",
        "    move -- chess.Move\n",
        "    \"\"\"\n",
        "    from_ = np.zeros(64)\n",
        "    to_ = np.zeros(64)\n",
        "    from_[move.from_square] = 1\n",
        "    to_[move.to_square] = 1\n",
        "    return from_, to_\n",
        "\n",
        "\n",
        "def get_possible_moves_data(current_board):\n",
        "    \"\"\"Return pd.DataFrame of all possible moves used for predictions\n",
        "\n",
        "    Keyword arguments:\n",
        "    current_board -- chess.Board()\n",
        "    \"\"\"\n",
        "    data = []\n",
        "    moves = list(current_board.legal_moves)\n",
        "    for move in moves:\n",
        "      from_square, to_square = get_move_features(move)\n",
        "      row = np.concatenate((get_board_features(current_board), from_square, to_square))\n",
        "      data.append(row)\n",
        "\n",
        "    board_feature_names = chess.SQUARE_NAMES\n",
        "    move_from_feature_names = ['from_' + square for square in chess.SQUARE_NAMES]\n",
        "    move_to_feature_names = ['to_' + square for square in chess.SQUARE_NAMES]\n",
        "\n",
        "    columns = board_feature_names + move_from_feature_names + move_to_feature_names\n",
        "\n",
        "    df = pd.DataFrame(data = data, columns = columns)\n",
        "\n",
        "    for column in move_from_feature_names:\n",
        "      df[column] = df[column].astype(float)\n",
        "    for column in move_to_feature_names:\n",
        "      df[column] = df[column].astype(float)\n",
        "    return df\n",
        "\n",
        "\n",
        "def find_best_moves(current_board, model, proportion = 0.5):\n",
        "    \"\"\"Return array of the best chess.Move\n",
        "\n",
        "    Keyword arguments:\n",
        "    current_board -- chess.Board()\n",
        "    model -- tf.saved_model\n",
        "    proportion -- proportion of best moves returned\n",
        "    \"\"\"\n",
        "    moves = list(current_board.legal_moves)\n",
        "    df_eval = get_possible_moves_data(current_board)\n",
        "    predictions = predict(df_eval, model)\n",
        "    good_move_probas = []\n",
        "\n",
        "    for prediction in predictions:\n",
        "      proto_tensor = tf.make_tensor_proto(prediction['probabilities'])\n",
        "      proba = tf.make_ndarray(proto_tensor)[0][1]\n",
        "      good_move_probas.append(proba)\n",
        "\n",
        "    dict_ = dict(zip(moves, good_move_probas))\n",
        "    dict_ = OrderedDict(sorted(dict_.items(), key = itemgetter(1), reverse = True))\n",
        "\n",
        "    best_moves = list(dict_.keys())\n",
        "\n",
        "    return best_moves[0:int(np.ceil(len(best_moves)*proportion))]"
      ],
      "metadata": {
        "id": "i9Ca_GP_a_I9"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pawn_white_eval = np.array([[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],\n",
        "                            [5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0],\n",
        "                            [1.0, 1.0, 2.0, 3.0, 3.0, 2.0, 1.0, 1.0],\n",
        "                            [0.5, 0.5, 1.0, 2.5, 2.5, 1.0, 0.5, 0.5],\n",
        "                            [0.0, 0.0, 0.0, 2.0, 2.0, 0.0, 0.0, 0.0],\n",
        "                            [0.5, -0.5, -1.0, 0.0, 0.0, -1.0, -0.5, 0.5],\n",
        "                            [0.5, 1.0, 1.0, -2.0, -2.0, 1.0, 1.0, 0.5],\n",
        "                            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]], float)\n",
        "\n",
        "pawn_black_eval = pawn_white_eval[::-1]\n",
        "\n",
        "\n",
        "knight_white_eval = np.array([[-5.0, -4.0, -3.0, -3.0, -3.0, -3.0, -4.0, -5.0],\n",
        "                              [-4.0, -2.0, 0.0, 0.0, 0.0, 0.0, -2.0, -4.0],\n",
        "                              [-3.0, 0.0, 1.0, 1.5, 1.5, 1.0, 0.0, -3.0],\n",
        "                              [-3.0, 0.5, 1.5, 2.0, 2.0, 1.5, 0.5, -3.0],\n",
        "                              [-3.0, 0.0, 1.5, 2.0, 2.0, 1.5, 0.0, -3.0],\n",
        "                              [-3.0, 0.5, 1.0, 1.5, 1.5, 1.0, 0.5, -3.0],\n",
        "                              [-4.0, -2.0, 0.0, 0.5, 0.5, 0.0, -2.0, -4.0],\n",
        "                              [-5.0, -4.0, -3.0, -3.0, -3.0, -3.0, -4.0, -5.0]], float)\n",
        "\n",
        "knight_black_eval = knight_white_eval[::-1]\n",
        "\n",
        "\n",
        "bishop_white_eval = np.array([[-2.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -2.0],\n",
        "                              [-1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0],\n",
        "                              [-1.0, 0.0, 0.5, 1.0, 1.0, 0.5, 0.0, -1.0],\n",
        "                              [-1.0, 0.5, 0.5, 1.0, 1.0, 0.5, 0.5, -1.0],\n",
        "                              [-1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, -1.0],\n",
        "                              [-1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0],\n",
        "                              [-1.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.5, -1.0],\n",
        "                              [-2.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -2.0]], float)\n",
        "\n",
        "bishop_black_eval = bishop_white_eval[::-1]\n",
        "\n",
        "\n",
        "rook_white_eval = np.array([[0.0, 0.0, 0.0, 0.0, 0.0,  0.0, 0.0, 0.0],\n",
        "                            [0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5],\n",
        "                            [-0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -0.5],\n",
        "                            [-0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -0.5],\n",
        "                            [-0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -0.5],\n",
        "                            [-0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -0.5],\n",
        "                            [-0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -0.5],\n",
        "                            [ 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0]], float)\n",
        "\n",
        "rook_black_eval = rook_white_eval[::-1]\n",
        "\n",
        "\n",
        "queen_white_eval = np.array([[-2.0, -1.0, -1.0, -0.5, -0.5, -1.0, -1.0, -2.0],\n",
        "                             [-1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0],\n",
        "                             [-1.0, 0.0, 0.5, 0.5, 0.5, 0.5, 0.0, -1.0],\n",
        "                             [-0.5, 0.0, 0.5, 0.5, 0.5, 0.5, 0.0, -0.5],\n",
        "                             [0.0, 0.0, 0.5, 0.5, 0.5, 0.5, 0.0, -0.5],\n",
        "                             [-1.0, 0.5, 0.5, 0.5, 0.5, 0.5, 0.0, -1.0],\n",
        "                             [-1.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0, -1.0],\n",
        "                             [-2.0, -1.0, -1.0, -0.5, -0.5, -1.0, -1.0, -2.0]], float)\n",
        "\n",
        "queen_black_eval = queen_white_eval[::-1]\n",
        "\n",
        "\n",
        "king_white_eval = np.array([[-3.0, -4.0, -4.0, -5.0, -5.0, -4.0, -4.0, -3.0],\n",
        "                            [-3.0, -4.0, -4.0, -5.0, -5.0, -4.0, -4.0, -3.0],\n",
        "                            [-3.0, -4.0, -4.0, -5.0, -5.0, -4.0, -4.0, -3.0],\n",
        "                            [-3.0, -4.0, -4.0, -5.0, -5.0, -4.0, -4.0, -3.0],\n",
        "                            [-2.0, -3.0, -3.0, -4.0, -4.0, -3.0, -3.0, -2.0],\n",
        "                            [-1.0, -2.0, -2.0, -2.0, -2.0, -2.0, -2.0, -1.0],\n",
        "                            [2.0, 2.0, 0.0, 0.0, 0.0, 0.0, 2.0, 2.0],\n",
        "                            [2.0, 3.0, 1.0, 0.0, 0.0, 1.0, 3.0, 2.0]], float)\n",
        "\n",
        "king_black_eval = king_white_eval[::-1]\n",
        "\n",
        "\n",
        "def square_to_coord(square):\n",
        "  \"\"\"Convert square to coordinates\n",
        "  \"\"\"\n",
        "  return {0:(7,0), 1:(7,1), 2:(7,2), 3:(7,3), 4:(7,4), 5:(7,5), 6:(7,6), 7:(7,7),\n",
        "          8:(6,0), 9:(6,1), 10:(6,2), 11:(6,3), 12:(6,4), 13:(6,5), 14:(6,6), 15:(6,7),\n",
        "          16:(5,0), 17:(5,1), 18:(5,2), 19:(5,3), 20:(5,4), 21:(5,5), 22:(5,6), 23:(5,7),\n",
        "          24:(4,0), 25:(4,1), 26:(4,2), 27:(4,3), 28:(4,4), 29:(4,5), 30:(4,6), 31:(4,7),\n",
        "          32:(3,0), 33:(3,1), 34:(3,2), 35:(3,3), 36:(3,4), 37:(3,5), 38:(3,6), 39:(3,7),\n",
        "          40:(2,0), 41:(2,1), 42:(2,2), 43:(2,3), 44:(2,4), 45:(2,5), 46:(2,6), 47:(2,7),\n",
        "          48:(1,0), 49:(1,1), 50:(1,2), 51:(1,3), 52:(1,4), 53:(1,5), 54:(1,6), 55:(1,7),\n",
        "          56:(0,0), 57:(0,1), 58:(0,2), 59:(0,3), 60:(0,4), 61:(0,5), 62:(0,6), 63:(0,7)}[square]\n",
        "\n",
        "\n",
        "def get_piece_value(piece, square):\n",
        "  \"\"\"Return the value of a piece\n",
        "  \"\"\"\n",
        "  x, y = square_to_coord(square)\n",
        "\n",
        "  if(ai_white):\n",
        "    sign_white = -1\n",
        "    sign_black = 1\n",
        "  else:\n",
        "    sign_white = 1\n",
        "    sign_black = -1\n",
        "\n",
        "  if(piece == 'None'):\n",
        "    return 0\n",
        "  elif(piece == 'P'):\n",
        "    return sign_white * (10 + pawn_white_eval[x][y])\n",
        "  elif(piece == 'N'):\n",
        "    return sign_white * (30 + knight_white_eval[x][y])\n",
        "  elif(piece == 'B'):\n",
        "    return sign_white * (30 + bishop_white_eval[x][y])\n",
        "  elif(piece == 'R'):\n",
        "    return sign_white * (50 + rook_white_eval[x][y])\n",
        "  elif(piece == 'Q'):\n",
        "    return sign_white * (90 + queen_white_eval[x][y])\n",
        "  elif(piece == 'K'):\n",
        "    return sign_white * (900 + king_white_eval[x][y])\n",
        "  elif(piece == 'p'):\n",
        "    return sign_black * (10 + pawn_black_eval[x][y])\n",
        "  elif(piece == 'n'):\n",
        "    return sign_black * (30 + knight_black_eval[x][y])\n",
        "  elif(piece == 'b'):\n",
        "    return sign_black * (30 + bishop_black_eval[x][y])\n",
        "  elif(piece == 'r'):\n",
        "    return sign_black * (50 + rook_black_eval[x][y])\n",
        "  elif(piece == 'q'):\n",
        "    return sign_black * (90 + queen_black_eval[x][y])\n",
        "  elif(piece == 'k'):\n",
        "    return sign_black * (900 + king_black_eval[x][y])\n",
        "\n",
        "\n",
        "def evaluate_board(board):\n",
        "  \"\"\"Return the evaluation of a board\n",
        "  \"\"\"\n",
        "  evaluation = 0\n",
        "  for square in chess.SQUARES:\n",
        "    piece = str(board.piece_at(square))\n",
        "    evaluation = evaluation + get_piece_value(piece, square)\n",
        "  return evaluation\n",
        "\n",
        "\n",
        "def minimax(depth, board, alpha, beta, is_maximising_player):\n",
        "\n",
        "  if(depth == 0):\n",
        "    return - evaluate_board(board)\n",
        "  elif(depth > 3):\n",
        "    legal_moves = find_best_moves(board, model, 0.75)\n",
        "  else:\n",
        "    legal_moves = list(board.legal_moves)\n",
        "\n",
        "  if(is_maximising_player):\n",
        "    best_move = -9999\n",
        "    for move in legal_moves:\n",
        "      board.push(move)\n",
        "      best_move = max(best_move, minimax(depth-1, board, alpha, beta, not is_maximising_player))\n",
        "      board.pop()\n",
        "      alpha = max(alpha, best_move)\n",
        "      if(beta <= alpha):\n",
        "        return best_move\n",
        "    return best_move\n",
        "  else:\n",
        "    best_move = 9999\n",
        "    for move in legal_moves:\n",
        "      board.push(move)\n",
        "      best_move = min(best_move, minimax(depth-1, board, alpha, beta, not is_maximising_player))\n",
        "      board.pop()\n",
        "      beta = min(beta, best_move)\n",
        "      if(beta <= alpha):\n",
        "        return best_move\n",
        "    return best_move\n",
        "\n",
        "\n",
        "def minimax_root(depth, board, is_maximising_player = True):\n",
        "  #only search the top 50% moves\n",
        "  legal_moves = find_best_moves(board, model)\n",
        "  best_move = -9999\n",
        "  best_move_found = None\n",
        "\n",
        "  for move in legal_moves:\n",
        "    board.push(move)\n",
        "    value = minimax(depth - 1, board, -10000, 10000, not is_maximising_player)\n",
        "    board.pop()\n",
        "    if(value >= best_move):\n",
        "      best_move = value\n",
        "      best_move_found = move\n",
        "\n",
        "  return best_move_found"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6ewwWAtebOsD",
        "outputId": "0619c59f-be82-4aa6-e9f3-b949eacb525a"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-5-6bde7a234428>:8: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
            "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
            "  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]], np.float)\n",
            "<ipython-input-5-6bde7a234428>:20: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
            "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
            "  [-5.0, -4.0, -3.0, -3.0, -3.0, -3.0, -4.0, -5.0]], np.float)\n",
            "<ipython-input-5-6bde7a234428>:32: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
            "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
            "  [-2.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -2.0]], np.float)\n",
            "<ipython-input-5-6bde7a234428>:44: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
            "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
            "  [ 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0]], np.float)\n",
            "<ipython-input-5-6bde7a234428>:56: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
            "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
            "  [-2.0, -1.0, -1.0, -0.5, -0.5, -1.0, -1.0, -2.0]], np.float)\n",
            "<ipython-input-5-6bde7a234428>:68: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
            "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
            "  [2.0, 3.0, 1.0, 0.0, 0.0, 1.0, 3.0, 2.0]], np.float)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def draw_board(current_board):\n",
        "  \"\"\"Draw board\n",
        "\n",
        "   Keyword arguments:\n",
        "   current_board -- chess.Board()\n",
        "  \"\"\"\n",
        "  board_img = chess.svg.board(current_board, flipped = ai_white)\n",
        "  svg2png(bytestring=board_img,write_to='/content/board.png')\n",
        "  img = cv2.imread('/content/board.png', 1)\n",
        "  cv2_imshow(img)\n",
        "\n",
        "\n",
        "def can_checkmate(move, current_board):\n",
        "  \"\"\"Return True if a move can checkmate\n",
        "\n",
        "  Keyword arguments:\n",
        "  move -- chess.Move\n",
        "  current_board -- chess.Board()\n",
        "  \"\"\"\n",
        "  fen = current_board.fen()\n",
        "  future_board = chess.Board(fen)\n",
        "  future_board.push(move)\n",
        "  return future_board.is_checkmate()\n",
        "\n",
        "\n",
        "def ai_play_turn(current_board):\n",
        "  \"\"\"Handdle the A.I's turn\n",
        "\n",
        "  Keyword arguments:\n",
        "  current_board -- chess.Board()\n",
        "  \"\"\"\n",
        "  clear_output()\n",
        "  draw_board(current_board)\n",
        "  print('\\n')\n",
        "  print(r\"\"\"\n",
        "                      ._ o o\n",
        "                      \\_`-)|_       Hold on,\n",
        "                   ,\"\"       \\        Let me think...\n",
        "                 ,\"  ## |   ಠ ಠ.\n",
        "               ,\" ##   ,-\\__    `.\n",
        "             ,\"       /     `--._;)\n",
        "           ,\"     ## /\n",
        "         ,\"   ##    /\n",
        "        \"\"\")\n",
        "  for move in current_board.legal_moves:\n",
        "    if(can_checkmate(move, current_board)):\n",
        "      current_board.push(move)\n",
        "      return\n",
        "\n",
        "  nb_moves = len(list(current_board.legal_moves))\n",
        "\n",
        "  if(nb_moves > 30):\n",
        "    current_board.push(minimax_root(4, current_board))\n",
        "  elif(nb_moves > 10 and nb_moves <= 30):\n",
        "    current_board.push(minimax_root(5, current_board))\n",
        "  else:\n",
        "    current_board.push(minimax_root(7, current_board))\n",
        "  return\n",
        "\n",
        "\n",
        "def human_play_turn(current_board):\n",
        "  \"\"\"Handle the human's turn\n",
        "\n",
        "  Keyword arguments:\n",
        "  current_board = chess.Board()\n",
        "  \"\"\"\n",
        "  clear_output()\n",
        "  draw_board(current_board)\n",
        "  print('\\n')\n",
        "  print('\\n')\n",
        "  print('number moves: ' + str(len(current_board.move_stack)))\n",
        "  move_uci = input('Enter your move: ')\n",
        "\n",
        "  try:\n",
        "    move = chess.Move.from_uci(move_uci)\n",
        "  except:\n",
        "    return human_play_turn(current_board)\n",
        "  if(move not in current_board.legal_moves):\n",
        "    return human_play_turn(current_board)\n",
        "  current_board.push(move)\n",
        "  return\n",
        "\n",
        "\n",
        "def play_game(turn, current_board):\n",
        "  \"\"\"Play through the whole game\n",
        "\n",
        "  Keyword arguments:\n",
        "  turn -- True for A.I plays first\n",
        "  current_board -- chess.Board()\n",
        "  \"\"\"\n",
        "  if(current_board.is_stalemate()):\n",
        "    clear_output()\n",
        "    print('Stalemate: No one wins')\n",
        "    return\n",
        "  else:\n",
        "    if(not turn):\n",
        "      if(not current_board.is_checkmate()):\n",
        "        human_play_turn(current_board)\n",
        "        return play_game(not turn, current_board)\n",
        "      else:\n",
        "        clear_output()\n",
        "        draw_board(current_board)\n",
        "        print('A.I wins')\n",
        "        return\n",
        "    else:\n",
        "      if(not current_board.is_checkmate()):\n",
        "        ai_play_turn(current_board)\n",
        "        return play_game(not turn, current_board)\n",
        "      else:\n",
        "        clear_output()\n",
        "        draw_board(current_board)\n",
        "        print('Human wins')\n",
        "        return\n",
        "\n",
        "\n",
        "def play():\n",
        "  \"\"\"Init and start the game\n",
        "  \"\"\"\n",
        "  global ai_white\n",
        "  ai_white = True\n",
        "\n",
        "  board = chess.Board()\n",
        "  human_first = input('Choose your colour [w/b]: ')\n",
        "  clear_output()\n",
        "  if(human_first == 'w'):\n",
        "    ai_white = False\n",
        "    return play_game(False, board)\n",
        "  else:\n",
        "    return play_game(True, board)"
      ],
      "metadata": {
        "id": "VJHVeYQUbil_"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "play()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 854
        },
        "id": "w-xduymibqXd",
        "outputId": "7c0554b1-9611-4ad2-972f-8c1198e77d22"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=390x390>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\n",
            "\n",
            "number moves: 1\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-425fd712de3c>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mplay\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-8-4b2a345a7efe>\u001b[0m in \u001b[0;36mplay\u001b[0;34m()\u001b[0m\n\u001b[1;32m    127\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mplay_game\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mboard\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    128\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 129\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mplay_game\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mboard\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-8-4b2a345a7efe>\u001b[0m in \u001b[0;36mplay_game\u001b[0;34m(turn, current_board)\u001b[0m\n\u001b[1;32m    106\u001b[0m       \u001b[0;32mif\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mnot\u001b[0m \u001b[0mcurrent_board\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_checkmate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    107\u001b[0m         \u001b[0mai_play_turn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcurrent_board\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 108\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mplay_game\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mnot\u001b[0m \u001b[0mturn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcurrent_board\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    109\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    110\u001b[0m         \u001b[0mclear_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-8-4b2a345a7efe>\u001b[0m in \u001b[0;36mplay_game\u001b[0;34m(turn, current_board)\u001b[0m\n\u001b[1;32m     96\u001b[0m     \u001b[0;32mif\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mnot\u001b[0m \u001b[0mturn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     97\u001b[0m       \u001b[0;32mif\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mnot\u001b[0m \u001b[0mcurrent_board\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_checkmate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 98\u001b[0;31m         \u001b[0mhuman_play_turn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcurrent_board\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     99\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mplay_game\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mnot\u001b[0m \u001b[0mturn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcurrent_board\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    100\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-8-4b2a345a7efe>\u001b[0m in \u001b[0;36mhuman_play_turn\u001b[0;34m(current_board)\u001b[0m\n\u001b[1;32m     70\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     71\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'number moves: '\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcurrent_board\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmove_stack\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 72\u001b[0;31m   \u001b[0mmove_uci\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Enter your move: '\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     73\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     74\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m    849\u001b[0m                 \u001b[0;34m\"raw_input was called, but this frontend does not support input requests.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    850\u001b[0m             )\n\u001b[0;32m--> 851\u001b[0;31m         return self._input_request(str(prompt),\n\u001b[0m\u001b[1;32m    852\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_ident\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    853\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_header\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m    893\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    894\u001b[0m                 \u001b[0;31m# re-raise KeyboardInterrupt, to truncate traceback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 895\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Interrupted by user\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    896\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    897\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarning\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Invalid Message:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexc_info\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: Interrupted by user"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "aQW5_jFmpLDj"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}