fortuna
commented
5 months ago I don't know if this is how it's implemented, but you can calculate chances of winning for any (n, m) pair of troops in O(n * m) using dynamic programming and real dice probability. That is not slow and imprecise given the numbers in a game.
It's as simple as two for loops to build a P[a][b] matrix for the probability of attacker winning with a troops against b defender troops.
stevemer
Here is a solution to the balanced blitz dice that runs in O(N) time. Note this is not really a fix to the current BB dice code for two reasons. The first reason is the balanced blitz dice currently relies on finding the true random probablilty first which is super slow and inaccurate. Secondly this is method moduler and can easily be expanded to say 4 dice defenders or attackers easily. Another thing I did with this is allowed all rolls to have a chance to win or lose rather than capping anything less than 10% and because I hate when people just use 3 troops to get a card. I wanted an attacker to lose less troops rolling 1000 into a 1 than only rolling 4.
Here is a graph of the win percentages for several example battles. https://prnt.sc/Ot1RF5rDk1pQ A zoomed in version https://prnt.sc/BXkJAZ4LSz1R Here is an example of troops remianing after a 90v100 battle https://prnt.sc/NVvp5ihjKZ7q Example of 9v8 https://prnt.sc/gGH-_JyyCWYH Example of rolling stacks into 1 troop https://prnt.sc/UeewmCeRG8rq
FYI I only sent the part of the code that does attacker troop loss. Reach out to me if your intested in using this solution to fix the balanced blitz issue I'll add the defender troop loss as well as the cap troop loss and win percentage calculator. Also note this part of the code only gives an array of all possible loss values for attackers it doesnt actually select the outcome. Also note I used Int and float. The code is way more accurate using doubles.
_____Code
include
include
include
include
double floorToZero(double value);
int main() { srand(time(NULL));
int Attackers = 100; //Attackers in the battle int Defenders = 100; //Defenders in the battle int iscap =0; //0 if not a cap int AttackersOutcome[Attackers+Defenders+1][4]; int FinalOutcome[Attackers+Defenders+1][2];
} return 0; }
//This removes odds for battles that cant possibly happen. like -1v2 double floorToZero(double value) { return value < 0.0 ? 0.0 : value; }
_____Code end
Please leave some feedback. Is this method worth implementing? Would you like to see it more efficent or like some more info? Maybe a demo? Find me in the discord as Acid_Ibis