dominoes_simulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5c6fc4e3",
   "metadata": {},
   "source": [
    "# Simulation: Dominoes Edition \n",
    "\n",
    "Using the dominoes Open Software library, I've done some preliminary simulations of different algorithms, and how they perform against each other. The following \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aa973825",
   "metadata": {},
   "outputs": [],
   "source": [
    "# necessary library\n",
    "import dominoes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "537cb1d5",
   "metadata": {},
   "source": [
    "# 0. Choose your character(s)\n",
    "\n",
    "The following variables contain an instance of the different algorithms that have been already implemented to play the game.\n",
    "\n",
    "*remark: the **counter** as well as the **probabilistic_alphabeta** players run extremely slowly, making it harder to actually run any simulations with them*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2790ba18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# initiate instance of each type of player\n",
    "\n",
    "player_0 = dominoes.players.bota_gorda\n",
    "player_2 = dominoes.players.random\n",
    "player_3 = dominoes.players.bota_gorda\n",
    "player_4 = dominoes.players.double\n",
    "\n",
    "player_1 = dominoes.players.omniscient() # breaking my game logic for some reason\n",
    "player_5 = dominoes.players.probabilistic_alphabeta(sample_size = 2) #lento\n",
    "player_6 = dominoes.players.counter(player = player_0) # lento"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "942b9f9a",
   "metadata": {},
   "source": [
    "we now concatante a list of 4 of the previous players. These will be used when running simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ba190652",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('AI: 0', <function dominoes.players.bota_gorda(game)>),\n",
       " ('AI: 1', <function dominoes.players.random(game)>),\n",
       " ('AI: 2', <function dominoes.players.random(game)>),\n",
       " ('AI: 3', <function dominoes.players.bota_gorda(game)>)]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player_settings = [('AI: 0', player_0),\n",
    "                   ('AI: 1', player_2), \n",
    "                   ('AI: 2', player_2), \n",
    "                   ('AI: 3', player_3)]\n",
    "player_settings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63f5da4e",
   "metadata": {},
   "source": [
    "# 1. Playing a single game of dominoes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2c313ba4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def single_game(player_settings):\n",
    "    \"\"\"\n",
    "    automatically runs a single game, with the four players specified \n",
    "    in the \"player_settings\" argument. \n",
    "    returns the game object of the played game.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    single_game = dominoes.Game.new()\n",
    "\n",
    "    while single_game.result is None: \n",
    "            # remember whose turn it currently is.\n",
    "            # we'll need it after we move on to the next player.\n",
    "            turn = single_game.turn\n",
    "\n",
    "            # get the setting for the current player\n",
    "            player_setting_name, player_setting = player_settings[single_game.turn]\n",
    "\n",
    "            # the current player is an AI. apply the player setting to select a\n",
    "            # move to play. the player setting is a callable that will sort the\n",
    "            # game's valid moves in decreasing order of preference.\n",
    "            player_setting(single_game)\n",
    "\n",
    "            # make the selected move\n",
    "            single_game.make_move(*single_game.valid_moves[0])\n",
    "    \n",
    "    return single_game"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93931afb",
   "metadata": {},
   "source": [
    "It can be used as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b82eb426",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Result(player=0, won=True, points=26)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = single_game(player_settings)\n",
    "res.result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c865639",
   "metadata": {},
   "source": [
    "# 3. Preliminary simulations: who wins more?\n",
    "\n",
    "the next block of code runs a certain number of iterations of the same faceoff between two teams, recording which team won (not by how much). The results are stored in a tuple. The results should be balanced"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "41da4d44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Team 0: 539 wins. 418 points.\n",
      "Team 1: 461 wins. 304 points.\n"
     ]
    }
   ],
   "source": [
    "player_settings = [('AI: 0', player_0), # bota gorda\n",
    "                   ('AI: 1', player_2), # random\n",
    "                   ('AI: 2', player_2), # random\n",
    "                   ('AI: 3', player_3)] # bota gorda\n",
    "\n",
    "\n",
    "iters = 1000\n",
    "team_0 = 0\n",
    "team_0_count = 0\n",
    "\n",
    "team_1 = 0\n",
    "team_1_count = 0\n",
    "for i in range(iters):\n",
    "    game = single_game(player_settings)\n",
    "    result = game.result\n",
    "    \n",
    "    # team 0 or team 1 won\n",
    "    if result[0] == 0 or result[0] == 2:\n",
    "        team_0 += 1\n",
    "        team_0_count += result[1]\n",
    "    else:\n",
    "        team_1 += 1 \n",
    "        team_1_count += result[1]\n",
    "        \n",
    "print(f\"Team 0: {team_0} wins. {team_0_count} points.\\n\\\n",
    "Team 1: {team_1} wins. {team_1_count} points.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0289c9b",
   "metadata": {},
   "source": [
    "# 4. Now, lets play a series\n",
    "\n",
    "in classical dominoes, a series of games are played up to 100 or 150 points. Hence, the first team to accumulate 150 points wins. We'll now count those. The following function `single_series`, runs a single iteration "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "a050aa8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def single_series(player_settings, target_score = 150):\n",
    "    \"\"\"\n",
    "    run a single iteration of a domino series\n",
    "    arguments:\n",
    "        - player_settings: list. 4 tuples containing names and types of players\n",
    "        - target_score: int. winning score for a series of domino games. default is 150.\n",
    "    \n",
    "    returns:\n",
    "        series object, containing the results and other key information.\n",
    "    \"\"\"\n",
    "\n",
    "    series = dominoes.Series(target_score= target_score)\n",
    "    game = series.games[0]\n",
    "\n",
    "    while not series.is_over():\n",
    "\n",
    "        # the player holding the [6|6] plays first, in the first game. in all other\n",
    "        # games, the outcome of the previous game determines the starting player.\n",
    "\n",
    "        # game.result will be filled in once the game ends\n",
    "        while game.result is None:\n",
    "\n",
    "            # remember whose turn it currently is.\n",
    "            # we'll need it after we move on to the next player.\n",
    "            turn = game.turn\n",
    "\n",
    "            # get the setting for the current player\n",
    "            player_setting_name, player_setting = player_settings[game.turn]\n",
    "\n",
    "            # the current player is an AI. apply the player setting to select a\n",
    "            # move to play. the player setting is a callable that will sort the\n",
    "            # game's valid moves in decreasing order of preference.\n",
    "            player_setting(game)\n",
    "\n",
    "\n",
    "            # make the selected move\n",
    "            game.make_move(*game.valid_moves[0])\n",
    "\n",
    "        # go to next game in series \n",
    "        game = series.next_game()\n",
    "    \n",
    "    return series"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae0878ea",
   "metadata": {},
   "source": [
    "one can now use that logic to instantly simulate a domino series, for example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "106ccf44",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = single_series(player_settings)\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d4118a2",
   "metadata": {},
   "source": [
    "---\n",
    "Now, we're ready to run hundreds of domino series simulations and compare the performance of different agents. This is the true KPI for dominoes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64543728",
   "metadata": {},
   "outputs": [],
   "source": [
    "# simulation parameters\n",
    "iters = 2\n",
    "target_score = 150\n",
    "player_settings = [('AI: 0', player_2),\n",
    "                   ('AI: 1', player_2), # prefers to play doubles \n",
    "                   ('AI: 2', player_2), \n",
    "                   ('AI: 3', player_2)] # all random\n",
    "\n",
    "# initialize counters\n",
    "team_0, team_1 = 0 , 0\n",
    "team_0_count, team_1_count = 0, 0\n",
    "\n",
    "# run iters and store results in counter\n",
    "for i in range(iters):\n",
    "    series_res = single_series(player_settings, target_score = target_score)\n",
    "    \n",
    "    if series_res.scores[0] >= target_score:\n",
    "        team_0 += 1\n",
    "    else:\n",
    "        team_1 += 1\n",
    "        \n",
    "    team_0_count += series_res.scores[0]\n",
    "    team_1_count += series_res.scores[1]\n",
    "        \n",
    "        \n",
    "# display results      \n",
    "print(f\"Team 0: {team_0} series wins. {team_0_count//iters} avg points per game.\\n\\\n",
    "Team 1: {team_1} series wins. {team_1_count//iters} avg points per game.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eeab0cee",
   "metadata": {},
   "source": [
    "# Conclusions\n",
    "\n",
    "even slight departures from randomness, like playing doubles/ playing heavy dominoes lead to huge improvements in performence.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}