{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "name": "Troop349-Dice-Game-Simulation.ipynb", "version": "0.3.2", "provenance": [], "collapsed_sections": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" } }, "cells": [ { "metadata": { "id": "xCUilSYNY_f-", "colab_type": "text" }, "cell_type": "markdown", "source": [ "# Troop 349 The Dice Game Simulation\n", "\n", "Simulation of the _Troop 349 Dice Game_ to determine average play length in turns and the value of different winning point total choices.\n", "\n", "This notebook can be run interactively via Binder!\n", "\n", "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/stephenhouser/Troop349-Dice-Game/master?filepath=Troop349_Dice_Game_Simulation.ipynb)" ] }, { "metadata": { "id": "1Lm-oqd34mb4", "colab_type": "code", "colab": {} }, "cell_type": "code", "source": [ "# Python imports for packages used later on.\n", "import random\n", "import itertools\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np" ], "execution_count": 0, "outputs": [] }, { "metadata": { "id": "9q6-ct2cY9_i", "colab_type": "text" }, "cell_type": "markdown", "source": [ "## Customization\n", "Here you can tweak what's on the die faces, how many dice are rolled for each turn, and how many dice are used to set the initial winning point total.\n", "\n", "Only '349' has been extensively tested. Some values might perhaps make an unresolvable game! Adjust at your own risk." ] }, { "metadata": { "id": "8e49dSrwTugs", "colab_type": "code", "colab": {} }, "cell_type": "code", "source": [ "# What's on the die faces\n", "die_faces = (3, 4, 9)\n", "\n", "# Number of dice rolled by players for their turn\n", "n_dice = 3\n", "\n", "# Number of dice used to determine winning point total\n", "n_dice_win = 2" ], "execution_count": 0, "outputs": [] }, { "metadata": { "id": "KckRB75GaAQ3", "colab_type": "text" }, "cell_type": "markdown", "source": [ "Some pre-computation to make our simulation go a bit quicker, or at least I think it will make it go quicker. Could just be premature optimization too.\n", "\n", "* Precompute all the possible winning point totals.\n", "\n", "* Precompute all the possible turn totals (all the combinations of dice and +/- based on the die faces and number of dice). Then we don't have to do the calculations at simulation time, we just look up the value that gets us closest to where we want to be.\n", "\n", "* Precompute the maximum poss" ] }, { "metadata": { "id": "Vr1kwe_HTbCz", "colab_type": "code", "colab": {} }, "cell_type": "code", "source": [ "# Pre-compute all the possible winning point totals \n", "# hint: it's fixed and all are equally likely (are they?)\n", "all_win_combinations = list(itertools.product(die_faces, repeat=n_dice_win))\n", "all_win_totals = tuple(map(lambda dice: int(str(dice[0]) + str(dice[1])), all_win_combinations))" ], "execution_count": 0, "outputs": [] }, { "metadata": { "id": "iPqj_IDOTeFH", "colab_type": "code", "colab": {} }, "cell_type": "code", "source": [ "# Pre-compute all the possible player rolls and their possible totals\n", "# this is a 2D structure, \n", "# one entry for each possible roll combination\n", "# then all the possible addition and subtraction combinations for the roll\n", "def possible_roll_totals(dice):\n", " results = set()\n", " # ---\n", " results.add(- dice[0] - dice[1] - dice[2])\n", " # --+\n", " results.add(- dice[0] - dice[1] + dice[2])\n", " # -+-\n", " results.add(- dice[0] + dice[1] - dice[2])\n", " # -++\n", " results.add(- dice[0] + dice[1] + dice[2])\n", " # +--\n", " results.add(+ dice[0] - dice[1] - dice[2])\n", " # +-+\n", " results.add(+ dice[0] - dice[1] + dice[2])\n", " # ++-\n", " results.add(+ dice[0] + dice[1] - dice[2])\n", " # +++\n", " results.add(+ dice[0] + dice[1] + dice[2])\n", " return list(results)\n", "\n", "all_roll_combinations = list(itertools.combinations_with_replacement(die_faces, n_dice))\n", "all_roll_totals = {}\n", "for dice in list(all_roll_combinations):\n", " all_roll_totals[dice] = tuple(possible_roll_totals(dice))\n" ], "execution_count": 0, "outputs": [] }, { "metadata": { "id": "ikgi8fVJanUo", "colab_type": "text" }, "cell_type": "markdown", "source": [ "## Die Rolling\n", "\n", "Here's the core function we use to roll the dice for each turn." ] }, { "metadata": { "id": "b_6suAl1TnX3", "colab_type": "code", "colab": {} }, "cell_type": "code", "source": [ "def roll_dice():\n", " \"\"\"Simulate a roll of n_dice with die_faces on them and returns a list of the results.\"\"\"\n", " return tuple(sorted(random.choices(die_faces, k=n_dice)))\n" ], "execution_count": 0, "outputs": [] }, { "metadata": { "id": "PZWKkco2bBC2", "colab_type": "text" }, "cell_type": "markdown", "source": [ "## Intermediate Check\n", "This is just a diagnostic intermediate check of the precomputations that we have done. Give them a look and make sure they seem to make sense at this point." ] }, { "metadata": { "id": "-z7ooVvqHupS", "colab_type": "code", "outputId": "e008275c-68d5-4d3d-9661-0037db7322b4", "colab": { "base_uri": "https://localhost:8080/", "height": 110 } }, "cell_type": "code", "source": [ "print(all_win_totals)\n", "print(all_roll_totals)\n", "print(roll_dice())\n", "random.choice(all_win_totals)" ], "execution_count": 6, "outputs": [ { "output_type": "stream", "text": [ "(33, 34, 39, 43, 44, 49, 93, 94, 99)\n", "{(3, 3, 3): (9, 3, -3, -9), (3, 3, 4): (2, 4, 10, -10, -4, -2), (3, 3, 9): (3, 9, 15, -15, -9, -3), (3, 4, 4): (3, 5, 11, -11, -5, -3), (3, 4, 9): (2, 8, 10, -16, 16, -10, -8, -2), (3, 9, 9): (3, -21, 15, -15, 21, -3), (4, 4, 4): (4, 12, -12, -4), (4, 4, 9): (1, 9, -17, 17, -9, -1), (4, 9, 9): (4, -22, 14, -14, 22, -4), (9, 9, 9): (9, 27, -27, -9)}\n", "(3, 3, 9)\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "99" ] }, "metadata": { "tags": [] }, "execution_count": 6 } ] }, { "metadata": { "id": "EWm9JUOkbMD5", "colab_type": "text" }, "cell_type": "markdown", "source": [ "## Play A Game\n", "This is the main function used to simulate one play of the game. It selects a winning point total, and tracks the number of turns needed to get there. If passed `True` then will print some diagnostic information to the console as it does it's work.\n", "\n", "Returns a tuple of (number of turns played, the winning point total) which is used in our statistics computation later on." ] }, { "metadata": { "id": "uqKuN5-V68xK", "colab_type": "code", "colab": {} }, "cell_type": "code", "source": [ "def play_game(show_progress = False):\n", " \"\"\"Simulate a game and reuturn the number of turns to win.\"\"\"\n", " turns = 0\n", " current_points = 0\n", " win_points = random.choice(all_win_totals)\n", " \n", " if show_progress:\n", " print('GAME: win = {} points'.format(win_points))\n", " while current_points != win_points:\n", " dice = roll_dice()\n", " if show_progress:\n", " print('TURN {}: points = {}, roll = {}, '.format(turns, current_points, dice), end='')\n", " \n", " # Optimize when current points is far below win_points\n", " if current_points + sum(dice) < win_points:\n", " turn_points = sum(dice)\n", " if show_progress:\n", " print('best = {}'.format(turn_points))\n", " else:\n", " target_choice = win_points - current_points\n", " possible_combinations = all_roll_totals[dice]\n", " turn_points = min(possible_combinations, key=lambda x:abs(x-target_choice))\n", " if show_progress:\n", " print('possible = {}, best = {}'.format(possible_combinations, turn_points))\n", "\n", " current_points += turn_points\n", " turns += 1\n", " \n", " return (turns, win_points)\n", " " ], "execution_count": 0, "outputs": [] }, { "metadata": { "id": "Obe14jQKbo9E", "colab_type": "text" }, "cell_type": "markdown", "source": [ "Simulate a sample game and show the progress." ] }, { "metadata": { "id": "bwhzoU2T8jC9", "colab_type": "code", "outputId": "e840c5f4-99b0-4aec-dbcf-c644af01d6a1", "colab": { "base_uri": "https://localhost:8080/", "height": 136 } }, "cell_type": "code", "source": [ "play_game(True)" ], "execution_count": 8, "outputs": [ { "output_type": "stream", "text": [ "GAME: win = 49 points\n", "TURN 0: points = 0, roll = (3, 4, 9), best = 16\n", "TURN 1: points = 16, roll = (3, 4, 9), best = 16\n", "TURN 2: points = 32, roll = (3, 4, 9), best = 16\n", "TURN 3: points = 48, roll = (3, 9, 9), possible = (3, -21, 15, -15, 21, -3), best = 3\n", "TURN 4: points = 51, roll = (3, 4, 9), possible = (2, 8, 10, -16, 16, -10, -8, -2), best = -2\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "(5, 49)" ] }, "metadata": { "tags": [] }, "execution_count": 8 } ] }, { "metadata": { "id": "-iSfso-QbwbO", "colab_type": "text" }, "cell_type": "markdown", "source": [ "## Simulate a Bunch of Games\n", "\n", "Now we are ready to simulate a whole bunch of games. How many is a whole bunch? Here it's 250,000 because things start running out of memory (or CPU time) when I adjust it to much more. Even when you do, the results don't vary that much, so it's _good enough_ for my purposes." ] }, { "metadata": { "id": "_atKYA4PQat3", "colab_type": "code", "colab": {} }, "cell_type": "code", "source": [ "# Play a bunch of games and accumulate the number of turns and the win_points..\n", "games = []\n", "for n in range(250000):\n", " games.append(play_game())\n", " \n", "# Lots of output for each game \n", "print(games)" ], "execution_count": 0, "outputs": [] }, { "metadata": { "id": "T70FPAajYa7O", "colab_type": "text" }, "cell_type": "markdown", "source": [ "## How Many Turns to Win?\n", "\n", "Here we plot a histogram of the number of turns it took to finish each of the games we simulated. This gives us an idea of how long games will take.\n", "\n", "Included in the histogram is the median (the number of turns for the middle-most game), the mean (the average number of turns needed), and the 95th percentile (the number of turns in which 95% of all simulated games were completed before)." ] }, { "metadata": { "id": "w7-SD8DcW6-X", "colab_type": "code", "outputId": "a0894239-338a-4b0e-fc02-c4349c9eb0bb", "colab": { "base_uri": "https://localhost:8080/", "height": 347 } }, "cell_type": "code", "source": [ "# Plot simple histogram of number of turns needed to win\n", "np_games = np.array(games)\n", "\n", "x = np_games[:,0]\n", "#y = np_games[:,1]\n", "\n", "n, bins, patches = plt.hist(x, bins=50, color='c', edgecolor='k', alpha=0.65)\n", "_, max_ = plt.ylim()\n", "\n", "median_turns = np.median(x)\n", "_ = plt.axvline(median_turns, color='g', linewidth=1)\n", "_ = plt.text(median_turns + median_turns/5, max_ - max_/10, 'Median: {:.0f}'.format(median_turns))\n", "\n", "mean_turns = x.mean()\n", "_ = plt.axvline(mean_turns, color='k', linewidth=1)\n", "_ = plt.text(mean_turns + mean_turns/5, max_ - max_/6.5, 'Mean: {:.2f}'.format(mean_turns))\n", "\n", "ninety_percent_turns = np.percentile(x, 95) \n", "_ = plt.axvline(ninety_percent_turns, color='r', linewidth=1)\n", "_ = plt.text(ninety_percent_turns + ninety_percent_turns/5, max_ - max_/5, '95%: {:.0f}'.format(ninety_percent_turns))" ], "execution_count": 10, "outputs": [ { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe8AAAFKCAYAAAA0WNeQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRETEYBTeIiIiBqPwFhERMZj/D9btq9H7FpqdAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "tags": [] } } ] }, { "metadata": { "id": "f0_qS8cMX3Go", "colab_type": "text" }, "cell_type": "markdown", "source": [ "## Winning Points Compared to Mean Turns to Win\n", "\n", "Compare the number of turns on average it takes to win a game with different winning point totals. This tells us how best to choose the winning point total from the inital die roll. E.g. is it better to choose `39` or `93`? Which will allow us to win faster than our opponent?\n" ] }, { "metadata": { "id": "KP_TAcVeXjOz", "colab_type": "code", "outputId": "92c5da0f-5412-4fe2-e095-6bd2df04f63a", "colab": { "base_uri": "https://localhost:8080/", "height": 500 } }, "cell_type": "code", "source": [ "# Where we will accumulate the mean number of turns to play a game \n", "# with each winning point total\n", "mean_turns = []\n", "\n", "# Loop for each winning point (these are discrete and precomputed above)\n", "for win_total in all_win_totals:\n", " # filter for only games with this winning point total\n", " games_wt = list(filter(lambda x: x[1] == win_total, games))\n", " \n", " # make a numpy array and select only the turns to play\n", " np_turns = np.array(games_wt)[:,0]\n", " \n", " # append to our collection array for later plotting\n", " mean_turns.append(np.mean(np_turns))\n", " \n", " # print some status details of our work\n", " print(\"win points={}, n_games={}, median turns={:.2f}\".format(win_total, len(np_turns), np.mean(np_turns)))\n", "\n", "# Plot the mean turns for each winning point total\n", "y_pos = np.arange(len(all_win_totals)) \n", "plt.bar(y_pos, mean_turns, align='center', alpha=0.5)\n", "plt.xticks(y_pos, list(all_win_totals)) \n", "plt.show() " ], "execution_count": 11, "outputs": [ { "output_type": "stream", "text": [ "win points=33, n_games=27617, median turns=6.37\n", "win points=34, n_games=28138, median turns=6.46\n", "win points=39, n_games=27734, median turns=6.79\n", "win points=43, n_games=27873, median turns=6.85\n", "win points=44, n_games=27855, median turns=7.04\n", "win points=49, n_games=27881, median turns=7.32\n", "win points=93, n_games=27307, median turns=10.05\n", "win points=94, n_games=27740, median turns=10.04\n", "win points=99, n_games=27855, median turns=10.41\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAd8AAAFKCAYAAABcq1WoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [] } } ] }, { "metadata": { "id": "B_6i92dTYY5P", "colab_type": "code", "colab": {} }, "cell_type": "code", "source": [ "" ], "execution_count": 0, "outputs": [] } ] }