skullAIV2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Skull AI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The objective here is to make AI/Bots that can play the deception board/tile game: Skull. See this link [LINK] to a video showing how to play and then the flow diagram in the gitrepo showing the decision flow for  a player.\n",
    "\n",
    "ASSUMPTIONS:\n",
    " - Only 4 players in a game\n",
    " - for now, wont pay attention to previous rounds\n",
    " - simple terms (linear)\n",
    " - max bet to place is 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from numpy.random import rand, choice\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from copy import deepcopy\n",
    "from math import log\n",
    "from time import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class skullPlayer:\n",
    "    \"\"\"\n",
    "    The main class that handles all functions and actions that a player themselves would need to take. \n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        \"\"\"\n",
    "        The initialiser of this class.\n",
    "        \"\"\"\n",
    "        self.flowers = 3       #GR          how many flowers the player currently has\n",
    "        self.skull = 1         #GR          how many skulls the player currently has\n",
    "        self.totalTiles = 4    #GR          how many tiles the player has in total\n",
    "        self.inPlay = True     #GR          is the player still in the game \n",
    "        self.hasPoint = False  #GR          does the player have a point already\n",
    "        self.externalHasSkull = True  #GR*  do the other players know for certain that the player has a skull\n",
    "        self.externalHasNoSkull = False #GR do the other player know the player does not have a skull\n",
    "        self.placedTiles = []  #RR          what tiles the player has currently placed\n",
    "        self.hasPassed = False #RR          has the the player passed in this round of betting\n",
    "        self.currentBet = None #RR          the current bet the player has made\n",
    "        self.verbose = False\n",
    "        \n",
    "        self.recPosition = None #GR\n",
    "        self.gameState = None #GR\n",
    "        self.betrec = None #RR*\n",
    "        self.game = None #GR\n",
    "        self.pickRec = None #RR*\n",
    "        \n",
    "        self.age=1\n",
    "        self.winTwo=0\n",
    "        self.winElim=0\n",
    "        \n",
    "        self.theta_tp=(rand(1,30)*2)-1 #AI\n",
    "        self.theta_bp=(rand(1,31)*2)-1 #AI\n",
    "        self.theta_w2b=(rand(12,95)*2-1) #AI\n",
    "        self.theta_bpa=(rand(1,95)*2-1) #AI\n",
    "        self.theta_w2p=(rand(3,93)*2-1) #AI\n",
    "        \n",
    "    def removeTile(self):\n",
    "        \"\"\"\n",
    "        Remove a tile from the players available tile. If there is a choice it will do so randomly.\n",
    "        \"\"\"\n",
    "        if self.inPlay:\n",
    "            if self.skull==0:\n",
    "                self.flowers+=-1\n",
    "            else:\n",
    "                if choice([True]+[False]*self.flowers):\n",
    "                    self.skull+=-1\n",
    "                else:\n",
    "                    self.flowers+=-1\n",
    "\n",
    "            self.totalTiles+=-1\n",
    "            self.externalHasSkull = False\n",
    "\n",
    "            if self.totalTiles==0:\n",
    "                self.inPlay=False\n",
    "                self.gameState.updateFirstPlayer((self.recPosition+1)%4)\n",
    "                self.game.activePlayer = self.recPosition\n",
    "            else:\n",
    "                self.gameState.updateFirstPlayer(self.recPosition)\n",
    "                self.game.activePlayer = (self.recPosition-1)%4\n",
    "            self.game.resetRound()\n",
    "        else:\n",
    "            raise NameError(\"Player is not in play\")\n",
    "                \n",
    "    def placeFlower(self):\n",
    "        \"\"\"\n",
    "        Adds a flower, if available, to the players list of placed tiles\n",
    "        \"\"\"\n",
    "        if self.inPlay & (self.flowers>0):\n",
    "            if (len(self.placedTiles)-sum(self.placedTiles))<self.flowers:\n",
    "                self.placedTiles.append(False)\n",
    "                self.gameState.gatherInfo()\n",
    "            else:\n",
    "                raise NameError('All flowers have been placed')\n",
    "        else:\n",
    "            if not(self.inPlay):\n",
    "                raise NameError(\"Player is not in play\")\n",
    "            else:\n",
    "                raise NameError('No flowers to place')\n",
    "    \n",
    "    def placeSkull(self):\n",
    "        \"\"\"\n",
    "        Adds a skull, if available, to the players list of placed tiles\n",
    "        \"\"\"\n",
    "        if self.inPlay & (self.skull>0):\n",
    "            if any(self.placedTiles):\n",
    "                raise NameError('Skull has been placed')\n",
    "            else:\n",
    "                self.placedTiles.append(True)\n",
    "                self.gameState.gatherInfo()\n",
    "        else:\n",
    "            if not(self.inPlay):\n",
    "                raise NameError(\"Player is not in play\")\n",
    "            else:\n",
    "                raise NameError('No Skull to place')\n",
    "                \n",
    "    def resetRound(self):\n",
    "        \"\"\"\n",
    "        resets the variables within the player that needs to be reset for a new round\n",
    "        \"\"\"\n",
    "        self.placedTiles=[]\n",
    "        self.hasPassed = False\n",
    "        self.currentBet = None\n",
    "        \n",
    "    def resetGame(self):\n",
    "        \"\"\"\n",
    "        resets the variables within the player that needs to be reset for a new game\n",
    "        \"\"\"\n",
    "        self.flowers=3\n",
    "        self.skull=1\n",
    "        self.totalTiles=4\n",
    "        self.inPlay=True\n",
    "        self.hasPoint = False\n",
    "        self.externalHasSkull = True\n",
    "        self.externalHasNoSkull = False\n",
    "        \n",
    "        self.recPosition = None\n",
    "        self.gameState = None\n",
    "        self.game = None\n",
    "        self.betrec = None\n",
    "        self.pickRec = None        \n",
    "        self.verbose = False\n",
    "        \n",
    "        self.resetRound()\n",
    "        \n",
    "    def playerSummary(self):\n",
    "        \"\"\"\n",
    "        prints basic information about the player\n",
    "        \"\"\"\n",
    "        print(\"Flowers: {}\\nSkull: {}\\nPlaced tiles: {}\".format(self.flowers,self.skull, self.placedTiles))\n",
    "        \n",
    "    def placeTile(self):\n",
    "        \"\"\"\n",
    "        Given the player has decided to place a tile go ahead and place a tile. If the choice is available it will make the choice, if not it will place the option that is available to it.\n",
    "        \"\"\"\n",
    "        if self.inPlay & (len(self.placedTiles)<self.totalTiles):\n",
    "            if any(self.placedTiles)|(self.skull==0):\n",
    "                self.placeFlower()\n",
    "            elif ((len(self.placedTiles)-sum(self.placedTiles))==self.flowers):\n",
    "                self.placeSkull()\n",
    "            else:\n",
    "                self.chooseTileToPlace()\n",
    "        else:\n",
    "            if not(self.inPlay):\n",
    "                pass\n",
    "            else:\n",
    "                raise NameError('Max number of tiles placed')\n",
    "            \n",
    "    def chooseTileToPlace(self):\n",
    "        \"\"\"\n",
    "        Based on the information available, given the player has decided to place a tile and has the choice available, decide what tile to place.\n",
    "        \"\"\"\n",
    "        if self.inPlay:\n",
    "            inVec=np.reshape(self.gameState.state,(-1,1))\n",
    "            inVec=np.concatenate((inVec,np.array([[rand()],[1]])))\n",
    "\n",
    "            skull = ((1/(1+np.exp(-np.dot(self.theta_tp,inVec))))>=0.5)[0][0]\n",
    "\n",
    "            if skull:\n",
    "                self.placeSkull()\n",
    "            else:\n",
    "                self.placeFlower()\n",
    "        else:\n",
    "            raise NameError(\"Player is not in play\")\n",
    "            \n",
    "    def betOrPlace(self): \n",
    "        \"\"\"\n",
    "        Based on the information available, decide wether to make a bet or place a tile.\n",
    "        \"\"\"\n",
    "        if self.inPlay:\n",
    "            if len(self.placedTiles)<self.totalTiles:\n",
    "                inVec=np.reshape(self.gameState.state,(-1,1))\n",
    "                inVec=np.concatenate((inVec,np.array([[int(any(self.placedTiles))],[rand()],[1]])))\n",
    "\n",
    "                betOrPlace = ((1/(1+np.exp(-np.dot(self.theta_bp,inVec))))>=0.5)[0][0]\n",
    "\n",
    "                if betOrPlace:\n",
    "                    bet = self.whatToBet()\n",
    "                    if self.verbose:\n",
    "                        print(\"Player bets: {}\".format(bet))\n",
    "                    self.currentBet=bet\n",
    "                    self.betrec.playerbet(self.recPosition,bet)\n",
    "                    self.game.stage+=1\n",
    "                else:\n",
    "                    self.placeTile()\n",
    "                    if self.verbose:\n",
    "                        print(\"Tile placed\")\n",
    "            else:\n",
    "                bet = self.whatToBet()\n",
    "                if self.verbose:\n",
    "                    print(\"Player bets: {}\".format(bet))\n",
    "                self.currentBet=bet\n",
    "                self.betrec.playerbet(self.recPosition,bet)\n",
    "                self.game.stage+=1\n",
    "        else:\n",
    "            pass\n",
    "            \n",
    "            \n",
    "    def whatToBet(self):\n",
    "        \"\"\"\n",
    "        Based on the information available, and given that the player has decided to bet, decide what value to bet.\n",
    "        \"\"\"\n",
    "        if self.inPlay:\n",
    "            inVec=np.concatenate((np.reshape(self.gameState.state,(-1,1)),\n",
    "                                  np.reshape(self.betrec.betRecord,(-1,1)),np.array([[int(any(self.placedTiles))],[rand()],[1]])))\n",
    "            availableBets=np.zeros((1,12))\n",
    "            availableBets[:,0:sum(np.array(self.gameState.state)[:,2])]=1\n",
    "            currentBet=(np.where(self.betrec.betRecord[:,:-1].any(axis=0))[0])\n",
    "            if currentBet.shape[0]==0:\n",
    "                currentBet=0\n",
    "            else:\n",
    "                currentBet=max(currentBet)+1\n",
    "            availableBets[:,0:currentBet]=0\n",
    "            inVec=np.concatenate((inVec,availableBets.T))\n",
    "            bet=np.argmax((1/(1+np.exp(-np.dot(self.theta_w2b,inVec))))*availableBets.T)+1\n",
    "            self.bet=bet\n",
    "            return bet\n",
    "        else:\n",
    "            raise NameError(\"Player is not in play\")\n",
    "    \n",
    "    def betOrPass(self):\n",
    "        \"\"\"\n",
    "        Based on the information available, decide to bet or pass.\n",
    "        \"\"\"\n",
    "        if self.inPlay & (self.game.stage==0) & (self.hasPassed==False):\n",
    "            inVec=np.concatenate((np.reshape(self.gameState.state,(-1,1)),np.reshape(self.betrec.betRecord,(-1,1)),\n",
    "                                  np.array([[int(any(self.placedTiles))],[rand()],[1]])))\n",
    "            availableBets=np.zeros((1,12))\n",
    "            availableBets[:,0:sum(np.array(self.gameState.state)[:,2])]=1\n",
    "            currentBet=(np.where(self.betrec.betRecord.any(axis=0))[0])\n",
    "            if currentBet.shape[0]==0:\n",
    "                currentBet=0\n",
    "            else:\n",
    "                currentBet=max(currentBet)+1\n",
    "            availableBets[:,0:currentBet]=0\n",
    "            if availableBets.any():\n",
    "                inVec=np.concatenate((inVec,availableBets.T))\n",
    "                betOrPass=(1/(1+np.exp(-np.dot(self.theta_bpa,inVec))))>=0.5\n",
    "\n",
    "                if betOrPass:\n",
    "                    bet = self.whatToBet()\n",
    "                    if self.verbose:\n",
    "                        print(\"Player bets: {}\".format(bet))\n",
    "                    self.currentBet=bet\n",
    "                    self.betrec.playerbet(self.recPosition,bet)\n",
    "\n",
    "                else:\n",
    "                    self.hasPassed=True\n",
    "                    if self.verbose:\n",
    "                        print(\"Player passes\")\n",
    "                    self.betrec.playerPass(self.recPosition)\n",
    "                    if self.betrec.switch:\n",
    "                        self.game.stage+=1\n",
    "            else:\n",
    "                self.hasPassed=True\n",
    "                if self.verbose:\n",
    "                    print(\"Player passes\")\n",
    "                self.betrec.playerPass(self.recPosition)\n",
    "                if self.betrec.switch:\n",
    "                        self.game.stage+=1\n",
    "        else:\n",
    "            if not(self.inPlay):\n",
    "                pass\n",
    "            elif not(self.game.stage==0):\n",
    "                raise NameError('Not in the betting stage')\n",
    "            \n",
    "    def takeTurn(self):\n",
    "        \"\"\"\n",
    "        Given the current stage of the game, have the player do their turn\n",
    "        \"\"\"\n",
    "        if self.inPlay & (self.hasPassed==False):\n",
    "            if self.game.stage==-1:\n",
    "                self.betOrPlace()\n",
    "            elif self.game.stage==0:\n",
    "                self.betOrPass()\n",
    "            elif self.game.stage==1:\n",
    "                self.pickRec.setPickRec(self.recPosition)\n",
    "                self.seek()\n",
    "        elif self.verbose:\n",
    "            if self.hasPassed:\n",
    "                print(\"Player {} has passed this round\".format(self.recPosition))\n",
    "            else:\n",
    "                print(\"Player {} is out of the game\".format(self.recPosition))\n",
    "            \n",
    "    def seek(self):\n",
    "        \"\"\"\n",
    "        Engages the seek proceedure if the player has the highest bet of the round\n",
    "        \"\"\"\n",
    "        if self.inPlay & (self.game.stage==1) & (self.hasPassed==False):\n",
    "            if any(self.placedTiles):\n",
    "                if self.verbose:\n",
    "                    print(\"Player {} skulls themself\".format(self.recPosition))\n",
    "                self.removeTile()\n",
    "            else:\n",
    "                toFind = self.currentBet - len(self.placedTiles)\n",
    "                idList = list(range(0,self.recPosition))+list(range(self.recPosition+1,4))\n",
    "                while toFind>0:\n",
    "                    rowId = self.whoToPick()\n",
    "                    pickedPlayer = idList[rowId]\n",
    "                    if self.verbose:\n",
    "                        print(\"picked player {}\".format(pickedPlayer))\n",
    "                    tile = self.pickRec.pickPlayer(pickedPlayer,rowId)\n",
    "                    if tile:\n",
    "                        break\n",
    "                    else:\n",
    "                        toFind+=-1\n",
    "                        if self.verbose:\n",
    "                            print(\"{} flowers left to find\".format(toFind))\n",
    "                if toFind>0:\n",
    "                    if self.verbose:\n",
    "                        print(\"player has been skulled\")\n",
    "                    self.removeTile()\n",
    "                else:\n",
    "                    if self.verbose:\n",
    "                        print(\"player {} has won a point\".format(self.recPosition))\n",
    "                    if self.hasPoint:\n",
    "                        if self.verbose:\n",
    "                            print(\"player {} wins the game with 2 points\".format(self.recPosition))\n",
    "                        self.winTwo+=1\n",
    "                        self.game.winnerFound=True\n",
    "                        self.game.winner=self\n",
    "                    else:\n",
    "                        self.hasPoint=True\n",
    "                        self.game.activePlayer = (self.recPosition-1)%4\n",
    "                        self.gameState.updateFirstPlayer(self.recPosition)\n",
    "                        self.game.resetRound()\n",
    "                        \n",
    "                \n",
    "\n",
    "    def whoToPick(self):\n",
    "        \"\"\"\n",
    "        Based on the information available and the if the player is seeking, decides which player tile to turn over. \n",
    "        \"\"\"\n",
    "        inVec=np.concatenate((np.reshape(self.gameState.state,(-1,1)),np.reshape(self.betrec.betRecord,(-1,1)),\n",
    "                              np.reshape(self.pickRec.pickRecord,(-1,1)),np.array([[1]])))\n",
    "        whoToPick = np.argmax((1/(1+np.exp(-np.dot(self.theta_w2p,inVec))))*np.array(self.pickRec.pickRecord)[:,-1].reshape(3,1))\n",
    "        return whoToPick\n",
    "    \n",
    "    def mutate(self,learningRate=0.0001):\n",
    "        \"\"\"\n",
    "        Perturb the coefficents of the variables used to make the decisions.\n",
    "        :param learningRate: float, the learning rate to control the pertubation.\n",
    "        \"\"\"\n",
    "        self.age+=1\n",
    "        self.theta_tp+=(rand(1,30)*2-1)*learningRate #AI\n",
    "        self.theta_bp+=(rand(1,31)*2-1)*learningRate #AI\n",
    "        self.theta_w2b+=(rand(12,95)*2-1)*learningRate #AI\n",
    "        self.theta_bpa+=(rand(1,95)*2-1)*learningRate #AI\n",
    "        self.theta_w2p+=(rand(3,93)*2-1)*learningRate #AI\n",
    "        \n",
    "    def genSummary(self):\n",
    "        \"\"\"\n",
    "        Print a quick summary of the player with respect to its generation information.\n",
    "        \"\"\"\n",
    "        print(\"Player age: {}\\nPlayer 2 point wins: {}\\nPlayer Elimination wins: {}\".format(self.age,\n",
    "        self.winTwo,\n",
    "        self.winElim))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class skullGame:\n",
    "    \"\"\"\n",
    "    The main class for the game itself\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self,player1,player2,player3,player4,verbose=False):\n",
    "        \"\"\"\n",
    "        The initialiser of this class.\n",
    "        :param player1,player2,player3,player4: skullPlayer, the players participating in this game. \n",
    "        \"\"\"\n",
    "        self.playerArray = [player1,player2,player3,player4]\n",
    "        self.firstPlayerOfRound = random.randint(0,len(self.playerArray)-1)\n",
    "        self.activePlayer=self.firstPlayerOfRound\n",
    "        self.gameState = skullGameState(self.firstPlayerOfRound,*self.playerArray)\n",
    "        self.betRec = skullBetRec(*self.playerArray)                               #RR\n",
    "        self.stage = -1                                                            #RR\n",
    "        self.pickRec = skullPickRec(*self.playerArray)                             #RR\n",
    "        self.verbose = verbose\n",
    "        self.winnerFound=False\n",
    "        self.winner=None\n",
    "        for i in range(0,4):\n",
    "            player = self.playerArray[i]\n",
    "            player.recPosition=i\n",
    "            player.gameState = self.gameState\n",
    "            player.betrec = self.betRec\n",
    "            player.game = self\n",
    "            player.placeTile()\n",
    "            player.pickRec = self.pickRec\n",
    "            player.verbose = self.verbose\n",
    "    \n",
    "    def resetRound(self):\n",
    "        \"\"\"\n",
    "        Will reset the players and the internal information that needs to be reset for a new round\n",
    "        \"\"\"\n",
    "        self.betRec = skullBetRec(*self.playerArray)\n",
    "        self.stage = -1\n",
    "        self.gameState.gatherInfo()\n",
    "        self.pickRec = skullPickRec(*self.playerArray)\n",
    "        for i in range(0,4):\n",
    "            player = self.playerArray[i]\n",
    "            player.betrec = self.betRec #potentially redundant\n",
    "            player.pickRec = self.pickRec\n",
    "            player.resetRound()\n",
    "            \n",
    "        for i in range(0,4):\n",
    "            player = self.playerArray[i]\n",
    "            player.placeTile()\n",
    "        if self.verbose:\n",
    "            display(self.gameState.state)\n",
    "            print(\"\\n\")\n",
    "            \n",
    "    def playGame(self):\n",
    "        \"\"\"\n",
    "        Begins the game and plays it out until a winner is found\n",
    "        \"\"\"\n",
    "        self.activePlayer = self.firstPlayerOfRound\n",
    "        while not(self.winnerFound):\n",
    "            if sum(np.array(self.gameState.state)[:,-1])==3:\n",
    "                winId = np.argmin(np.array(self.gameState.state)[:,-1])\n",
    "                self.winnerFound=True\n",
    "                self.winner=self.playerArray[winId]\n",
    "                self.playerArray[winId].winElim+=1\n",
    "                if self.verbose:\n",
    "                    print(\"player {} wins the game by player elimination\".format(winId))\n",
    "                break\n",
    "            if self.verbose:\n",
    "                print(\"player {}'s turn\".format(self.activePlayer))\n",
    "            self.playerArray[self.activePlayer].takeTurn()\n",
    "            self.activePlayer=(self.activePlayer+1)%4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class skullGameState:\n",
    "    \"\"\"\n",
    "    A class to handle and manage the game state information through the games and the rounds as they are played out. For each player it shall have:\n",
    "        - If they have a point (binary)\n",
    "        - How many tiles they have (numerical)\n",
    "        - How many tiles they have placed (numerical)\n",
    "        - If they have their skull (dual-binary) [1,0] skull, [0,0] unknown, [0,1] no skull \n",
    "        - their place in the turn order (numerical)\n",
    "        - if they're out of the game (binary) [1] out, [0] in\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self,firstPlayer,player1,player2,player3,player4):\n",
    "        \"\"\"\n",
    "        The initialiser of this class.\n",
    "        :param firstPlayer: int, the record id of the player who is first in this current round\n",
    "        :param player1,player2,player3,player4: skullPlayers, that are in the game\n",
    "        \"\"\"\n",
    "        self.playerArray = [player1,player2,player3,player4]\n",
    "        self.firstPlayer = firstPlayer\n",
    "        self.state=[]\n",
    "        self.gatherInfo()\n",
    "        \n",
    "        \n",
    "    def gatherInfo(self):\n",
    "        \"\"\"\n",
    "        Gather all the gatestate information at the point this is activated\n",
    "        \"\"\"\n",
    "        self.state=[]\n",
    "        for i in range(0,4):\n",
    "            player = self.playerArray[i]\n",
    "            self.state.append([int(player.hasPoint),player.totalTiles,len(player.placedTiles),\n",
    "                               int(player.externalHasSkull),int(player.externalHasNoSkull),\n",
    "                               ((i-self.firstPlayer)%4),1-int(player.inPlay)])\n",
    "    \n",
    "    def updateFirstPlayer(self,player):\n",
    "        \"\"\"\n",
    "        Update the internal refference who is the first player\n",
    "        :param player: int, the record id of who is the first player\n",
    "        \"\"\"\n",
    "        self.firstPlayer = player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class skullBetRec:\n",
    "    \"\"\"\n",
    "    A class to store and handle the betting record for a round of the game. For each player it has an indicatior vector for each bet they have made and an additional entry for if the player has passed\n",
    "    \"\"\"\n",
    "    def __init__(self,player1,player2,player3,player4):\n",
    "        \"\"\"\n",
    "        The initialiser of this class.\n",
    "        :param player1,player2,player3,player4: skullPlayer, the players that are in the given game\n",
    "        \"\"\"\n",
    "        self.playerArray = [player1,player2,player3,player4]\n",
    "        self.betRecord=np.zeros((len(self.playerArray),(len(self.playerArray)*3)+1))\n",
    "        self.switch = False\n",
    "        for i in range(0,4):\n",
    "            player = self.playerArray[i]\n",
    "            self.betRecord[i,-1] = (1-int(player.inPlay))\n",
    "            \n",
    "    def playerbet(self,playerId,bet):\n",
    "        \"\"\"\n",
    "        Update the bet record with the bet the given player has just made\n",
    "        :param playerId: int, the id of the player who is making the bet\n",
    "        :param bet: int, the bet the player has actually made\n",
    "        \"\"\"\n",
    "        self.betRecord[playerId,bet-1] = 1\n",
    "    \n",
    "    def playerPass(self,playerId):\n",
    "        \"\"\"\n",
    "        Update the bet record with the given player having just passed\n",
    "        :param playerId: int, the id of the player who is passing\n",
    "        \"\"\"\n",
    "        self.betRecord[playerId,-1] = 1\n",
    "        if sum(self.betRecord[:,-1])==3:\n",
    "            self.switch=True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class skullPickRec:\n",
    "    \"\"\"\n",
    "    A class to store and handle the record of the picking information when a player is seeking their flowers. for it other player it'll have: \n",
    "        - if they have been previously picked\n",
    "        - how many tiles they have remaining\n",
    "        - how many tiles have been selected already from them\n",
    "        - if the player is actually eligible to pick from\n",
    "    \"\"\"\n",
    "    def __init__(self,player1,player2,player3,player4):\n",
    "        \"\"\"\n",
    "        The initialiser of this class.\n",
    "        :param player1,player2,player3,player4: skullPlayer,the players that are in the given game\n",
    "        \"\"\"\n",
    "        self.pickerId=None\n",
    "        self.playerArray = [player1,player2,player3,player4]\n",
    "        self.pickRecord=[]\n",
    "        \n",
    "    def setPickRec(self,pickId):\n",
    "        \"\"\"\n",
    "        Sets the id of the player that is picking and then collects the initial information that is available to the seeker.\n",
    "        :param pickId: int, the id of the player that will be seeking.\n",
    "        \"\"\"\n",
    "        self.pickerId=pickId\n",
    "        for i in range(0,4):\n",
    "            if i==self.pickerId:\n",
    "                continue\n",
    "            else:\n",
    "                player = self.playerArray[i]\n",
    "                self.pickRecord.append([0,len(player.placedTiles),0,int(player.inPlay)])\n",
    "    \n",
    "    def pickPlayer(self,playerId,rowId):\n",
    "        \"\"\"\n",
    "        Handles the picking of another player when seeking.\n",
    "        :param playerId: int, the id of the picked player in the player array \n",
    "        :param rowId: int the row id of the picked player in picking record\n",
    "        \"\"\"\n",
    "        pickedPlayer = self.playerArray[playerId]\n",
    "        tile = pickedPlayer.placedTiles.pop\n",
    "        self.adjustInfo(rowId)\n",
    "        \n",
    "        if tile:\n",
    "            pickedPlayer.externalHasSkull=True\n",
    "        elif self.pickRecord[rowId,2] ==pickedPlayer.totalTiles:\n",
    "            pickedPlayer.externalHasNoSkull=True\n",
    "        return tile\n",
    "    \n",
    "    def adjustInfo(self,rowId):\n",
    "        \"\"\"\n",
    "        Update the pick record when a player has been picked.\n",
    "        :param rowId: int, the row id in the pick record to update.\n",
    "        \"\"\"\n",
    "        self.pickRecord[rowId][0] = 1\n",
    "        self.pickRecord[rowId][1] += -1\n",
    "        self.pickRecord[rowId][2] += 1\n",
    "        if self.pickRecord[rowId][1]==0:\n",
    "            self.pickRecord[rowId][3]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class skullTrainer:\n",
    "    \"\"\"\n",
    "    A class to do and handle the training of the players which are auto-generate. \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self,passThrough=4,noOfChild=205,newBorns=204,generations=100):\n",
    "        \"\"\"\n",
    "        The initialiser of this class.\n",
    "        :param passThrough: int, how many players should survive to be parents of the next generation \n",
    "        :param noOfChild: int, how many childeren each parent should make. Including themselves\n",
    "        :param newBorns: int, how many new children from no parents should be added\n",
    "        :param generations: int, how many generations the training should go through.\n",
    "        \"\"\"\n",
    "        self.passThrough = passThrough\n",
    "        self.noOfChild = noOfChild\n",
    "        self.newBorns = newBorns\n",
    "        self.generations = generations\n",
    "        self.totalPop = (passThrough*noOfChild)+newBorns\n",
    "        self.noOfGames = int(log(self.totalPop,self.passThrough))-1\n",
    "        self.populationList=[skullPlayer() for x in range(0,self.totalPop)]\n",
    "        self.gamesList=[]\n",
    "        \n",
    "    \n",
    "    def cleanUp(self):\n",
    "        \"\"\"\n",
    "        Will run through the current population list and perform a game reset on them so they are ready for the next game. The population list is shuffled afterwards to that the players play other from different parents/origins\n",
    "        \"\"\"\n",
    "        for player in self.populationList:\n",
    "            player.resetGame()\n",
    "        random.shuffle(self.populationList)\n",
    "    \n",
    "    def nextGen(self):\n",
    "        \"\"\"\n",
    "        Creates the next generation from the current population list. A copy of the parent is included as well fresh \"newborns\". At the end the new population list is shuffled to ensure players play other players.\n",
    "        \"\"\"\n",
    "        nextGenList=[]\n",
    "        for player in self.populationList:\n",
    "            nextGenList.append(player)\n",
    "            for i in range(0,self.noOfChild-1):\n",
    "                playerCopy=deepcopy(player)\n",
    "                playerCopy.mutate()\n",
    "                nextGenList.append(playerCopy)\n",
    "        nextGenList+=[skullPlayer() for x in range(0,self.newBorns)]\n",
    "        self.populationList=nextGenList\n",
    "        random.shuffle(self.populationList)\n",
    "    \n",
    "    def createGames(self):\n",
    "        \"\"\"\n",
    "        Will take the current population of the generation and will create games for each group of 4 and add them to the list of current games.\n",
    "        \"\"\"\n",
    "        for i in range(0,len(self.populationList)//4):\n",
    "            self.gamesList.append(skullGame(*self.populationList[i*4:i*4+4]))\n",
    "    \n",
    "    def playGames(self):\n",
    "        \"\"\"\n",
    "        Will go through the games and play them. Once complete it will add the winners to a list. Upon all games being completed the games list will be wipped and the winnersList will replace the current population list.\n",
    "        \"\"\"\n",
    "        winnerList=[]\n",
    "        for game in self.gamesList:\n",
    "            game.playGame()\n",
    "            winnerList.append(game.winner)\n",
    "        self.gamesList=[]\n",
    "        self.populationList=winnerList\n",
    "    \n",
    "    def train(self,verbose=True):\n",
    "        \"\"\"\n",
    "        Begins the training proceedure for training the AI via genetic evolution.\n",
    "        :param verbose: boolean, to control wether to print updates as the training proceeds \n",
    "        \"\"\"\n",
    "        currentGen=1\n",
    "        while currentGen<=self.generations:\n",
    "            if verbose:\n",
    "                print(\"Current Generation: {}\".format(currentGen))\n",
    "            t2=time()\n",
    "            for gameNo in range(0,self.noOfGames):\n",
    "                if verbose:\n",
    "                    print(\"Current round: {}\".format(gameNo+1),end=\"\\r\")\n",
    "                self.createGames()\n",
    "                self.playGames()\n",
    "                self.cleanUp()\n",
    "            if (currentGen!=self.generations):\n",
    "                if verbose:\n",
    "                    print(\"Creating next generation\", end=\"\\r\")\n",
    "                self.nextGen()\n",
    "            if verbose:\n",
    "                print(\"Generation completed after: {} S\".format(time()-t2))\n",
    "            currentGen+=1\n",
    "        print(\"Training Complete\")\n",
    "            \n",
    "    def survivorsSummary(self):\n",
    "        \"\"\"\n",
    "        Will print the gerneration summary of each player remaining in the population list.\n",
    "        \"\"\"\n",
    "        for player in self.populationList:\n",
    "            player.genSummary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# demoPlayers=[skullPlayer() for x in range(0,4)]\n",
    "# demoGame=skullGame(*demoPlayers,True)\n",
    "# demoGame.playGame()\n",
    "# display(demoGame.gameState.state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Complete\n"
     ]
    }
   ],
   "source": [
    "demoTrain=skullTrainer(generations=500)\n",
    "demoTrain.train(verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "demoTrain.survivorsSummary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "demoTrain.populationList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import pickle\n",
    "# file_to_store = open(\"winningPlayers1.pickle\", \"wb\")\n",
    "# pickle.dump(demoTrain.populationList, file_to_store)\n",
    "# file_to_store.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# file_to_read = open(\"winningPlayers1.pickle\", \"rb\")\n",
    "# loaded_object = pickle.load(file_to_read)\n",
    "# file_to_read.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainedGame=skullGame(*demoTrain.populationList,True)\n",
    "trainedGame.playGame()"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}