{

powerA = Power(attacker, false);

powerD = Power(defender, true);

Calculate();

{

// If the defender has no crew remaining, odds are 100%.

if(!defendingCrew)

return 1.;

// Make sure the input is within range, with the special constraint that the

// attacker can never succeed if they don't have two crew left (one to pilot

// each of the ships).

int index = Index(attackingCrew, defendingCrew);

if(attackingCrew < 2 || index < 0)

return 0.;

return capture[index];

{

// If the attacker has fewer than two crew, they cannot attack. If the

// defender has no crew, they cannot defend (so casualties will be zero).

int index = Index(attackingCrew, defendingCrew);

if(attackingCrew < 2 || !defendingCrew || index < 0)

return 0.;

return casualtiesA[index];

{

// If the attacker has fewer than two crew, they cannot attack. If the

// defender has no crew, they cannot defend (so casualties will be zero).

int index = Index(attackingCrew, defendingCrew);

if(attackingCrew < 2 || !defendingCrew || index < 0)

return 0.;

return casualtiesD[index];

{

if(static_cast<unsigned>(attackingCrew - 1) >= powerA.size())

return 0.;

return powerA[attackingCrew - 1];

{

if(static_cast<unsigned>(defendingCrew - 1) >= powerD.size())

return 0.;

return powerD[defendingCrew - 1];

{

if(powerD.empty() || powerA.empty())

return;

// The first row represents the case where the attacker has only one crew left.

// In that case, the defending ship can never be successfully captured.

capture.resize(powerD.size(), 0.);

casualtiesA.resize(powerD.size(), 0.);

casualtiesD.resize(powerD.size(), 0.);

unsigned up = 0;

for(unsigned a = 2; a <= powerA.size(); ++a)

{

double ap = powerA[a - 1];

// Special case: odds for defender having only one person,

// because 0 people is outside the end of the table.

double odds = ap / (ap + powerD[0]);

capture.push_back(odds + (1. - odds) * capture[up]);

casualtiesA.push_back((1. - odds) * (casualtiesA[up] + 1.));

casualtiesD.push_back(odds + (1. - odds) * casualtiesD[up]);

++up;

// Loop through each number of crew the defender might have.

for(unsigned d = 2; d <= powerD.size(); ++d)

{

// This is basic 2D dynamic program, where each value is based on

// the odds of success and the values for one fewer crew members

// for the defender or the attacker depending on who wins.

odds = ap / (ap + powerD[d - 1]);

capture.push_back(odds * capture.back() + (1. - odds) * capture[up]);

casualtiesA.push_back(odds * casualtiesA.back() + (1. - odds) * (casualtiesA[up] + 1.));

casualtiesD.push_back(odds * (casualtiesD.back() + 1.) + (1. - odds) * casualtiesD[up]);

++up;

}

}

{

if(static_cast<unsigned>(attackingCrew - 1) > powerA.size())

return -1;

if(static_cast<unsigned>(defendingCrew - 1) > powerD.size())

return -1;

return (attackingCrew - 1) * powerD.size() + (defendingCrew - 1);

{

vector<double> power;

if(!ship.Crew())

return power;

// Check for any outfits that assist with attacking or defending:

const string attribute = (isDefender ? "capture defense" : "capture attack");

const double crewPower = (isDefender ?

ship.GetGovernment()->CrewDefense() : ship.GetGovernment()->CrewAttack());

// Each crew member can wield one weapon. They use the most powerful ones

// that can be wielded by the remaining crew.

for(const auto &it : ship.Outfits())

{

double value = it.first->Get(attribute);

if(value > 0. && it.second > 0)

power.insert(power.end(), it.second, value);

}

// Use the best weapons first.

sort(power.begin(), power.end(), greater<double>());

// Resize the vector to have exactly one entry per crew member.

power.resize(ship.Crew(), 0.);

// Calculate partial sums. That is, power[N - 1] should be your total crew

// power when you have N crew left.

power.front() += crewPower;

for(unsigned i = 1; i < power.size(); ++i)

power[i] += power[i - 1] + crewPower;

return power;