main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import http.client\n",
    "import json\n",
    "import time\n",
    "import datetime\n",
    "from functools import lru_cache\n",
    "\n",
    "conn = http.client.HTTPSConnection(\"www.notexponential.com\")\n",
    "headers = {\n",
    "  'x-api-key': '13d493c2d91efe1c451a',\n",
    "  'userid': '1171', \n",
    "  'Content-Type': 'application/x-www-form-urlencoded',\n",
    "  'Authorization': 'Basic YWxpLmFzZ2Fyb3ZAZ3dtYWlsLmd3dS5lZHU6TWFydmVsMDc0QA=='\n",
    "}\n",
    "\n",
    "def create_game(team_id_2, size, target):\n",
    "    conn = http.client.HTTPSConnection(\"www.notexponential.com\")\n",
    "    payload = f'type=game&teamId1=1343&teamId2={team_id_2}&gameType=TTT&boardSize={size}&target={target}' #change team id\n",
    "    conn.request(\"POST\", \"/aip2pgaming/api/index.php\", payload, headers)\n",
    "    res = conn.getresponse()\n",
    "    data = res.read()\n",
    "    s = data.decode(\"utf-8\")\n",
    "    return json.loads(s)\n",
    "\n",
    "\n",
    "def make_move(game_id,move):\n",
    "    conn = http.client.HTTPSConnection(\"www.notexponential.com\")\n",
    "    payload=f'type=move&gameId={game_id}&teamId=1343&move={move}' #change team id\n",
    "    conn.request(\"POST\", \"/aip2pgaming/api/index.php\", payload, headers)\n",
    "    res = conn.getresponse()\n",
    "    data = res.read()\n",
    "    s = data.decode(\"utf-8\")\n",
    "    return s\n",
    "\n",
    "\n",
    "def get_moves(game_id):\n",
    "    conn = http.client.HTTPSConnection(\"www.notexponential.com\")\n",
    "    payload = ''\n",
    "    conn.request(\"GET\", f\"/aip2pgaming/api/index.php?type=moves&gameId={game_id}&count=1\", payload, headers)\n",
    "    res = conn.getresponse()\n",
    "    data = res.read()\n",
    "    s = data.decode(\"utf-8\")\n",
    "    return json.loads(s)\n",
    "\n",
    "\n",
    "def print_board(board):\n",
    "    size = len(board)\n",
    "    for i in range(size):\n",
    "        print(\"|\".join(board[i]))\n",
    "        if i != size - 1:\n",
    "            print(\"-\" * (size * 2 - 1))\n",
    "  \n",
    "\n",
    "def is_winner(board, player, target):\n",
    "    size = len(board)\n",
    "    def check_line(line):\n",
    "        count = 0\n",
    "        for cell in line:\n",
    "            if cell == player:\n",
    "                count += 1\n",
    "                if count == target:\n",
    "                    # problem\n",
    "                    return True\n",
    "            else:\n",
    "                count = 0\n",
    "        return False\n",
    "    # Check rows\n",
    "    for row in board:\n",
    "        if check_line(row):\n",
    "            return True\n",
    "    # Check columns\n",
    "    for col in range(size):\n",
    "\n",
    "        if check_line([board[row][col] for row in range(size)]):\n",
    "            return True\n",
    " # Check diagonals\n",
    "    for diag_start in range(size - target + 1):\n",
    "        # Main diagonal and off-diagonal lines, starting from the top row\n",
    "        if check_line([board[i + diag_start][i] for i in range(size - diag_start)]):\n",
    "            return True\n",
    "        if check_line([board[i + diag_start][size - i - 1] for i in range(size - diag_start)]):\n",
    "            return True\n",
    "        \n",
    "        # Off-diagonal lines, starting from the left and right columns\n",
    "        if diag_start > 0:\n",
    "            if check_line([board[i][i + diag_start] for i in range(size - diag_start)]):\n",
    "                return True\n",
    "            if check_line([board[i][size - i - diag_start - 1] for i in range(size - diag_start)]):\n",
    "                return True\n",
    "\n",
    "    # If no complete lines found, return False\n",
    "    return False\n",
    "\n",
    "  \n",
    "def is_full(board):\n",
    "    return all(cell != \" \" for row in board for cell in row)\n",
    "  \n",
    "\n",
    "def heuristic(board, player, opponent, target):\n",
    "    target=target\n",
    "    \n",
    "    def count_lines(player):\n",
    "        r,c,d=0,0,0\n",
    "        size = len(board)\n",
    "        def check_line(line):\n",
    "            count = 0\n",
    "            for cell in line:\n",
    "                if cell == player:\n",
    "                    count += 1\n",
    "                    if count == target:\n",
    "                        # problem\n",
    "                        return True\n",
    "                else:\n",
    "                    count = 0\n",
    "            return False\n",
    "       \n",
    "\n",
    "        def check_potential_line(line):\n",
    "            count_player = 0\n",
    "            count_blank=0\n",
    "            max_count=0\n",
    "           \n",
    "            for cell in line:\n",
    "                if (cell == player):\n",
    "                    count_player =count_player+ 1\n",
    "                    if count_player+count_blank>=target:\n",
    "                        return 0\n",
    "\n",
    "#                         return (count_player)/100\n",
    "                    \n",
    "                elif cell==\" \":\n",
    "                    count_blank =count_blank+ 1\n",
    "                    if count_player+count_blank>=target:\n",
    "                        return 0\n",
    "\n",
    "#                         return (3*count_player+count_blank)/100\n",
    "\n",
    "                    # if count == target:\n",
    "                        # # problem\n",
    "                        # return True\n",
    "                else:\n",
    "                    max_count=max(max_count,count_player+count_blank)    \n",
    "                    count = 0\n",
    "\n",
    "#             return 0\n",
    "            return 0    \n",
    "            \n",
    "\n",
    "        # Check rows\n",
    "        for row in board:\n",
    "            if check_line(row):\n",
    "                r=r+1\n",
    "            r=r+check_potential_line(row)\n",
    "\n",
    "        # Check columns\n",
    "        for col in range(size):\n",
    "\n",
    "            if check_line([board[row][col] for row in range(size)]):\n",
    "                c=c+1\n",
    "            c=c+check_potential_line([board[row][col] for row in range(size)])\n",
    "\n",
    "\n",
    "    # Check diagonals\n",
    "        for diag_start in range(size - target + 1):\n",
    "            # Main diagonal and off-diagonal lines, starting from the top row\n",
    "            if check_line([board[i + diag_start][i] for i in range(size - diag_start)]):\n",
    "                d=d+1\n",
    "            d=d+check_potential_line([board[i + diag_start][i] for i in range(size - diag_start)])\n",
    "\n",
    "            if check_line([board[i + diag_start][size - i - 1] for i in range(size - diag_start)]):\n",
    "                d=d+1\n",
    "            d=d+check_potential_line([board[i + diag_start][size - i - 1] for i in range(size - diag_start)])\n",
    "\n",
    "            # Off-diagonal lines, starting from the left and right columns\n",
    "            if diag_start > 0:\n",
    "                if check_line([board[i][i + diag_start] for i in range(size - diag_start)]):\n",
    "                    d=d+1\n",
    "                d=d+check_potential_line([board[i][i + diag_start] for i in range(size - diag_start)])\n",
    "\n",
    "                \n",
    "                if check_line([board[i][size - i - diag_start - 1] for i in range(size - diag_start)]):\n",
    "                    d=d+1\n",
    "                d=d+check_potential_line([board[i][size - i - diag_start - 1] for i in range(size - diag_start)])\n",
    "        \n",
    "        \n",
    "        \n",
    "        center_score = 0\n",
    "        for i in range(len(board)):\n",
    "            row = []\n",
    "            for j in range(len(board)):\n",
    "                # Calculate distance from center\n",
    "                x_dist = abs(i - len(board)//2)\n",
    "                y_dist = abs(j - len(board)//2)\n",
    "                dist = max(x_dist, y_dist)\n",
    "\n",
    "            # Assign weight based on distance from center\n",
    "                weight = 1 / (2 ** dist)\n",
    "                if board[i][j]==player:\n",
    "                    center_score=center_score+weight\n",
    "\n",
    "        return r+c+d+center_score\n",
    "\n",
    "\n",
    "    return count_lines(player)\n",
    "\n",
    "  \n",
    "def get_valid_moves(board):\n",
    "    size = len(board)\n",
    "    valid_moves = [(i, j) for i in range(size) for j in range(size) if board[i][j] == \" \"]\n",
    "    return valid_moves\n",
    "\n",
    "def score_move(board, move, team_symbol, opponent_symbol, target):\n",
    "    # Define a scoring function to order moves based on their potential value\n",
    "    # This is a simple example; we can use a more sophisticated heuristic if needed\n",
    "    board_copy = [row.copy() for row in board]\n",
    "    board_copy[move[0]][move[1]] = team_symbol\n",
    "    return heuristic(board_copy, team_symbol, opponent_symbol, target)\n",
    "\n",
    "\n",
    "def minimax(board, depth, alpha, beta, maximizing, max_depth, team_symbol, opponent_symbol, target):\n",
    "    if depth == max_depth or is_winner(board, opponent_symbol, target) or is_winner(board, team_symbol, target) or is_full(board):\n",
    "        if is_winner(board, opponent_symbol, target):\n",
    "            # print(\"yes\")\n",
    "            # print_board(board)\n",
    "\n",
    "            return -1000/(depth+1)\n",
    "        if is_winner(board, team_symbol, target):\n",
    "            return 1000/(depth+1)\n",
    "        if depth == max_depth:\n",
    "            return heuristic(board, team_symbol, opponent_symbol, target)/(depth+1)\n",
    "        return 0\n",
    "    valid_moves = get_valid_moves(board)\n",
    "    best_eval = -sys.maxsize if maximizing else sys.maxsize\n",
    "    if maximizing:\n",
    "        valid_moves.sort(key=lambda move: score_move(board, move, team_symbol, opponent_symbol,target), reverse=True)\n",
    "    else:\n",
    "        valid_moves.sort(key=lambda move: score_move(board, move, opponent_symbol, team_symbol, target), reverse=True)\n",
    "    \n",
    "    for move in valid_moves:\n",
    "        i, j = move\n",
    "        board[i][j] = team_symbol if maximizing else opponent_symbol\n",
    " \n",
    "        eval = minimax(board, depth + 1, alpha, beta, not maximizing, max_depth, team_symbol, opponent_symbol, target)\n",
    "        board[i][j] = \" \"\n",
    "        best_eval = max(eval, best_eval) if maximizing else min(eval, best_eval)\n",
    "        alpha, beta = (max(alpha, eval), beta) if maximizing else (alpha, min(beta, eval))\n",
    "        if beta <= alpha:\n",
    "            break\n",
    "\n",
    "    return best_eval\n",
    "\n",
    "def ai_move(board, max_depth, team_symbol, opponent_symbol, target):\n",
    "    valid_moves = get_valid_moves(board)\n",
    "    valid_moves.sort(key=lambda move: score_move(board, move, team_symbol, opponent_symbol, target), reverse=True)\n",
    "    for move in valid_moves:\n",
    "        board[move[0]][move[1]]=team_symbol\n",
    "        if is_winner(board, team_symbol, target):\n",
    "            return move[0], move[1]\n",
    "        board[move[0]][move[1]]=\" \"\n",
    "\n",
    "    best_move = max(valid_moves, key=lambda move: minimax(board[:move[0]] + [board[move[0]][:move[1]] + [team_symbol] + board[move[0]][move[1] + 1:]] + board[move[0] + 1:], 0, -sys.maxsize, sys.maxsize, False, max_depth, team_symbol, opponent_symbol, target))\n",
    "    # print(\"best move board\", board[:best_move[0]] + [board[best_move[0]][:best_move[1]] + [team_symbol] + board[best_move[0]][best_move[1] + 1:]] + board[best_move[0] + 1:])\n",
    "    # print(\"after \" ,best_move)\n",
    "    return best_move[0], best_move[1]\n",
    "\n",
    "\n",
    "\n",
    "def main():\n",
    "\n",
    "    team_id_2 = int(input(\"Enter team ID: \"))\n",
    "    size = int(input(\"Enter board size: \"))\n",
    "    target = int(input(\"Enter target: \"))\n",
    "    team_symbol=str(input(\"Enter team symbol 'X' or 'O': \"))\n",
    "    \n",
    "    \n",
    "        \n",
    "    if team_symbol=='X':\n",
    "        opponent_symbol='O'\n",
    "    else:\n",
    "        opponent_symbol='X'\n",
    "\n",
    "    board = [[\" \" for _ in range(size)] for _ in range(size)]\n",
    "    max_depth = 3 if size >= 4 else size\n",
    "\n",
    "    \n",
    "    game_initiator = int(input(\"Who creates the game? '1' if we are creating the game, '0' is the opponent team is creating the game: \"))\n",
    "    if game_initiator:\n",
    "        game_details = create_game(team_id_2, size, target)\n",
    "        print(game_details)\n",
    "        game_id = game_details['gameId']\n",
    "    else:\n",
    "        game_id=int(input(\"Enter the game id: \"))\n",
    "    print(f'Game has been created with {team_id_2} and the game_id is {game_id}, good luck !')\n",
    "    \n",
    "    \n",
    "    index = 1\n",
    "    if team_symbol == 'O':\n",
    "        index = 0\n",
    "        \n",
    "    \n",
    "    while not is_full(board) and not is_winner(board, opponent_symbol, target) and not is_winner(board, team_symbol, target):\n",
    "        if index != 0:\n",
    "            print('before ai_move', datetime.datetime.now())\n",
    "            if first_move:\n",
    "                i , j=size//2, size//2\n",
    "                first_move=0\n",
    "            else:\n",
    "                i , j = ai_move(board, max_depth, team_symbol, opponent_symbol, target)\n",
    "            print('after ai_move', datetime.datetime.now())\n",
    "            move = f\"{i},{j}\" \n",
    "\n",
    "            try : \n",
    "                print(make_move(game_id,move))\n",
    "                board[i][j] = team_symbol\n",
    "                print(f'{move} has been done')\n",
    "                print_board(board)\n",
    "            except :\n",
    "                print('Invalid')\n",
    "                \n",
    "        else:\n",
    "            index = index + 1\n",
    "\n",
    "            \n",
    "        while True:\n",
    "  \n",
    "            move_details = get_moves(game_id)\n",
    "\n",
    "            try:\n",
    "                move_i = int(move_details[\"moves\"][0][\"moveX\"]) \n",
    "            except:\n",
    "                time.sleep(5)\n",
    "                continue\n",
    "\n",
    "            \n",
    "            print(move_details)\n",
    "            move_i = int(move_details[\"moves\"][0][\"moveX\"])\n",
    "            move_j = int(move_details[\"moves\"][0][\"moveY\"])\n",
    "\n",
    "            if  is_full(board) or is_winner(board, opponent_symbol, target) or is_winner(board, team_symbol, target):\n",
    "                break\n",
    "            \n",
    "            if (board[move_i][move_j]==opponent_symbol or board[move_i][move_j]==team_symbol) :\n",
    "                time.sleep(5)\n",
    "                continue\n",
    "\n",
    "            else:\n",
    "                board[move_i][move_j] = opponent_symbol\n",
    "                print(\"Opponent played\")\n",
    "                print_board(board)\n",
    "\n",
    "            break\n",
    "        print('\\n')\n",
    "    #we need to print the status of the game to see who is the winner?\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "aee092a1e4baae2e030beaa9b110582a4ae5056d7aff2080621389713d9d630b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}