Mathematics for casino players (winning probabilities)

I hope you get the idea that scripted slots implement two of Shpilevoy's laws about adaptability in casino slot machines.

The first law, filled with years of practice
= THE HIGHER THE BET, THE LESS OFTEN YOU WIN

The first pedal on the server of pedal Vasya means that a bet of 0.01*1*1 will play with a probability of 10%, and a bet of 10*2*100 with a probability of 1:1000000.
For Book of Ra Delux, the % Win probabilities will be spread over a betting range from 0.01UAH to 2000UAH.

/////////////////////////

Shpilevoy's second law concerns the quality of payouts. To find something worthwhile, you have to sift through a mountain of junk...
= NORMAL BONUS YOU WILL NOT GET ANY F#CK

Vasya's second point concerns the payout odds themselves. Underwinnings below the bet are much more common than winnings. Bonuses of x1000+ (especially with a normal bet) only come around a couple of times a year.

//////////////////////



This simple two-pedal mechanism allows the owner to easily customize the game on their platform. It regulates the payout with several coefficients in the admin panel, shifting the ranges and tying it to stock statistics and their own greed.

At least for my purposes, this engine is quite sufficient. I can easily customize the system to suit my experience playing Champion (far from the worst option among the wide variety of slot machines).

The probability of event Y varies from 0% to 100%. The factor X varies from 0.003 to 1800. What does the function look like in which the closer X gets to 1800, the closer Y approaches zero?

Such a function would look like this:
Y = A * exp(-B * X)
where A and B are the coefficients that must be determined so that the function satisfies the conditions of the problem.
In order for Y to tend to zero at X close to 1800, the coefficients must be chosen so that the exponent decreases very rapidly as X increases. In this case, at X close to 1800, the value of the function will be close to zero.
Since we want Y to vary between 0% and 100%, we can set A so that Y at X = 0 is equal to 100%. Then:
Y(0) = A * exp(-B * 0) = 100%
From which it follows that A = 100%.
To determine the value of B, we can use the condition that at X = 1800 the value of the function should be close to zero. Then:
Y(1800) = 100% * exp(-B * 1800) ≈ 0
From which it follows that:
exp(-B * 1800) ≈ 0
This means that B * 1800 must be a very large number (almost infinity) for the exponential to decay rapidly. One could choose, for example, B = 0.001, then:
Y(X) = 100% * exp(-0.001 * X)
where X ranges from 0.003 to 1800 and Y ranges from 0% to 100%, meeting the given conditions.

//////////////////////////////////////
/////////////////////////////
Adapting the primary filter
"The higher the bet, the less often the winnings"
Probability.

public float GetProbSumBet(float x) // Probability 0-1
{
// when playing 0.01 W will be 1 time in 10-20 spins = 15%
// when playing at MAX W will be 1 time in 20-50 spins = 4%
float a = 0.15f; // function value at x = 0.01
float b = 0.04f; // function value at x = 1800+
float k = -Mathf.Log(b / a) / 1800f ; // coefficient for calculating the function
float payout = a * Mathf.Exp(-k * x);
// Mathf.Clamp01() is used to ensure that the result is always in the range from 0 to 1.
return payout;
}

/////////////////
This is roughly the WIN dynamics we get during the game. At a glance, it's very similar to real-life conditions.
The higher the bet, the WIN dynamics worsen.
And this is an axiom for all scripted slots.

Secondary filter
EFF WIN?
/////////////////////
Here too, everything is simple )))
Spin the slot quickly for 1 hour (1000 spins).
The bulk of payouts are the majority less than or equal to the bet (!) hidden loss.
Another portion up to x3 to the total bet.
We are, of course, expecting bonuses.
It's good if we catch two or three bonuses during this hour. The symbol line is also equivalent to a bonus feature.
The odds in the bonus range from RARE killer x5-x10, the bulk of the bonuses are NOTHING x10-x30, then a wide streak of x30-x100 and rare good x100-x1000.
//////////////////
Now I will translate this diagram into slot mathematics.

In fact, it is a regular exponential from x5 to x5000 to the LINE BET, the payout is a multiple of [5].

//////////////////////////////////////
Tertiary filter
GUESS THE LINE

