python_chess_engine.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "python-chess-engine.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MessiSkillz/ChessEngine/blob/main/python_chess_engine.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0GLrsNkxgSrE"
      },
      "source": [
        "#Python Chess Engine ♟️\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5U2BBi4RT8tL"
      },
      "source": [
        "**libraries**\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dsacAJ-5gkN0"
      },
      "source": [
        "!pip3 install python-chess\n",
        "!pip3 install cairosvg"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nrv8bXmMgn6G"
      },
      "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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yveIUxzjUr2b"
      },
      "source": [
        "**tensorflow model**\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zltySP8_UrTA",
        "outputId": "a71cf1a6-b863-4544-9109-df0e9378be4f"
      },
      "source": [
        "!git clone https://github.com/iAmEthanMai/chess-engine-model.git"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'chess-engine-model'...\n",
            "remote: Enumerating objects: 54, done.\u001b[K\n",
            "remote: Counting objects: 100% (54/54), done.\u001b[K\n",
            "remote: Compressing objects: 100% (46/46), done.\u001b[K\n",
            "remote: Total 54 (delta 22), reused 22 (delta 6), pack-reused 0\u001b[K\n",
            "Unpacking objects: 100% (54/54), done.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "loDX7U-wUwAQ"
      },
      "source": [
        "**model utils**\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0IussDJEU6Nj"
      },
      "source": [
        "path_to_model = '/content/chess-engine-model/latest-model'\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():\n",
        "      example = tf.train.Example()\n",
        "      for i in range(len(col_names)):\n",
        "        dtype = dtypes[i]\n",
        "        col_name = col_names[i]\n",
        "        value = row[1][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(len(best_moves)*proportion)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dyb46NIAUN9I"
      },
      "source": [
        "**minimax**\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "inDa8N70gO6I"
      },
      "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]], np.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]], np.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]], np.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]], np.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]], np.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]], np.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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zg57ZibfUS2C"
      },
      "source": [
        "**game util**\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GFvB8_SHg0V5"
      },
      "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: both A.I and human win')\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('Care to start? [y/n]: ')\n",
        "  clear_output()\n",
        "  if(human_first == 'y'):\n",
        "    ai_white = False\n",
        "    return play_game(False, board)\n",
        "  else:\n",
        "    return play_game(True, board)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q6PdYgyZUayy"
      },
      "source": [
        "**play**\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 541
        },
        "id": "tIks0yXVpEw2",
        "outputId": "bd10a22f-7495-4a47-a811-1831894de05f"
      },
      "source": [
        "play()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=400x400 at 0x7F82895CC4A8>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "\n",
            "\n",
            "number moves: 6\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}