Game.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import copy\n",
    "import pandas as pd\n",
    "from random import randint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Square(object):\n",
    "    \"\"\"\n",
    "    Represents one square of an othello board.\n",
    " \n",
    "    Instance variables:\n",
    "        value - If a disk is placed, its value - 0 or 1 if it's black or white, else None\n",
    "        is_valid_move - boolean if the current player can play here\n",
    "        flipped_disks - if the current player plays here,\n",
    "                        which disks will flip to their color\n",
    "    \"\"\"\n",
    "    def __init__(self, value=None):\n",
    "        \"\"\"\n",
    "        Initialize Square.\n",
    " \n",
    "        Optional arguments:\n",
    "            value - current value of square, default None\n",
    "        \"\"\"\n",
    "        self._value = value\n",
    "        self.is_valid_move = False\n",
    "        self.flipped_disks = []\n",
    " \n",
    "    @property\n",
    "    def value(self):\n",
    "        return self._value\n",
    " \n",
    "    @value.setter\n",
    "    def value(self, value):\n",
    "        self._value = value\n",
    "        self.is_valid_move = False\n",
    "        self.flipped_disks = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Board(object):\n",
    "    \"\"\"\n",
    "    8 x 8 game board which can be displayed and interacted with.\n",
    " \n",
    "    Instance variables:\n",
    "        board_state - an 8 x 8 numpy array of Square objects\n",
    "        game_over - boolean: True if the game has ended\n",
    "        current_player - 0/1: the player whose move it is\n",
    "        p0_score - number of discs player 0 controls\n",
    "        p1_score - number of discs player 1 controls\n",
    "        verbose - boolean: print output on moves\n",
    " \n",
    "    Methods:\n",
    "        update_valid_moves - calculate valid moves for the current player\n",
    "        get_valid_moves - return valid moves and flipped disks\n",
    "        print_board - display board state in a human-readable format\n",
    "        translate_move - return a coordinate move, (x, y) in\n",
    "                         human-readable format\n",
    "        human_move - given human-readable input (e.g. 'A4'), make move\n",
    "        coord_move - given tuple (x, y), make move\n",
    "    \"\"\"\n",
    "    _human_readable_dict = dict(enumerate('ABCDEFGH'))\n",
    "    _computer_readable_dict = dict([(v, k) for k, v in enumerate('ABCDEFGH')])\n",
    "    _print_row = '%s %s %s %s %s %s %s %s'.encode('utf-8')\n",
    " \n",
    "    def __init__(self, board_state=None, verbose=True):\n",
    "        \"\"\"\n",
    "        Initialize Board object.\n",
    " \n",
    "        Optional arguments:\n",
    "            board_state - an 8 x 8 numpy array of Square objects\n",
    "                          default: starting board\n",
    "            verbose - print output; default True\n",
    "        \"\"\"\n",
    "        self._current_player = 0\n",
    "        self.verbose = verbose\n",
    "        if board_state is None:\n",
    "            start = np.array([[Square(1), Square(0)], [Square(0), Square(1)]])\n",
    "            self.board_state = np.array([\n",
    "                [Square() for _ in range(8)] for _ in range(8)])\n",
    "            self.board_state[3:5, 3:5] = start\n",
    "        else:\n",
    "            self.board_state = board_state\n",
    "        self.update_valid_moves()\n",
    "        self.game_over = False\n",
    "        self._score()\n",
    "        vals = np.array([[r.value for r in row] for row in self.board_state])\n",
    "        self.p0_score = len(np.where(vals == 0)[0])\n",
    "        self.p1_score = len(np.where(vals == 1)[0])\n",
    "        self._xstr = np.vectorize(self._xstr)\n",
    "        if self.verbose is True:\n",
    "            self.print_board()\n",
    " \n",
    "    @property\n",
    "    def current_player(self):\n",
    "        return self._current_player\n",
    " \n",
    "    @current_player.setter\n",
    "    def current_player(self, value):\n",
    "        if value not in [0, 1]:\n",
    "            raise ValueError('Player can only be 0 or 1.')\n",
    "        self._current_player = value\n",
    "        self.update_valid_moves()\n",
    "        \n",
    "    def get_board_state(self):\n",
    "        return self.board_state\n",
    "    \n",
    "    def get_board_state_array(self):\n",
    "        state=[]\n",
    "        for row in self.board_state:\n",
    "            for square in row:\n",
    "                state.append(square.value)\n",
    "        return np.array(state)\n",
    "    \n",
    "    def get_game_over(self):\n",
    "        return self.game_over\n",
    "    \n",
    "    def get_black_score(self):\n",
    "        return self.p0_score\n",
    "    \n",
    "    def get_white_score(self):\n",
    "        return self.p1_score\n",
    "        \n",
    "    def get_valid_moves(self):\n",
    "        \"\"\"\n",
    "        Return all valid moves and accompanying flipped disks.\n",
    " \n",
    "        Returns:\n",
    "            vms - a list of tuples where\n",
    "                tuple[0] is a valid move and\n",
    "                tuple[1] is a list of flipped disks\n",
    "        \"\"\"\n",
    "        flipped_disks = np.array([\n",
    "            [r.flipped_disks for r in row] for row in self.board_state])\n",
    "        valid_moves = [tuple(r) for r in np.argwhere(flipped_disks)]\n",
    "        flipped_moves = list(flipped_disks[np.where(flipped_disks)])\n",
    "        return zip(valid_moves, flipped_moves)\n",
    "    \n",
    "    def _valid_moves_in_array(self, array):\n",
    "        \"\"\"\n",
    "        Given a 1-D array, find valid moves and disks flipped.\n",
    " \n",
    "        Called by update_valid_moves()\n",
    " \n",
    "        Arguments:\n",
    "            array - a 1-D numpy array\n",
    " \n",
    "        Returns:\n",
    "            valid_moves - list of tuples:\n",
    "                tuple[0] is index of valid move\n",
    "                tuple[1] is list of indices of flipped disks\n",
    "        \"\"\"\n",
    "        valid_moves = []\n",
    "        # If array doesn't have both 0 and 1, there are no valid moves.\n",
    "        if not ((array == 0).any() and (array == 1).any()):\n",
    "            return valid_moves\n",
    "        opponent = 1 - self._current_player\n",
    "        pos_list = np.where(array == self._current_player)[0]\n",
    " \n",
    "        for pos in pos_list:\n",
    "            i = pos - 1\n",
    "            flipped_disks = []\n",
    "            if i >= 0 and array[i] == opponent:\n",
    "                flipped_disks += [i]\n",
    "                i -= 1\n",
    "                while i >= 0 and array[i] == opponent:\n",
    "                    flipped_disks += [i]\n",
    "                    i -= 1\n",
    "                if i >= 0 and array[i] is None:\n",
    "                    valid_moves += [(i, flipped_disks)]\n",
    " \n",
    "            i = pos + 1\n",
    "            flipped_disks = []\n",
    "            if i < len(array) and array[i] == opponent:\n",
    "                flipped_disks += [i]\n",
    "                i += 1\n",
    "                while i < len(array) and array[i] == opponent:\n",
    "                    flipped_disks += [i]\n",
    "                    i += 1\n",
    "                if i < len(array) and array[i] is None:\n",
    "                    valid_moves += [(i, flipped_disks)]\n",
    "        return valid_moves\n",
    "    \n",
    "    def update_valid_moves(self):\n",
    "        \"\"\"\n",
    "        Update valid moves for the current player, save to board_state.\n",
    "        \"\"\"\n",
    "        # Reset all cells to 'invalid move'\n",
    "        for row in self.board_state:\n",
    "            for cell in row:\n",
    "                cell.is_valid_move = False\n",
    "                cell.flipped_disks = []\n",
    " \n",
    "        # Horizontal\n",
    "        for i, row in enumerate(self.board_state):\n",
    "            array = np.array([cell.value for cell in row])\n",
    "            vms = self._valid_moves_in_array(array)\n",
    "            for index, flipped in vms:\n",
    "                flipped_ids = zip([i]*len(flipped), flipped)\n",
    "                self.board_state[i, index].is_valid_move = True\n",
    "                self.board_state[i, index].flipped_disks += flipped_ids\n",
    " \n",
    "        # Vertical\n",
    "        for i, col in enumerate(self.board_state.T):\n",
    "            array = np.array([cell.value for cell in col])\n",
    "            vms = self._valid_moves_in_array(array)\n",
    "            for index, flipped in vms:\n",
    "                flipped_ids = zip(flipped, [i]*len(flipped))\n",
    "                self.board_state[index, i].is_valid_move = True\n",
    "                self.board_state[index, i].flipped_disks += flipped_ids\n",
    " \n",
    "        # Diagonal NW--SE\n",
    "        for i in range(-7, 8):\n",
    "            array = np.array([\n",
    "                cell.value for cell in self.board_state.diagonal(i)])\n",
    "            vms = self._valid_moves_in_array(array)\n",
    "            for index, flipped in vms:\n",
    "                flipped_ids = [self._diag_coords(i, f, 'NW') for f in flipped]\n",
    "                coords = self._diag_coords(i, index, 'NW')\n",
    "                self.board_state[coords].is_valid_move = True\n",
    "                self.board_state[coords].flipped_disks += flipped_ids\n",
    " \n",
    "        # Diagonal NE--SW\n",
    "        for i in range(-7, 8):\n",
    "            array = np.array([cell.value for cell in np.diag(\n",
    "                np.fliplr(self.board_state), i)])\n",
    "            vms = self._valid_moves_in_array(array)\n",
    "            for index, flipped in vms:\n",
    "                flipped_ids = [self._diag_coords(i, f, 'NE') for f in flipped]\n",
    "                coords = self._diag_coords(i, index, 'NE')\n",
    "                self.board_state[coords].is_valid_move = True\n",
    "                self.board_state[coords].flipped_disks += flipped_ids   \n",
    "                \n",
    "                \n",
    "    def _diag_coords(self, i, index, NW_NE):\n",
    "        \"\"\"\n",
    "        Translate from diagonal indices to array coordinates.\n",
    " \n",
    "        Called by update_valid_moves()\n",
    " \n",
    "        Arguments:\n",
    "            i - i'th slice of matrix\n",
    "            index - index of the diagonal array\n",
    "            NW_NE - can be 'NW' or 'NE'; direction of slice\n",
    " \n",
    "        Returns:\n",
    "            row - index of numpy row\n",
    "            col - index of numpy column\n",
    " \n",
    "        Exceptions Raised:\n",
    "            AssertionError - if NW_NE is neither 'NW' nor 'NE'\n",
    "        \"\"\"\n",
    "        assert NW_NE in ['NW', 'NE'], 'NW_NE must be either \"NW\" or \"NE\"'\n",
    "        if i >= 0:\n",
    "            row = index\n",
    "        else:\n",
    "            row = index - i\n",
    " \n",
    "        if NW_NE == 'NW':\n",
    "            col = row + i\n",
    "        else:\n",
    "            if i > 0:\n",
    "                col = 7 - index - i\n",
    "            else:\n",
    "                col = 7 - index\n",
    "        return row, col\n",
    "    \n",
    "    def print_board(self):\n",
    "        \"\"\"Display board state in a human-readable format.\"\"\"\n",
    "        row_num = 1\n",
    "        for row in self.board_state:\n",
    "            vals = tuple(self._xstr([cell.value for cell in row]))\n",
    "            print (row_num, self._print_row.decode('utf8') % vals)\n",
    "            row_num += 1\n",
    "        print ('  A B C D E F G H')\n",
    " \n",
    "    def _xstr(self, s):\n",
    "        \"\"\"For printing human-readable board: convert None to ' '.\"\"\"\n",
    "        if s is None:\n",
    "            return u'\\u25E6'  # bullet\n",
    "        elif s == 0:\n",
    "            return u'\\u25CF'  # filled circle\n",
    "        elif s == 1:\n",
    "            return u'\\u25CB'  # empty circle\n",
    "        else:\n",
    "            raise ValueError('Invalid value for square.')\n",
    "            \n",
    "    def translate_move(self, move):\n",
    "        \"\"\"\n",
    "        Translate coordinate move (x, y) into human-readable format.\n",
    " \n",
    "        Arguments:\n",
    "            move - an (x, y) tuple\n",
    " \n",
    "        Returns:\n",
    "            a length-2 string e.g. 'A4'\n",
    "        \"\"\"\n",
    "        return self._human_readable_dict[move[1]], move[0]+1\n",
    " \n",
    "    def human_move(self, s):\n",
    "        \"\"\"\n",
    "        Make move on board.\n",
    " \n",
    "        Arguments:\n",
    "            s - Human-readable string of length-2 e.g. 'A4'\n",
    " \n",
    "        Effects:\n",
    "            take move\n",
    "            flip relevent disks\n",
    "            update current_player\n",
    "            update valid moves\n",
    "            print message if player skipped\n",
    "            check if game has ended; print final score if so\n",
    "            print board\n",
    " \n",
    "        Exceptions raised:\n",
    "            AssertionError - if s is incorrect length\n",
    "            RuntimeError - if invalid move provided\n",
    "        \"\"\"\n",
    "        assert len(s) == 2, 's must be 2 characters'\n",
    "        s1, s2 = list(s)\n",
    "        s1 = self._computer_readable_dict[s1]\n",
    "        s2 = int(s2) - 1\n",
    "        self.coord_move((s2, s1))\n",
    " \n",
    "    def coord_move(self, move):\n",
    "        \"\"\"\n",
    "        Make move on board.\n",
    " \n",
    "        Called by human_move()\n",
    " \n",
    "        Arguments:\n",
    "            move - tuple of array coordinates (x, y)\n",
    " \n",
    "        Effects:\n",
    "            take move\n",
    "            flip relevent disks\n",
    "            update current_player\n",
    "            update valid moves\n",
    "            print message if player skipped\n",
    "            check if game has ended; print final score if so\n",
    "            print board\n",
    " \n",
    "        Exceptions raised:\n",
    "            RuntimeError - if invalid move provided\n",
    "        \"\"\"\n",
    "        \n",
    "        cell = self.board_state[move]\n",
    "        if cell.is_valid_move is False:\n",
    "            raise RuntimeError('Invalid move.')\n",
    "        flipped_disks = cell.flipped_disks\n",
    " \n",
    "        self.board_state[move].value = self._current_player\n",
    "        for d in flipped_disks:\n",
    "            self.board_state[d].value = self._current_player\n",
    " \n",
    "        self._current_player = 1 - self._current_player\n",
    "        self.update_valid_moves()\n",
    "        self._score()\n",
    "        if self.verbose:\n",
    "            self.print_board()\n",
    "            \n",
    "    def _score(self):\n",
    "        \"\"\"\n",
    "        Tracks if players have moves and if game has ended\n",
    " \n",
    "        Called by coord_move()\n",
    " \n",
    "        Effects:\n",
    "            update current player scores\n",
    "            if current player has no valid moves, skip player\n",
    "            print 'skipped player' message\n",
    "            update valid moves\n",
    "            if current player has no valid moves\n",
    "                set game_over to True\n",
    "                print 'game over' message\n",
    "                print final scores\n",
    "        \"\"\"\n",
    "        vals = np.array([[r.value for r in row] for row in self.board_state])\n",
    "        self.p0_score = len(np.where(vals == 0)[0])\n",
    "        self.p1_score = len(np.where(vals == 1)[0])\n",
    "        n_moves = len(list(zip(*self.get_valid_moves())))\n",
    "        if n_moves == 0:\n",
    "            self._current_player = 1 - self._current_player\n",
    "            self.update_valid_moves()\n",
    "            n_moves = len(list(zip(*self.get_valid_moves())))\n",
    "            if n_moves == 0:\n",
    "                self.game_over = True\n",
    "                if self.verbose:\n",
    "                    print ('Game over.')\n",
    "                    data='black : {}\\twhite : {}'.format(self.p0_score, self.p1_score)\n",
    "                    print (data.encode())"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}