Here, the entire hard-earned win is "hidden" on one of the slot's active lines. To avoid losing the winnings, the player must spin all the lines, which is expensive and inherently unprofitable.
Therefore, you need to vary and “feel” when to expand along the lines, and when to narrow their set to save money.
Here a pure randomness is added in the number of lines.

Shpilevoy wrote:
In fact, it is a regular exponential from x5 to x5000 to the LINE BET, the payout is a multiple of [5].

Not quite ordinary ))) turned inside out...

If the values on the X-axis range from 5 to 5000, and on the Y-axis from 0 to 100, what is the exponential function for a graph in which the minimum X corresponds to the maximum Y?

The exponential function for a graph in which the minimum X corresponds to the maximum Y can be described by the following formula:

y = A * exp(-x / + C
where A, B and C are coefficients that determine the shape of the graph.
To find the values of the coefficients, we can use the following conditions:
at x = 5, y = 100at x = 5000, y = 0Substituting these values into the formula, we get two equations:

100 = A * exp(-5 / + C
0 = A * exp(-5000 / + C
We can solve this system of equations to find the values of A, B, and C. The first equation can be rewritten as follows:

C = 100 - A * exp(-5 /
Substituting this equation into the second equation, we get:

0 = A * exp(-5000 / + (100 - A * exp(-5 / )
Solving this equation for A, we obtain:

A = 100 / (exp(-5 / - exp(-5000 / )
Substituting this value of A into the first equation, we can express C:

C = 100 - A * exp(-5 /
Finally, we can find the value of B by solving either of the two equations for A:

A = 100 / (exp(-5 / - exp(-5000 / )
or
A = -100 / (exp(5 / - exp(5000 / )
The value of B can be found by iteration, for example, using the Newton-Raphson method or the bisection method.

///////////////////
ps ChatGPT has completely replaced our sweet Alatissa

In this problem, the user enters argument Y, and the function should return X. Show me the script.

public float CalculateX5000(float y)
{
float minX = 5f;
float maxX = 5000f;
float minY = 0.000001f;
float maxY = 100f;
// Calculate parameters B and k
float B = Mathf.Pow(minY / maxY, -maxX / (maxX - minX));
float k = Mathf.Log(minY / maxY) / (maxX - minX);
// Calculate the value of the function at point y
float logY = Mathf.Log(y / maxY);
float x = (logY - k * minX) / k;
float result = B * Mathf.Exp(k * x);
// Clip the x value to the range from minX to maxX
x = Mathf.Clamp(x, minX, maxX);
return x;
}

To use this script, you need to add it to an object in your Unity scene. You can then access the CalculateFunction method from other scripts or components to calculate the function value at the desired point. For example, you could do it like this:



/////////////////////////
=== The higher the probability, the lower the WIN odds. Payouts of x5000 per line are extremely rare.

You need to generate a number between 0 and 100 that follows a normal probability distribution. That is, if the function returns 68, this corresponds to 1 in approximately 68 executions of this function. If it returns 12, this means that the function was called an average of 12 times.

To generate random numbers that follow a normal distribution, you can use the Box-Muller formula. This formula generates pairs of independent random numbers with a uniform distribution on the interval [0, 1] and transforms them into pairs of independent random numbers that follow a normal distribution.

Here is some sample C# code for Unity that generates a random number that follows a normal distribution with a mean of 50 and a standard deviation of 15:

public float GenerateRandomNormalDistribution()
{
float u1 = Random.value;
float u2 = Random.value;
float randStdNormal = Mathf.Sqrt(-2.0f * Mathf.Log(u1)) * Mathf.Sin(2.0f * Mathf.PI * u2); // Box-Muller transform
float randNormal = 50.0f + 15.0f * randStdNormal; // scale and shift along the Y axis
if (randNormal < 0) randNormal = 0;
if (randNormal > 100) randNormal = 100;
return randNormal; // limiting the value from 0 to 100 Mathf.Clamp(randNormal, 0.0f, 100.0f)
}

This function returns a random number that follows a normal distribution with mean 50 and standard deviation 15, bounded by values between 0 and 100. Calling it will cause numbers close to the mean (50) to be generated more frequently, while numbers far from the mean will be generated less frequently.

////////////////////////
P.S. This is fantastic! Cry, math professors!



pps It's too early to immediately include sumWin in the credit dynamics. We also need to "hide" the mathematical winnings for the RTP in one of the slot lines - in case the player doesn't open it if he plays on fewer lines )))