Untitled.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyautogui\n",
    "import cv2\n",
    "import numpy as np\n",
    "import imutils\n",
    "import PIL.Image\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_dict = {\n",
    "    (0, 0, 0)      : 0, # blank\n",
    "    (15, 155, 215) : 1, #line\n",
    "    (227, 159, 2)  : 2, #square\n",
    "    (175, 41, 138) : 3, # T\n",
    "    (89, 177, 1)   : 4, # S\n",
    "    (215, 15, 55)  : 5, #Z\n",
    "    (33, 65, 198)  : 6, # ReverseL\n",
    "    (227, 91, 2)   : 7, # L\n",
    "    #any outline        : -1,\n",
    "}\n",
    "\n",
    "num_to_shape = {\n",
    "    1 : 'I',\n",
    "    2 : 'O',\n",
    "    3 : 'T',\n",
    "    4 : 'S',\n",
    "    5 : 'Z',\n",
    "    6 : 'J',\n",
    "    7 : 'L',\n",
    "}\n",
    "\n",
    "def colors_to_blocks(img):\n",
    "    mat = np.ndarray(img.shape[:-1])\n",
    "    for row_i, row in enumerate(img):\n",
    "            for col_i, pixel in enumerate(row):\n",
    "                #print(pixel)\n",
    "                scaled = pixel\n",
    "                key = tuple(np.round(scaled).astype(np.int))\n",
    "                if key in color_dict:\n",
    "                    mat[row_i, col_i] = color_dict[key]\n",
    "                else: \n",
    "                    mat[row_i, col_i] = -1\n",
    "        \n",
    "    return mat\n",
    "\n",
    "def colors_to_binary(img):\n",
    "    mat = np.ndarray(img.shape[:-1])\n",
    "    for row_i, row in enumerate(img):\n",
    "            for col_i, pixel in enumerate(row):\n",
    "                if tuple(pixel) == (0., 0., 0.):\n",
    "                    mat[row_i, col_i] = 0\n",
    "                else:\n",
    "                    mat[row_i, col_i] = 1\n",
    "        \n",
    "    return mat\n",
    "                    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#make sure page is scrolled to top\n",
    "def screenshot(with_cache=True):    #\n",
    "    #img, ax = plt.subplots(ncols=3)\n",
    "    \n",
    "    board = pyautogui.screenshot(region=(128, 160, 248, 480))\n",
    "    board = np.array(board)\n",
    "\n",
    "    if with_cache:\n",
    "        cache = pyautogui.screenshot(region=(25, 160, 96, 96))\n",
    "        cache = np.array(cache)\n",
    "\n",
    "    queue = pyautogui.screenshot(region=(400, 160, 96, 360))\n",
    "    queue = np.array(queue)\n",
    "    \n",
    "\n",
    "   # plt.imshow(board)\n",
    "#     ax[0].imshow(board)\n",
    "#     ax[1].imshow(cache)\n",
    "#     ax[2].imshow(queue)\n",
    "    \n",
    "    if with_cache:\n",
    "        cache = cache[12::24, 12::24]\n",
    "    board, queue = board[12::24, 12::24], queue[12::24, 12::24]\n",
    "\n",
    "    #plt.imshow(queue)\n",
    "    #print(cache)\n",
    "    \n",
    "    #plt.imshow(queue)\n",
    "    \n",
    "    if with_cache:\n",
    "        cache = np.max(colors_to_blocks(cache))\n",
    "    \n",
    "    board = colors_to_binary(board).astype(np.int)\n",
    "    \n",
    "    queue = colors_to_blocks(queue).astype(np.int)\n",
    "    queue = [np.max(queue[0:3, 1:-1]),\n",
    "                    np.max(queue[3:6, 1:-1]),\n",
    "                    np.max(queue[6:9, 1:-1]),\n",
    "                    np.max(queue[9:12, 1:-1]),\n",
    "                    np.max(queue[12:15, 1:-1])]\n",
    "    if with_cache:\n",
    "        return cache, board[3:], queue\n",
    "    else:\n",
    "        return board[3:], queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "board, queue = screenshot(with_cache=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "protpos=dict()\n",
    "protpos[('T',0)]=((1,0),(0, 1),(1,1),(1,2))\n",
    "protpos[('T',3)]=((2,1),(1,0),(1,1),(0,1))\n",
    "protpos[('T',2)]=((1,1),(0,0),(0,1),(0,2))\n",
    "protpos[('T',1)]=((2,0),(1,0),(0,0),(1,1))\n",
    "\n",
    "\n",
    "protpos[('I',0)]=((0,0),(0,1),(0,2),(0,3))\n",
    "protpos[('I',1)]=((3,0),(1,0),(2,0),(0,0))\n",
    "\n",
    "protpos[('O',0)]=((1,0),(0,0),(0,1),(1,1))\n",
    "\n",
    "\n",
    "protpos[('S',0)]=((1,0),(0,1),(1,1),(0,2))\n",
    "protpos[('S',1)]=((2,1),(1,0),(1,1),(0,0))\n",
    "\n",
    "protpos[('Z',0)]=((1,1),(0,0),(0,1),(1,2))\n",
    "protpos[('Z',1)]=((2,0),(1,0),(0,1),(1,1))\n",
    "\n",
    "\n",
    "protpos[('J',0)]=((1,0),(0,0),(1,1),(1,2))\n",
    "protpos[('J',3)]=((2,0),(0,1),(1,1),(2,1))\n",
    "protpos[('J',2)]=((0,0),(0,1),(0,2),(1,2))\n",
    "protpos[('J',1)]=((2,0),(1,0),(0,0),(0,1))\n",
    "\n",
    "protpos[('L',0)]=((1,0),(0,2),(1,1),(1,2))\n",
    "protpos[('L',3)]=((2,1),(0,0),(1,1),(0,1))\n",
    "protpos[('L',2)]=((0,0),(0,1),(0,2),(1,0))\n",
    "protpos[('L',1)]=((2,0),(1,0),(0,0),(2,1))\n",
    "\n",
    "poff=dict()\n",
    "\n",
    "poff[('T',0)]=(3,4)\n",
    "poff[('T',1)]=(4,5)\n",
    "poff[('T',2)]=(3,4)\n",
    "poff[('T',3)]=(3,4)\n",
    "\n",
    "poff[('I',0)]=(3,3)\n",
    "poff[('I',1)]=(5,5)\n",
    "\n",
    "poff[('O',0)]=(4,4)\n",
    "\n",
    "\n",
    "poff[('S',0)]=(3,4)\n",
    "poff[('S',1)]=(4,5)\n",
    "\n",
    "poff[('Z',0)]=(3,4)\n",
    "poff[('Z',1)]=(4,5)\n",
    "\n",
    "\n",
    "poff[('J',0)]=(3,4)\n",
    "poff[('J',1)]=(4,5)\n",
    "poff[('J',2)]=(3,4)\n",
    "poff[('J',3)]=(3,4)\n",
    "\n",
    "poff[('L',0)]=(3,4)\n",
    "poff[('L',1)]=(4,5)\n",
    "poff[('L',2)]=(3,4)\n",
    "poff[('L',3)]=(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pynput.keyboard import Key, Controller\n",
    "keyboard = Controller()\n",
    "from numba import njit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "@njit\n",
    "def update_heights(fake_mat, block, drop_dist, drop_col):\n",
    "    fake_copy = fake_mat.copy()\n",
    "    for square in block:\n",
    "        if square[1] + drop_col < 10:\n",
    "            fake_copy[int(square[0] + drop_dist) - 1, int(square[1] + drop_col)] = 1\n",
    "                \n",
    "    return np.sum(fake_copy, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "@njit\n",
    "def fake_from_heights(heights):\n",
    "    retmat = np.ones((20, 10))\n",
    "    for i, col in enumerate(heights):\n",
    "        #print(i, col)\n",
    "        retmat[:, i] = np.zeros(20)\n",
    "        retmat[:int(col), i] = 1\n",
    "    \n",
    "    return retmat[::-1,:]\n",
    "\n",
    "def calc_score(block_name, col_heights):\n",
    "    num_orientations = 4\n",
    "    if block_name == 'I' or block_name == 'S' or block_name == 'Z':\n",
    "        num_orientations = 2\n",
    "    elif block_name == 'O':\n",
    "        num_orientations = 1\n",
    "      \n",
    "                \n",
    "    fake_mat = fake_from_heights(col_heights)\n",
    "    \n",
    "    scores = np.empty((num_orientations, 10))\n",
    "    drop_dists = np.empty((num_orientations, 10))\n",
    "    \n",
    "    for pos_col in range(10):\n",
    "        #print(pos_col)\n",
    "        for orientation in range(num_orientations):\n",
    "            new_col_heights = col_heights.copy()\n",
    "            block = protpos[(block_name, orientation)]\n",
    "            \n",
    "            num_holes = 0\n",
    "            drop_dist = 0\n",
    "\n",
    "            col_mins = dict()\n",
    "\n",
    "\n",
    "            for square in block:\n",
    "                tsquare = (square[0], square[1] + pos_col)\n",
    "                if tsquare[1] < 10:\n",
    "                    square_max_drop = (20 - tsquare[0]) - col_heights[tsquare[1]]\n",
    "                    #print(square_max_drop, square[0], square[1])\n",
    "            \n",
    "                    if tsquare[1] in col_mins:\n",
    "                        if square_max_drop < col_mins[tsquare[1]]:\n",
    "                            col_mins[tsquare[1]] = square_max_drop\n",
    "                    else:\n",
    "                        col_mins[tsquare[1]] = square_max_drop\n",
    "                else:\n",
    "                    col_mins[tsquare[1]] = -1\n",
    "\n",
    "\n",
    "            #print(col_mins)\n",
    "            #print(\"----------\")\n",
    "\n",
    "            drop_dist = min(list(col_mins.values()))\n",
    "\n",
    "            drop_dists[orientation, pos_col] = drop_dist\n",
    "\n",
    "            fake_copy = fake_mat.copy()\n",
    "\n",
    "            for square in block:\n",
    "                if square[1] + pos_col < 10:\n",
    "                    fake_copy[int(square[0] + drop_dist) - 1, int(square[1] + pos_col)] = 1\n",
    "\n",
    "            new_col_heights = np.sum(fake_copy, axis=0)\n",
    "\n",
    "            curr_holes = 0\n",
    "\n",
    "            for item in col_mins.values():\n",
    "                if item > drop_dist:\n",
    "                    curr_holes += abs(item - drop_dist)\n",
    "\n",
    "            num_holes += curr_holes\n",
    "\n",
    "            prev_distr = np.max(col_heights) - np.min(col_heights)\n",
    "\n",
    "\n",
    "            distr = np.max(new_col_heights) - np.min(new_col_heights)\n",
    "\n",
    "            distr_diff = distr - prev_distr\n",
    "\n",
    "            hole_fac = num_holes * 11\n",
    "            if hole_fac > 12:\n",
    "                hole_fac = 12\n",
    "\n",
    "\n",
    "            score = (drop_dist/1.6) - hole_fac - distr_diff\n",
    "\n",
    "#                 if not (block_name != 'I' and distr_diff > 1):\n",
    "#                     score -= distr_diff\n",
    "\n",
    "            if num_holes == 0:\n",
    "                score += 5\n",
    "\n",
    "            max_h_diff = np.max(new_col_heights) - np.max(col_heights)\n",
    "            if max_h_diff > 2 and block_name != 'I':\n",
    "                score -= 2 * (max_h_diff - 1)\n",
    "\n",
    "            if max_h_diff < 3 and num_holes == 0 and orientation == 1 and block_name == 'I':\n",
    "                score += 15\n",
    "\n",
    "            if block_name == 'I' and orientation == 0:\n",
    "                score -= 5\n",
    "            \n",
    "\n",
    "#             if pos_col >= 7 and block_name != 'I':\n",
    "#                 score -= 2 * pos_col - 6\n",
    "            if block_name != 'I':\n",
    "                for square in block:\n",
    "                    if square[1] == 9:\n",
    "                        score -= 10\n",
    "\n",
    "            elif distr > 4:\n",
    "                score -= distr\n",
    "\n",
    "\n",
    "\n",
    "            prev_height = 25\n",
    "            for col_height in new_col_heights:\n",
    "                if col_height == prev_height and block_name != 'I':\n",
    "                    score += 2\n",
    "                elif abs(col_height - prev_height) > 3:\n",
    "                    score -= abs(col_height - prev_height) * 1.2\n",
    "                if col_height > 10:\n",
    "                    score -= 2 * (col_height - 10)**3\n",
    "                prev_height = col_height\n",
    "            #print(col_heights, block_name, orientation, pos_col, drop_dist, num_holes, score)\n",
    "            scores[orientation, pos_col] = score\n",
    "\n",
    "\n",
    "    argmax = np.argmax(scores)\n",
    "    drop_orientation = int(argmax // 10)\n",
    "    drop_col = int(argmax % 10)\n",
    "        \n",
    "    block = protpos[(block_name, drop_orientation)]\n",
    "    \n",
    "    height_diffs = dict()\n",
    "             \n",
    "    new_col_heights = update_heights(fake_mat, block, drop_dists[drop_orientation, drop_col], drop_col)\n",
    "\n",
    "#     print(max_y)\n",
    "#     print(height_diffs)\n",
    "\n",
    "#     print(height_diffs)\n",
    "#     print(\"----\")\n",
    "#     print(col_heights)\n",
    "#     print(block_name, drop_orientation, drop_col)\n",
    "#     print(new_col_heights)\n",
    "#     print('-------')\n",
    "    \n",
    "    return scores[drop_orientation, drop_col], drop_orientation, drop_col, new_col_heights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-41-6a17914929d4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     32\u001b[0m                 \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 34\u001b[0;31m     \u001b[0mblock_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnum_to_shape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcurrent_block\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     35\u001b[0m     \u001b[0;31m#print(block_name)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     36\u001b[0m     \u001b[0;31m#print(col_heights)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "time.sleep(3)\n",
    "\n",
    "\n",
    "keyboard.press(Key.f4)\n",
    "keyboard.release(Key.f4)\n",
    "\n",
    "# sum the columns to get max drop distance\n",
    "# if drop distance is more for one piece than for others, a hole will form\n",
    "\n",
    "cache, board, queue = screenshot()\n",
    "current_block = queue[1]\n",
    "cache = queue[0]\n",
    "\n",
    "keydel = 0.0325\n",
    "\n",
    "\n",
    "time.sleep(1.5)\n",
    "keyboard.press('c')\n",
    "keyboard.press('c')\n",
    "time.sleep(keydel)\n",
    "\n",
    "col_heights = np.zeros(10)\n",
    "\n",
    "for frame in range(50_000):\n",
    "    board, queue = screenshot(with_cache = False)\n",
    "      \n",
    "    col_heights = np.zeros(10)\n",
    "    for col in range(10):\n",
    "        for row in range(len(board)):\n",
    "            if board[row, col] != 0:\n",
    "                col_heights[col] = 17 - row\n",
    "                break\n",
    "    \n",
    "    block_name = num_to_shape[current_block]\n",
    "    #print(block_name)\n",
    "    #print(col_heights)\n",
    "    \n",
    "    score, drop_orientation, drop_col, ncol_heights = calc_score(block_name, col_heights)\n",
    "    \n",
    "    \n",
    " \n",
    "    if frame != 0:\n",
    "        cache_score, cdrop_orientation, cdrop_col, cncol_heights = calc_score(num_to_shape[cache], col_heights)\n",
    "        #print(cache_score, score)\n",
    "        if cache_score > score:\n",
    "            drop_orientation = cdrop_orientation\n",
    "            drop_col = cdrop_col\n",
    "            block_name = num_to_shape[cache]\n",
    "            \n",
    "            time.sleep(keydel)\n",
    "            keyboard.press('c')\n",
    "            keyboard.release('c')\n",
    "            cache = int(current_block)\n",
    "            time.sleep(keydel)\n",
    "            ncol_heights = cncol_heights\n",
    "    \n",
    "        #print(score, cache_score)\n",
    "    \n",
    "#     col_heights = ncol_heights\n",
    "#     print(col_heights)\n",
    "\n",
    "    \n",
    "\n",
    "    if drop_orientation == 3:\n",
    "        keyboard.press('z')\n",
    "        keyboard.release('z')\n",
    "    else:\n",
    "        for i in range(drop_orientation):\n",
    "            keyboard.press(Key.up)\n",
    "            keyboard.release(Key.up)\n",
    "    time.sleep(keydel)\n",
    "    \n",
    "    offset = poff[(block_name, drop_orientation)][0] - drop_col\n",
    "\n",
    "    \n",
    "    if offset > 0: \n",
    "        for i in range(offset):\n",
    "            keyboard.press(Key.left)\n",
    "            keyboard.release(Key.left)\n",
    "            time.sleep(keydel)\n",
    "    elif offset < 0:\n",
    "         for i in range(abs (offset)):\n",
    "            keyboard.press(Key.right)\n",
    "            keyboard.release(Key.right)\n",
    "            time.sleep(keydel)\n",
    "     \n",
    "    \n",
    "    keyboard.press(Key.space)\n",
    "    keyboard.release(Key.space)\n",
    "    time.sleep(0.01)\n",
    "    \n",
    "    \n",
    "    current_block = queue[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:.conda-tetrisbot] *",
   "language": "python",
   "name": "conda-env-.conda-tetrisbot-py"
  },
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}