335_bitboard-4connect.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bitboard für 4-Connect\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Board\n",
    "\n",
    "Ein *board* ist ein 6x7 numpy-Array mit den Werten:\n",
    "```\n",
    "0 - frei\n",
    "1 - Spieler 1\n",
    "2 - Spieler 2\n",
    "\n",
    "```\n",
    " \n",
    "\n",
    "Funktionen zum Erstellen und Füllen eines boards:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def makeBoard():\n",
    "    return np.zeros((6, 7), dtype = int)\n",
    "\n",
    "def showBoard(board):\n",
    "    for i in range(6):\n",
    "        print(*row(i,board))\n",
    "    print('==============')\n",
    "    print('0 1 2 3 4 5 6 ')\n",
    "    print()\n",
    "    \n",
    "def row(i, board):\n",
    "    return board[i,:]\n",
    "\n",
    "def col(j, board):\n",
    "    return board[:,j]\n",
    "\n",
    "    \n",
    "def insert(j, x, board):\n",
    "    ''' insert in col j value x as in connect 4'''\n",
    "    coltmp = np.argwhere(col(j,board)==0)  # \n",
    "    if len(coltmp) == 0: return False\n",
    "    board[coltmp[-1],j] = x\n",
    "    return True\n",
    "\n",
    "def fill(j, s, board):\n",
    "    ''' fill col j with values of s \n",
    "    eg. s = '1122' : 2 is at the bottom of col j '''\n",
    "    for c in list(s)[::-1]:\n",
    "        insert(j,int(c),board)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0 0 0 0 0\n",
      "0 0 0 1 0 0 0\n",
      "0 0 2 2 0 0 0\n",
      "0 0 1 2 0 0 0\n",
      "0 0 1 1 2 0 0\n",
      "0 0 1 2 2 2 0\n",
      "==============\n",
      "0 1 2 3 4 5 6 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "board = makeBoard()\n",
    "fill(2,'2111', board)\n",
    "fill(3,'12212', board)\n",
    "fill(4,'22', board)\n",
    "fill(5,'2', board)\n",
    "showBoard(board)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bitboard, Boardzahl und Bitstring\n",
    "\n",
    "Einem Board ordnen wir zwei Bitboards zu, die die Positionen der Steine jedes Spielers zeigen. \n",
    "Ein Bitboard ist eine 7x7 Matrix. Die erste Reihe ist eine Sentinel-Reihe (Wächter), die immer mit 0 gefüllt ist.\n",
    "\n",
    "0 ist das *least significant bit*, d.h. das am weitesten rechts stehende Bit. Die Positionen der Bits in der Matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6 13 20 27 34 41 48]\n",
      "----------------------\n",
      "[ 5 12 19 26 33 40 47]\n",
      "[ 4 11 18 25 32 39 46]\n",
      "[ 3 10 17 24 31 38 45]\n",
      "[ 2  9 16 23 30 37 44]\n",
      "[ 1  8 15 22 29 36 43]\n",
      "[ 0  7 14 21 28 35 42]\n"
     ]
    }
   ],
   "source": [
    "bd = np.zeros((7, 7), dtype = int)\n",
    "\n",
    "for j in range(7):\n",
    "    for i in range(6,-1,-1):\n",
    "        bd[i,j] = 6-i + 7 *j\n",
    "\n",
    "for i in range(7):\n",
    "    print(row(i,bd))\n",
    "    if i == 0:\n",
    "        print('----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das Bitboard wird nicht in einer Matrix gespeichert, sondern in einem *bitString*. Dieser Bitstring ergibt sich aus der Dualzahldarstellung einer Zahl. Diese Zahl nennen wir die boardZahl. Die Funktion *boardzahl* gibt neben der boardzahl für den Spieler *player* auch die Zahl\n",
    "für die bitboard-Maske zurück. Die ist an allen Stellen 1, an denen ein Stein gesetzt wurde. Damit kann man das Bitboard des anderen\n",
    "Spielers berechnen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def boardzahl(board, player):\n",
    "    ''' returns int : zahl, die im bin-format das board repräsentiert'''\n",
    "    bs, mask = '', ''\n",
    "    # Start with right-most column\n",
    "    for j in range(6, -1, -1):\n",
    "        # Add 0-bits to sentinel \n",
    "        mask += '0'\n",
    "        bs += '0'\n",
    "        # Start with bottom row\n",
    "        for i in range(0, 6):\n",
    "            mask += ['0', '1'][int(board[i, j] != 0)]\n",
    "            bs += ['0', '1'][int(board[i, j] == player)]\n",
    "    return int(bs, 2), int(mask, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(37863424, 35192438784)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bz1, mask = boardzahl(board , 1)\n",
    "bz2 = bz1 ^ mask  \n",
    "bz1, bz2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0 0 0 0 0\n",
      "0 0 0 1 0 0 0\n",
      "0 0 2 2 0 0 0\n",
      "0 0 1 2 0 0 0\n",
      "0 0 1 1 2 0 0\n",
      "0 0 1 2 2 1 0\n",
      "==============\n",
      "0 1 2 3 4 5 6 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "board = makeBoard()\n",
    "fill(2,'2111', board)\n",
    "fill(3,'12212', board)\n",
    "fill(4,'22', board)\n",
    "fill(5,'1', board)\n",
    "showBoard(board)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir betrachten den Bitstring, der durch die beiden Bitzahlen repräsentiert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bitboard(bz):\n",
    "    bs = bitstr(bz)\n",
    "    i, j = 6, 0\n",
    "    board = np.zeros((7, 7), dtype = int)\n",
    "    for c in bs[::-1]:\n",
    "        board[i,j] = int(c)\n",
    "        i-=1\n",
    "        if i == -1:\n",
    "            j += 1\n",
    "            i = 6 \n",
    "    print()\n",
    "    for i in range(7):\n",
    "        print(*row(i,board))\n",
    "        if i == 0:\n",
    "            print('-'*13)\n",
    "    print('=============')\n",
    "    print('0 1 2 3 4 5 6')\n",
    "\n",
    "def bitstr(bz):\n",
    "    bitstr = bin(bz)[2:]\n",
    "    return bitstr.rjust(49,'0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('0000000000000000000000010010000011100000000000000',\n",
       " '0000000000000100000110001101000100000000000000000')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bitstr(bz1), bitstr(bz2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aus den Bitstrings können wir das Bitboard konstruieren. Das Spiel-Board und die beiden Bitboards zusammen gesehen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0 0 0 0 0\n",
      "0 0 0 1 0 0 0\n",
      "0 0 2 2 0 0 0\n",
      "0 0 1 2 0 0 0\n",
      "0 0 1 1 2 0 0\n",
      "0 0 1 2 2 2 0\n",
      "==============\n",
      "0 1 2 3 4 5 6 \n",
      "\n",
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 1 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n",
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "0 0 0 1 0 0 0\n",
      "0 0 0 0 1 0 0\n",
      "0 0 0 1 1 1 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "showBoard(board)\n",
    "bitboard(bz1)\n",
    "bitboard(bz2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check auf Vierer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion entdeckt, ob vier Positionen verbunden sind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check4(bz):\n",
    "    '''  bn: bitnummer '''\n",
    "    # Horizontal  \n",
    "    m = bz & (bz >> 7)\n",
    "    if m & (m >> 14):\n",
    "        return True\n",
    "    # Diagonal \\\n",
    "    m = bz & (bz >> 6)\n",
    "    if m & (m >> 12):\n",
    "        return True\n",
    "    # Diagonal /\n",
    "    m = bz & (bz >> 8)\n",
    "    if m & (m >> 16):\n",
    "        return True\n",
    "    # Vertical\n",
    "    m = bz & (bz >> 1)\n",
    "    if m & (m >> 2):\n",
    "        return True\n",
    "    # Nothing found\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check4(bz1), check4(bz2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Erläuterung des horizontalen Checks\n",
    "\n",
    "Das folgende Board dient zur Demonstration, es ist keinen gültige Spielstellung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 1 1 1 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "board = makeBoard()\n",
    "board[2] = np.array([0,0,1,1,1,1,0])    \n",
    "\n",
    "bz = boardzahl(board,1)[0]\n",
    "bitboard(bz)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir schieben die Bits in *bz* um 7 Stellen nach rechts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0000000000100000010000001000000100000000000000000\n",
      "0000000000000000010000001000000100000010000000000\n"
     ]
    }
   ],
   "source": [
    "bz1 = bz >> 7\n",
    "print(bitstr(bz))\n",
    "print(bitstr(bz1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das bedeutet, dass die Bits im Board um eine Stelle nach links verschoben wurden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 1 1 1 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n",
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 1 1 1 1 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "bitboard(bz)\n",
    "bitboard(bz1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit der *&*-Verbindung prüfen wir, ob an einer Stelle dasselbe steht, wie an der Stelle rechts daneben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 1 1 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n",
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "1 1 1 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "bitboard(m)\n",
    "bitboard(m >> 14)\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dieses Bitboard können wir wie folgt interpretieren: Dort wo eine 1 steht, steht im ursprünglichen bitboard rechts daneben auch eine 1.\n",
    "\n",
    "Die beiden äußeren 1er verraten dass, ein 4er gefunden wurde. Die linke 1 sagt, hier steht eine 1 und rechts daneben auch. die rechte 1 sagt: hier steht eine 1 und rechts daneben auch. Von der linken 1 aus gesehen sind das vier 1en. \n",
    "\n",
    "Wir überprüfen, ob wir eine 1 und in der übernächsten Position wieder eine 1 haben, indem wir um 14 Stellen nach rechts verschieben und\n",
    "wieder die *&*-Verbindung bilden. Wenn die resultierende boardzahl nicht gleich 0 ist, ist ein Vierer vorhanden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bitboard(m & m >> 14)\n",
    "bool(m & m >> 14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Erläuterung des vertikalen Checks\n",
    "\n",
    "Für den vertikalen Check benötigen wir die Sentinel-Reihe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Spielzug\n",
    "\n",
    "In der Funktion *move* ist *bz* die Bitzahl des Spielers, der gerade dran ist. *bz1* ist dann die Bitzahl des anderen Spielers, die\n",
    "unverändert zurückgegeben wird, da dieser Spieler das nächste mal dran ist und seine Steine sich in diesem Zug nicht verändern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def move(bz, mask, col):\n",
    "    bz1 = bz ^ mask\n",
    "    mask1 = mask | (mask + (1 << (col*7)))\n",
    "    return bz1, mask1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 2 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 2 0 0 0\n",
      "==============\n",
      "0 1 2 3 4 5 6 \n",
      "\n",
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n",
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 1 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n",
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "board = makeBoard()\n",
    "fill(2,'211', board)\n",
    "fill(3,'2', board)\n",
    "\n",
    "showBoard(board)\n",
    "bz, mask = boardzahl(board,1) \n",
    "bitboard(bz)\n",
    "\n",
    "bz_neu, mask_neu = move(bz,mask,2)\n",
    "bitboard(bz_neu)\n",
    "bitboard(mask_neu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Erläuterung zur neuen Maske"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "bitboard(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "1 0 0 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n",
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "col = 2\n",
    "bitboard(1)\n",
    "bitboard(1 << (col*7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 1 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "bitboard(mask + (1 << (col*7)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 0 0 0 0 0 0\n",
      "-------------\n",
      "0 0 0 0 0 0 0\n",
      "0 0 0 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 0 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "bitboard(mask | mask + (1 << (col*7)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Überfüllen des Boards \n",
    "ist noch nicht abgefangen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 0 1 0 0 0 0\n",
      "-------------\n",
      "0 0 1 1 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "0 0 1 1 0 0 0\n",
      "=============\n",
      "0 1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "board = makeBoard()\n",
    "fill(2,'211', board)\n",
    "fill(3,'2', board)\n",
    "bz,mask = move(bz,mask,2)\n",
    "bz,mask = move(bz,mask,2)\n",
    "bz,mask = move(bz,mask,2)\n",
    "bz,mask = move(bz,mask,2)\n",
    "bitboard(mask)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}