int getCombatOdds(CvUnit* pAttacker, CvUnit* pDefender)
{
float fOddsEvent;
float fOddsAfterEvent;
int iAttackerStrength;
int iAttackerFirepower;
int iDefenderStrength;
int iDefenderFirepower;
int iDefenderOdds;
int iAttackerOdds;
int iStrengthFactor;
int iDamageToAttacker;
int iDamageToDefender;
int iNeededRoundsAttacker;
int iNeededRoundsDefender;
int iMaxRounds;
int iAttackerLowFS;
int iAttackerHighFS;
int iDefenderLowFS;
int iDefenderHighFS;
int iFirstStrikes;
int iI;
int iJ;
int iI3;
int iI4;
int iOdds = 0;
iAttackerStrength = pAttacker->currCombatStr(NULL, NULL);
iAttackerFirepower = pAttacker->currFirepower(NULL, NULL);
iDefenderStrength = pDefender->currCombatStr(pDefender->plot(), pAttacker);
iDefenderFirepower = pDefender->currFirepower(pDefender->plot(), pAttacker);
iDefenderOdds = ((1000 * iDefenderStrength) / (iAttackerStrength + iDefenderStrength));
iAttackerOdds = ((1000 * iAttackerStrength) / (iAttackerStrength + iDefenderStrength));
[COLOR="SeaGreen"]// note: iDefenderOdds + iAttackerOdds = 1000[/COLOR]
[COLOR="SeaGreen"]// **** asserts removed ****[/COLOR]
if (iDefenderOdds == 0)
return 1000;
if (iAttackerOdds == 0)
return 0;
iStrengthFactor = ((iAttackerFirepower + iDefenderFirepower + 1) / 2);
[COLOR="SeaGreen"]// calculate damage done in one round
//////[/COLOR]
iDamageToAttacker = max(1,
((20 * (iDefenderFirepower + iStrengthFactor)) / (iAttackerFirepower + iStrengthFactor)));
iDamageToDefender = max(1,
((20 * (iAttackerFirepower + iStrengthFactor)) / (iDefenderFirepower + iStrengthFactor)));
[COLOR="SeaGreen"]// calculate needed rounds.
// Needed rounds = round_up(health/damage)
//////[/COLOR]
iNeededRoundsAttacker = (pDefender->currHitPoints() + iDamageToDefender - 1 ) / iDamageToDefender;
iNeededRoundsDefender = (pAttacker->currHitPoints() + iDamageToAttacker - 1 ) / iDamageToAttacker;
iMaxRounds = iNeededRoundsAttacker + iNeededRoundsDefender - 1;
[COLOR="SeaGreen"]// calculate possible first strikes distribution.
// We can't use the getCombatFirstStrikes() function (only one result,
// no distribution), so we need to mimic it.
//////[/COLOR]
iAttackerLowFS = (pDefender->immuneToFirstStrikes()) ? 0 : pAttacker->firstStrikes();
iAttackerHighFS = (pDefender->immuneToFirstStrikes()) ? 0 : (pAttacker->firstStrikes() + pAttacker->chanceFirstStrikes());
iDefenderLowFS = (pAttacker->immuneToFirstStrikes()) ? 0 : pDefender->firstStrikes();
iDefenderHighFS = (pAttacker->immuneToFirstStrikes()) ? 0 : (pDefender->firstStrikes() + pDefender->chanceFirstStrikes());
[COLOR="seagreen"]// For every possible first strike event, calculate the odds of combat.
// Then, add these to the total, weighted to the chance of that first
// strike event occurring
//////[/COLOR]
for (iI = iAttackerLowFS; iI < iAttackerHighFS + 1; iI++)
{
for (iJ = iDefenderLowFS; iJ < iDefenderHighFS + 1; iJ++)
{
[COLOR="seagreen"]// for every possible combination of fs results, calculate the chance[/COLOR]
if (iI >= iJ)
{
[COLOR="seagreen"]// Attacker gets more or equal first strikes than defender[/COLOR]
iFirstStrikes = iI - iJ;
[COLOR="seagreen"]// For every possible first strike getting hit, calculate both
// the chance of that event happening, as well as the rest of
// the chance assuming the event has happened. Multiply these
// together to get the total chance (Bayes rule).
// iI3 counts the number of successful first strikes
//////[/COLOR]
for (iI3 = 0; iI3 < (iFirstStrikes + 1); iI3++)
{
[COLOR="seagreen"]// event: iI3 first strikes hit the defender
// calculate chance of iI3 first strikes hitting: fOddsEvent
// f(k;n,p)=C(n,k)*(p^k)*((1-p)^(n-k))
// this needs to be in floating point math
// k = iI3
// n = iFirstStrikes
// p = [B]iAttackerOdds[/B] / 1000
//////[/COLOR]
fOddsEvent = ( (float)getBinomialCoefficient(iFirstStrikes, iI3))
* pow((((float)[B]iAttackerOdds[/B])/1000), iI3)
* pow((1.0f - (((float)[B]iAttackerOdds[/B])/1000)), (iFirstStrikes - iI3));
[COLOR="SeaGreen"]// calculate chance assuming iI3 first strike hits: fOddsAfterEvent
//////[/COLOR]
if (iI3 >= iNeededRoundsAttacker)
{
fOddsAfterEvent = 1;
}
else
{
fOddsAfterEvent = 0;
[COLOR="seagreen"]// odds for _at_least_ (iNeededRoundsAttacker - iI3) (the remaining hits
// the attacker needs to make) out of (iMaxRounds - iI3) (the left over
// rounds) is the sum of each _exact_ draw
//////[/COLOR]
for (iI4 = (iNeededRoundsAttacker - iI3); iI4 < (iMaxRounds - iI3 + 1); iI4++)
{
[COLOR="seagreen"]// odds of exactly iI4 out of (iMaxRounds - iI3) draws.
// f(k;n,p)=C(n,k)*(p^k)*((1-p)^(n-k))
// this needs to be in floating point math
// k = iI4
// n = iMaxRounds - iI3
// p = [B]iAttackerOdds [/B]/ 1000
//////[/COLOR]
fOddsAfterEvent += ((float)getBinomialCoefficient((iMaxRounds - iI3), iI4))
* pow((((float)[B]iAttackerOdds[/B]) / 1000), iI4)
* pow((1.0f - (((float)[B]iAttackerOdds[/B]) / 1000)), ((iMaxRounds - iI3) - iI4));
}
}
[COLOR="seagreen"]// Multiply these together, round them properly, and add
// the result to the total iOdds
//////[/COLOR]
iOdds += ((int)(1000.0 * (fOddsEvent*fOddsAfterEvent + 0.0005)));
}
}
else // (iI < iJ)
{
[COLOR="seagreen"]// Attacker gets less first strikes than defender[/COLOR]
iFirstStrikes = iJ - iI;
[COLOR="seagreen"]// For every possible first strike getting hit, calculate both
// the chance of that event happening, as well as the rest of
// the chance assuming the event has happened. Multiply these
// together to get the total chance (Bayes rule).
// iI3 counts the number of successful first strikes
//////[/COLOR]
for (iI3 = 0; iI3 < (iFirstStrikes + 1); iI3++)
{
[COLOR="seagreen"]// event: iI3 first strikes hit the defender
// First of all, check if the attacker is still alive.
// Otherwise, no further calculations need to occur
/////[/COLOR]
if (iI3 < iNeededRoundsDefender)
{
[COLOR="seagreen"]// calculate chance of iI3 first strikes hitting: fOddsEvent
// f(k;n,p)=C(n,k)*(p^k)*((1-p)^(n-k))
// this needs to be in floating point math
// k = iI3
// n = iFirstStrikes
// p = [B]iDefenderOdds [/B]/ 1000
//////[/COLOR]
fOddsEvent = ((float)getBinomialCoefficient(iFirstStrikes, iI3))
* pow((((float)[B]iDefenderOdds[/B]) / 1000), iI3)
* pow((1.0f - (((float)[B]iDefenderOdds[/B]) / 1000)), (iFirstStrikes - iI3));
[COLOR="seagreen"]// calculate chance assuming iI3 first strike hits: fOddsAfterEvent
//////[/COLOR]
fOddsAfterEvent = 0;
[COLOR="seagreen"]// odds for _at_least_ iNeededRoundsAttacker (the remaining hits
// the attacker needs to make) out of (iMaxRounds - iI3) (the left over
// rounds) is the sum of each _exact_ draw
//////[/COLOR]
for (iI4 = iNeededRoundsAttacker; iI4 < (iMaxRounds - iI3 + 1); iI4++)
{
[COLOR="seagreen"]// odds of exactly iI4 out of (iMaxRounds - iI3) draws.
// f(k;n,p)=C(n,k)*(p^k)*((1-p)^(n-k))
// this needs to be in floating point math
// k = iI4
// n = iMaxRounds - iI3
// p = [B]iAttackerOdds [/B]/ 1000
//////[/COLOR]
fOddsAfterEvent += ((float)getBinomialCoefficient((iMaxRounds - iI3), iI4))
* pow((((float)[B]iAttackerOdds[/B]) / 1000), iI4)
* pow((1.0f - (((float)[B]iAttackerOdds[/B]) / 1000)), ((iMaxRounds - iI3) - iI4));
}
[COLOR="seagreen"]// Multiply these together, round them properly, and add
// the result to the total iOdds
//////[/COLOR]
iOdds += ((int)(1000.0 * (fOddsEvent*fOddsAfterEvent + 0.0005)));
}
}
}
}
}
[COLOR="seagreen"]// Weigh the total to the number of possible combinations of first strikes events
// note: the integer math breaks down when #FS > 656 (with a die size of 1000)
//////[/COLOR]
iOdds /= (((pDefender->immuneToFirstStrikes()) ? 0 : pAttacker->chanceFirstStrikes()) + 1)
* (((pAttacker->immuneToFirstStrikes()) ? 0 : pDefender->chanceFirstStrikes()) + 1);
[COLOR="seagreen"]// finished!
//////[/COLOR]
return iOdds;
}
