gacha_probability.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "gacha_probability.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sr229/gacha-prng/blob/main/gacha_probability.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2dAjjFZLNnYU"
      },
      "source": [
        "## Jupyter Notebook to Calculate Gacha Probabilities in Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zjw7KiDKNuUA"
      },
      "source": [
        "## What is this about?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x8xjncdjNxmt"
      },
      "source": [
        "This specific Notebook is used to calculate probabilities for Gacha games on N times of iterations. It was built to facilitate checking the probability of getting a ideal roll based on the number of iterations and attempts a user has made.\n",
        "\n",
        "We look on two factors that affects how a roll's outcome:\n",
        "\n",
        "- Time-based: some gacha games instead of using a fixed UID seed would use the server time as a seed. This allows it to be a bit more unpredictable however it still maintains it's usual predictability having a fixed rate and a relatively non-cryptographically secure PRNG.\n",
        "\n",
        "- Fixed seed-based: this is the most usual implementations seen in gacha games. They either use the UID or a internal identifier of the user to get your roll. Since we're using a predictable non-secure PRNG, this is the most predictable kind of method usually used and employed by games. Probability is considered constant as well since the seed is never changing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F9IzvHnnOqL5"
      },
      "source": [
        "## The Algorithm"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K2YIx6T4OtlZ"
      },
      "source": [
        "This gacha probability notebook uses the Subtractive Pseudo-Random Number Generator used by C#. \n",
        "\n",
        "Quoting [RosettaCode](https://rosettacode.org/wiki/Subtractive_generator):\n",
        "> A subtractive generator calculates a sequence of random numbers, where each number is congruent to the subtraction of two previous numbers from the sequence.\n",
        "\n",
        "The reason this was picked because a large majority of the games currently that has gacha elements are based on Unity C#, and we can assume some of them uses client-side PRNG (however most gacha games have server side PRNG)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ghOSQdaPPVBl"
      },
      "source": [
        "## The code"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iVPmAGiu7Nf2"
      },
      "source": [
        "from random import random\n",
        "from matplotlib import pyplot as plt\n",
        "import time\n",
        "import statistics\n",
        "from numpy import sqrt,empty,array,average,set_printoptions\n",
        "from numba import jit\n",
        "import sys\n",
        "\n",
        "set_printoptions(threshold=sys.maxsize)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nrjGPvlG97Mz"
      },
      "source": [
        "import os\n",
        "os.environ['NUMBAPRO_LIBDEVICE'] = \"/usr/local/cuda-10.0/nvvm/libdevice\"\n",
        "os.environ['NUMBAPRO_NVVM'] = \"/usr/local/cuda-10.0/nvvm/lib64/libnvvm.so\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rVLu-DSb7aYJ",
        "outputId": "b75a6f8e-39f6-4652-f100-7fa38749f6ca",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "import collections\n",
        "\n",
        "\"\"\"\"\n",
        "Implements the Subtractive PRNG used by C#: https://rosettacode.org/wiki/Subtractive_generator#C.2B.2B.\n",
        "seed is used to define a new generation for the PRNG. A new call of the srand function is always either a new generation based on that seed alone.\n",
        "\n",
        ":param seed: the seed used for generation. It has to be a value within 1-10^9. Keep in mind this parameter is not persisted between calls. One function call has its own instance. \n",
        "\"\"\"\n",
        "def srand(seed):\n",
        "    r = collections.deque(maxlen=55)\n",
        "    s = collections.deque(maxlen=55)\n",
        "    m = 10**9\n",
        "    s.extend([seed, 1])\n",
        "    s.extend((s[n-2] - s[n-1]) % m for n in range(2, 55))\n",
        "    r.extend(s[(34 * (n+1)) % 55] for n in range(55))\n",
        "    for _ in range(219-54):\n",
        "        r.append((r[0] - r[31]) % m)\n",
        "    while True:\n",
        "        r.append((r[0] - r[31]) % m)\n",
        "        yield r[54]\n",
        "\n",
        "# Verify our SPRNG works\n",
        "x = srand(1029202)\n",
        "print(next(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "521657541\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aNZfOus79OSw"
      },
      "source": [
        "\"\"\"\n",
        "Calculates the probability between N times of iterations.\n",
        ":param seed: the seed used by the PRNG to calculate the rate of roll. This could be any positive integers from 1 to 10^9.\n",
        ":param rate: the rate of the roll. By default it uses 0.02.\n",
        ":param iterations: the N amount of iterations to perform to check for a probability\n",
        ":param total_samples: the amount of total samples to check against.\n",
        "\"\"\"\n",
        "# We're using Numba to speed up our increments, since the LLVM opcodes is going to help us alot.\n",
        "@jit(parallel=True, forceobj=True)\n",
        "def get_probability(seed, rate, rate_increment, iterations, total_samples, debug=False):\n",
        "\n",
        "    tl_mean_list = []\n",
        "\n",
        "    prng = srand(seed)\n",
        "    s = 0\n",
        "    start = time.time()\n",
        "\n",
        "    while s < iterations:\n",
        "        trial_list = []\n",
        "        a = 0\n",
        "\n",
        "        while a < total_samples:\n",
        "            trial = 1\n",
        "            x = next(prng) / 10**9\n",
        "            rate_current = rate\n",
        "            while x > rate_current:\n",
        "                trial += 1\n",
        "                x = next(prng) / 10**9\n",
        "                if trial > 50:\n",
        "                    rate_current += rate_increment\n",
        "                \n",
        "            a += 1\n",
        "            trial_list.append(trial)\n",
        "        \n",
        "        eee = sum(trial_list) / iterations\n",
        "        tl_mean_list.append(eee)\n",
        "        s += 1\n",
        "\n",
        "        if s % 100 == 0 and debug is True:\n",
        "            endf = time.time()\n",
        "            print('progress =','%.2f' % (s*100/iterations),'% (time =','%.2f' % (endf-start),'s)')\n",
        "  \n",
        "    return tl_mean_list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vLkJjQIjPbSP"
      },
      "source": [
        "### Probability calculation using a fixed seed\n",
        "\n",
        "The following example plots the probability at 10000 iterations at a fixed rate of 0.02."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4a90poJ4Av1m",
        "outputId": "229f655a-2d98-485b-dc6e-8741c89db152",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Number of iterations\n",
        "N = 10000\n",
        "# Sample Size\n",
        "sN = 10000\n",
        "\n",
        "# Execute. Keep in mind it may take a while for the function to complete since it's going through a large number of iterations.\n",
        "tl_mean_list = get_probability(102927162, 0.02, 0.02, N, sN)\n",
        "\n",
        "var = statistics.variance(tl_mean_list)\n",
        "\n",
        "print('mean =',sum(tl_mean_list)/sN)\n",
        "print('variance =',var)\n",
        "print('sd =',sqrt(var))\n",
        "\n",
        "fig, ax = plt.subplots(figsize = (10,7))\n",
        "ax.hist(tl_mean_list, bins = 50)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "mean = 34.57004609\n",
            "variance = 0.04479807826653855\n",
            "sd = 0.2116555651678891\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NDbB0oB7SU7C"
      },
      "source": [
        "### Probability calculation using the Unix time\n",
        "\n",
        "The following example plots the probability at 10000 iterations at a fixed rate of 0.02 but using the ever changing [Unix time](https://en.wikipedia.org/wiki/Unix_time) as our seed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vnN3r4kbSU7G",
        "outputId": "1ef9d56e-6db4-46d6-c3a5-f2cc02462dc0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Number of iterations\n",
        "N = 10000\n",
        "# Sample Size\n",
        "sN = 49\n",
        "\n",
        "# Execute. Keep in mind it may take a while for the function to complete since it's going through a large number of iterations.\n",
        "tl_mean_list = get_probability(int(time.time()), 0.02, 0.02, N, sN)\n",
        "\n",
        "var = statistics.variance(tl_mean_list)\n",
        "\n",
        "print('mean =',sum(tl_mean_list)/sN)\n",
        "print('variance =',var)\n",
        "print('sd =',sqrt(var))\n",
        "\n",
        "fig, ax = plt.subplots(figsize = (10,7))\n",
        "ax.hist(tl_mean_list, bins = 50)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "mean = 34.58273061224491\n",
            "variance = 0.00022249166622222223\n",
            "sd = 0.01491615453869469\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Hcxja7sTd6M"
      },
      "source": [
        "## Credits\n",
        "\n",
        "These works are created as a collaboration of the following people:\n",
        "\n",
        "- [SurfChu85](https://twitter.com/SurfChu85)\n",
        "- [Ayane Satomi](https://github.com/sr229)\n",
        "- [Eyenine](https://twitter.com/Eyenine_i9)\n",
        "- [KaidenFrizu](https://github.com/KaidenFrizu)"
      ]
    }
  ]
}