void MapPanel::DrawTravelPlan() const
{
Color color(.4, .4, 0., 0.);
Ship *ship = player.Flagship();
bool hasHyper = ship ? ship->Attributes().Get("hyperdrive") : false;
bool hasJump = ship ? ship->Attributes().Get("jump drive") : false;
// Draw your current travel plan.
const System *previous = playerSystem;
for(int i = player.TravelPlan().size() - 1; i >= 0; --i)
{
const System *next = player.TravelPlan()[i];
bool hasLink = false;
if(hasHyper)
hasLink |= (find(previous->Links().begin(), previous->Links().end(), next)
!= previous->Links().end());
if(hasJump)
hasLink |= (find(previous->Neighbors().begin(), previous->Neighbors().end(), next)
!= previous->Neighbors().end());
if(!hasLink)
break;
Point from = next->Position() + center;
Point to = previous->Position() + center;
Point unit = (from - to).Unit() * 7.;
from -= unit;
to += unit;
LineShader::Draw(from, to, 3., color);
previous = next;
}
}
void Projectile::CheckLock(const Ship &target)
{
double base = hasLock ? 1. : .5;
hasLock = false;
// For each tracking type, calculate the probability that a lock will be
// lost in a given five-second period. Then, since this check is done every
// second, test against the fifth root of that probability.
if(weapon->Tracking())
hasLock |= Check(weapon->Tracking(), base);
// Optical tracking is about 15% for interceptors and 75% for medium warships.
if(weapon->OpticalTracking())
{
double weight = target.Mass() * target.Mass();
double probability = weapon->OpticalTracking() * weight / (200000. + weight);
hasLock |= Check(probability, base);
}
// Infrared tracking is 10% when heat is zero and 100% when heat is full.
if(weapon->InfraredTracking())
{
double probability = weapon->InfraredTracking() * min(1., target.Heat() + .1);
hasLock |= Check(probability, base);
}
// Radar tracking depends on whether the target ship has jamming capabilities.
// Jamming of 1 is enough to increase your chance of dodging to 50%.
if(weapon->RadarTracking())
{
double probability = weapon->RadarTracking() / (1. + target.Attributes().Get("radar jamming"));
hasLock |= Check(probability, base);
}
}
void ShipInfoDisplay::UpdateOutfits(const Ship &ship)
{
outfitLabels.clear();
outfitValues.clear();
outfitsHeight = 0;
int outfitsValue = 0;
map<string, map<string, int>> listing;
for(const auto &it : ship.Outfits())
{
listing[it.first->Category()][it.first->Name()] += it.second;
outfitsValue += it.first->Cost() * it.second;
}
for(const auto &cit : listing)
{
// Pad by 10 pixels before each category.
outfitLabels.push_back(string());
outfitValues.push_back(string());
outfitsHeight += 10;
outfitLabels.push_back(cit.first + ':');
outfitValues.push_back(string());
outfitsHeight += 20;
for(const auto &it : cit.second)
{
outfitLabels.push_back(it.first);
outfitValues.push_back(to_string(it.second));
outfitsHeight += 20;
}
}
// Pad by 10 pixels on the top and bottom.
outfitsHeight += 10;
saleLabels.clear();
saleValues.clear();
saleHeight = 0;
int totalValue = ship.Attributes().Cost();
saleLabels.push_back(string());
saleValues.push_back(string());
saleHeight += 10;
saleLabels.push_back("This ship will sell for:");
saleValues.push_back(string());
saleHeight += 20;
saleLabels.push_back("empty hull:");
saleValues.push_back(Format::Number(totalValue - outfitsValue) + " credits");
saleHeight += 20;
saleLabels.push_back(" + outfits:");
saleValues.push_back(Format::Number(outfitsValue) + " credits");
saleHeight += 20;
saleLabels.push_back("= total:");
saleValues.push_back(Format::Number(totalValue) + " credits");
saleHeight += 20;
// Pad by 10 pixels on the top and bottom.
saleHeight += 10;
}
void AI::PrepareForHyperspace(Ship &ship, Command &command)
{
int type = ship.HyperspaceType();
if(!type)
return;
Point direction = ship.GetTargetSystem()->Position() - ship.GetSystem()->Position();
if(type == 150)
{
direction = direction.Unit();
Point normal(-direction.Y(), direction.X());
double deviation = ship.Velocity().Dot(normal);
if(fabs(deviation) > ship.Attributes().Get("scram drive"))
{
// Need to maneuver; not ready to jump
if((ship.Facing().Unit().Dot(normal) < 0) == (deviation < 0))
// Thrusting from this angle is counterproductive
direction = -deviation * normal;
else
{
command |= Command::FORWARD;
// How much correction will be applied to deviation by thrusting
// as I turn back toward the jump direction.
double turnRateRadians = ship.TurnRate() * TO_RAD;
double cos = ship.Facing().Unit().Dot(direction);
// integral(t*sin(r*x), angle/r, 0) = t/r * (1 - cos(angle)), so:
double correctionWhileTurning = fabs(1 - cos) * ship.Acceleration() / turnRateRadians;
// (Note that this will always underestimate because thrust happens before turn)
if(fabs(deviation) - correctionWhileTurning > ship.Attributes().Get("scram drive"))
// Want to thrust from an even sharper angle
direction = -deviation * normal;
}
}
command.SetTurn(TurnToward(ship, direction));
}
// If we are moving too fast, point in the right direction.
else if(Stop(ship, command, ship.Attributes().Get("jump speed")))
{
if(type != 200)
command.SetTurn(TurnToward(ship, direction));
}
}
void AI::DoCloak(Ship &ship, Command &command, const list<shared_ptr<Ship>> &ships)
{
if(ship.Attributes().Get("cloak"))
{
// Never cloak if it will cause you to be stranded.
if(ship.Attributes().Get("cloaking fuel") && !ship.Attributes().Get("ramscoop"))
{
double fuel = ship.Fuel() * ship.Attributes().Get("fuel capacity");
fuel -= ship.Attributes().Get("cloaking fuel");
if(fuel < ship.JumpFuel())
return;
}
// Otherwise, always cloak if you are in imminent danger.
static const double MAX_RANGE = 10000.;
double nearestEnemy = MAX_RANGE;
for(const auto &other : ships)
if(other->GetSystem() == ship.GetSystem() && other->IsTargetable() &&
other->GetGovernment()->IsEnemy(ship.GetGovernment()))
nearestEnemy = min(nearestEnemy,
ship.Position().Distance(other->Position()));
if(ship.Hull() + ship.Shields() < 1. && nearestEnemy < 2000.)
command |= Command::CLOAK;
// Also cloak if there are no enemies nearby and cloaking does
// not cost you fuel.
if(nearestEnemy == MAX_RANGE && !ship.Attributes().Get("cloaking fuel"))
command |= Command::CLOAK;
}
}
// Find out how many of these I can take if I have this amount of cargo
// space free.
bool BoardingPanel::Plunder::CanTake(const Ship &ship) const
{
// If there's cargo space for this outfit, you can take it.
double mass = UnitMass();
if(ship.Cargo().Free() >= mass)
return true;
// Otherwise, check if it is ammo for any of your weapons. If so, check if
// you can install it as an outfit.
if(outfit)
for(const auto &it : ship.Outfits())
if(it.first != outfit && it.first->Ammo() == outfit && ship.Attributes().CanAdd(*outfit))
return true;
return false;
}
void AI::MoveEscort(Ship &ship, Command &command)
{
const Ship &parent = *ship.GetParent();
bool isStaying = ship.GetPersonality().IsStaying();
// If an escort is out of fuel, they should refuel without waiting for the
// "parent" to land (because the parent may not be planning on landing).
if(ship.Attributes().Get("fuel capacity") && !ship.JumpsRemaining() && ship.GetSystem()->IsInhabited())
Refuel(ship, command);
else if(ship.GetSystem() != parent.GetSystem() && !isStaying)
{
DistanceMap distance(ship, parent.GetSystem());
const System *system = distance.Route(ship.GetSystem());
ship.SetTargetSystem(system);
if(!system || (ship.GetSystem()->IsInhabited() && !system->IsInhabited() && ship.JumpsRemaining() == 1))
Refuel(ship, command);
else
{
PrepareForHyperspace(ship, command);
command |= Command::JUMP;
}
}
else if(parent.Commands().Has(Command::LAND) && parent.GetTargetPlanet())
{
ship.SetTargetPlanet(parent.GetTargetPlanet());
MoveToPlanet(ship, command);
if(parent.IsLanding() || parent.CanLand())
command |= Command::LAND;
}
else if(parent.Commands().Has(Command::BOARD) && parent.GetTargetShip().get() == &ship)
Stop(ship, command);
else if(parent.Commands().Has(Command::JUMP) && parent.GetTargetSystem() && !isStaying)
{
DistanceMap distance(ship, parent.GetTargetSystem());
const System *dest = distance.Route(ship.GetSystem());
ship.SetTargetSystem(dest);
if(!dest || (dest != parent.GetTargetSystem() && !dest->IsInhabited() && ship.JumpsRemaining() == 1))
Refuel(ship, command);
else
{
PrepareForHyperspace(ship, command);
if(parent.IsEnteringHyperspace() || parent.CheckHyperspace())
command |= Command::JUMP;
}
}
else
CircleAround(ship, command, parent);
}
void Engine::AddSprites(const Ship &ship)
{
bool hasFighters = ship.PositionFighters();
double cloak = ship.Cloaking();
bool drawCloaked = (cloak && ship.GetGovernment()->IsPlayer());
if(ship.IsThrusting())
for(const Point &point : ship.EnginePoints())
{
Point pos = ship.Facing().Rotate(point) * ship.Zoom() + ship.Position();
// If multiple engines with the same flare are installed, draw up to
// three copies of the flare sprite.
for(const auto &it : ship.Attributes().FlareSprites())
for(int i = 0; i < it.second && i < 3; ++i)
{
Body sprite(it.first, pos, ship.Velocity(), ship.Facing());
draw[calcTickTock].Add(sprite, cloak);
}
}
if(hasFighters)
for(const Ship::Bay &bay : ship.Bays())
if(bay.side == Ship::Bay::UNDER && bay.ship)
{
if(drawCloaked)
draw[calcTickTock].AddSwizzled(*bay.ship, 7);
draw[calcTickTock].Add(*bay.ship, cloak);
}
if(drawCloaked)
draw[calcTickTock].AddSwizzled(ship, 7);
draw[calcTickTock].Add(ship, cloak);
if(hasFighters)
for(const Ship::Bay &bay : ship.Bays())
if(bay.side == Ship::Bay::OVER && bay.ship)
{
if(drawCloaked)
draw[calcTickTock].AddSwizzled(*bay.ship, 7);
draw[calcTickTock].Add(*bay.ship, cloak);
}
}
void MissionAction::Do(PlayerInfo &player, UI *ui, const System *destination) const
{
bool isOffer = (trigger == "offer");
if(!conversation.IsEmpty())
{
ConversationPanel *panel = new ConversationPanel(player, conversation, destination);
if(isOffer)
panel->SetCallback(&player, &PlayerInfo::MissionCallback);
ui->Push(panel);
}
else if(!dialogText.empty())
{
map<string, string> subs;
subs["<first>"] = player.FirstName();
subs["<last>"] = player.LastName();
if(player.Flagship())
subs["<ship>"] = player.Flagship()->Name();
string text = Format::Replace(dialogText, subs);
if(isOffer)
ui->Push(new Dialog(text, player, destination));
else
ui->Push(new Dialog(text));
}
else if(isOffer && ui)
player.MissionCallback(Conversation::ACCEPT);
Ship *flagship = player.Flagship();
for(const auto &it : gifts)
{
int count = it.second;
string name = it.first->Name();
if(!count || name.empty())
continue;
string message;
if(abs(count) == 1)
{
char c = tolower(name.front());
bool isVowel = (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
message = (isVowel ? "An " : "A ") + name + " was ";
}
else
message = to_string(abs(count)) + " " + name + "s were ";
if(count > 0)
message += "added to your ";
else
message += "removed from your ";
bool didCargo = false;
bool didShip = false;
int cargoCount = player.Cargo().Get(it.first);
if(count < 0 && cargoCount)
{
int moved = min(cargoCount, -count);
count += moved;
player.Cargo().Transfer(it.first, moved);
didCargo = true;
}
while(flagship && count)
{
int moved = (count > 0) ? 1 : -1;
if(flagship->Attributes().CanAdd(*it.first, moved))
{
flagship->AddOutfit(it.first, moved);
didShip = true;
}
else
break;
count -= moved;
}
if(count > 0)
{
player.Cargo().Transfer(it.first, -count);
didCargo = true;
if(count > 0)
{
string special = "The " + name + (count == 1 ? " was" : "s were");
special += " put in your cargo hold because there is not enough space to install ";
special += (count == 1) ? "it" : "them";
special += " in your ship.";
ui->Push(new Dialog(special));
}
}
if(didCargo && didShip)
message += "cargo hold and your flagship.";
else if(didCargo)
message += "cargo hold.";
else
message += "flagship.";
Messages::Add(message);
}
if(payment)
player.Accounts().AddCredits(payment);
for(const auto &it : events)
player.AddEvent(*GameData::Events().Get(it.first), player.GetDate() + it.second);
conditions.Apply(player.Conditions());
}
void MapPanel::DrawTravelPlan() const
{
Color defaultColor(.5, .4, 0., 0.);
Color outOfFlagshipFuelRangeColor(.55, .1, .0, 0.);
Color withinFleetFuelRangeColor(.2, .5, .0, 0.);
Color wormholeColor(0.5, 0.2, 0.9, 1.);
Ship *ship = player.Flagship();
bool hasHyper = ship ? ship->Attributes().Get("hyperdrive") : false;
bool hasJump = ship ? ship->Attributes().Get("jump drive") : false;
// Find out how much fuel your ship and your escorts use per jump.
double flagshipCapacity = 0.;
if(ship)
flagshipCapacity = ship->Attributes().Get("fuel capacity") * ship->Fuel();
double flagshipJumpFuel = 0.;
if(ship)
flagshipJumpFuel = hasHyper ? ship->Attributes().Get("scram drive") ? 150. : 100. : 200.;
double escortCapacity = 0.;
double escortJumpFuel = 1.;
bool escortHasJump = false;
// Skip your flagship, parked ships, and fighters.
for(const shared_ptr<Ship> &it : player.Ships())
if(it.get() != ship && !it->IsParked() && !it->CanBeCarried())
{
double capacity = it->Attributes().Get("fuel capacity") * it->Fuel();
double jumpFuel = it->Attributes().Get("hyperdrive") ?
it->Attributes().Get("scram drive") ? 150. : 100. : 200.;
if(escortJumpFuel < 100. || capacity / jumpFuel < escortCapacity / escortJumpFuel)
{
escortCapacity = capacity;
escortJumpFuel = jumpFuel;
escortHasJump = it->Attributes().Get("jump drive");
}
}
// Draw your current travel plan.
if(!playerSystem)
return;
const System *previous = playerSystem;
for(int i = player.TravelPlan().size() - 1; i >= 0; --i)
{
const System *next = player.TravelPlan()[i];
// Figure out what kind of jump this is, and check if the player is able
// to make jumps of that kind.
bool isHyper =
(find(previous->Links().begin(), previous->Links().end(), next)
!= previous->Links().end());
bool isJump = isHyper ||
(find(previous->Neighbors().begin(), previous->Neighbors().end(), next)
!= previous->Neighbors().end());
bool isWormhole = false;
if(!((isHyper && hasHyper) || (isJump && hasJump)))
{
for(const StellarObject &object : previous->Objects())
isWormhole |= (object.GetPlanet() && object.GetPlanet()->WormholeDestination(previous) == next);
if(!isWormhole)
break;
}
Point from = Zoom() * (next->Position() + center);
Point to = Zoom() * (previous->Position() + center);
Point unit = (from - to).Unit() * 7.;
from -= unit;
to += unit;
if(isWormhole)
{
// Wormholes cost no fuel to travel through.
}
else if(!isHyper)
{
if(!escortHasJump)
escortCapacity = 0.;
flagshipCapacity -= 200.;
escortCapacity -= 200.;
}
else
{
flagshipCapacity -= flagshipJumpFuel;
escortCapacity -= escortJumpFuel;
}
Color drawColor = outOfFlagshipFuelRangeColor;
if(isWormhole)
drawColor = wormholeColor;
else if(flagshipCapacity >= 0. && escortCapacity >= 0.)
drawColor = withinFleetFuelRangeColor;
else if(flagshipCapacity >= 0. || escortCapacity >= 0.)
drawColor = defaultColor;
LineShader::Draw(from, to, 3., drawColor);
previous = next;
}
}
void AI::MoveIndependent(Ship &ship, Command &command) const
{
if(ship.Position().Length() >= 10000.)
{
MoveTo(ship, command, Point(), 40., .8);
return;
}
shared_ptr<const Ship> target = ship.GetTargetShip();
if(target && (ship.GetGovernment()->IsEnemy(target->GetGovernment())
|| (ship.IsYours() && target == sharedTarget.lock())))
{
bool shouldBoard = ship.Cargo().Free() && ship.GetPersonality().Plunders();
bool hasBoarded = Has(ship, target, ShipEvent::BOARD);
if(shouldBoard && target->IsDisabled() && !hasBoarded)
{
if(ship.IsBoarding())
return;
MoveTo(ship, command, target->Position(), 40., .8);
command |= Command::BOARD;
}
else
Attack(ship, command, *target);
return;
}
else if(target)
{
bool cargoScan = ship.Attributes().Get("cargo scan");
bool outfitScan = ship.Attributes().Get("outfit scan");
if((!cargoScan || Has(ship, target, ShipEvent::SCAN_CARGO))
&& (!outfitScan || Has(ship, target, ShipEvent::SCAN_OUTFITS)))
target.reset();
else
{
CircleAround(ship, command, *target);
if(!ship.GetGovernment()->IsPlayer())
command |= Command::SCAN;
}
return;
}
// If this ship is moving independently because it has a target, not because
// it has no parent, don't let it make travel plans.
if(ship.GetParent() && !ship.GetPersonality().IsStaying())
return;
if(!ship.GetTargetSystem() && !ship.GetTargetPlanet() && !ship.GetPersonality().IsStaying())
{
int jumps = ship.JumpsRemaining();
// Each destination system has an average priority of 10.
// If you only have one jump left, landing should be high priority.
int planetWeight = jumps ? (1 + 40 / jumps) : 1;
vector<int> systemWeights;
int totalWeight = 0;
const vector<const System *> &links = ship.Attributes().Get("jump drive")
? ship.GetSystem()->Neighbors() : ship.GetSystem()->Links();
if(jumps)
{
for(const System *link : links)
{
// Prefer systems in the direction we're facing.
Point direction = link->Position() - ship.GetSystem()->Position();
int weight = static_cast<int>(
11. + 10. * ship.Facing().Unit().Dot(direction.Unit()));
systemWeights.push_back(weight);
totalWeight += weight;
}
}
int systemTotalWeight = totalWeight;
// Anywhere you can land that has a port has the same weight. Ships will
// not land anywhere without a port.
vector<const StellarObject *> planets;
for(const StellarObject &object : ship.GetSystem()->Objects())
if(object.GetPlanet() && object.GetPlanet()->HasSpaceport()
&& object.GetPlanet()->CanLand(ship))
{
planets.push_back(&object);
totalWeight += planetWeight;
}
if(!totalWeight)
return;
int choice = Random::Int(totalWeight);
if(choice < systemTotalWeight)
{
for(unsigned i = 0; i < systemWeights.size(); ++i)
{
choice -= systemWeights[i];
if(choice < 0)
{
ship.SetTargetSystem(links[i]);
break;
}
}
}
else
{
choice = (choice - systemTotalWeight) / planetWeight;
ship.SetTargetPlanet(planets[choice]);
}
}
if(ship.GetTargetSystem())
{
PrepareForHyperspace(ship, command);
bool mustWait = false;
for(const weak_ptr<const Ship> &escort : ship.GetEscorts())
{
shared_ptr<const Ship> locked = escort.lock();
mustWait = locked && locked->CanBeCarried();
}
if(!mustWait)
command |= Command::JUMP;
}
else if(ship.GetTargetPlanet())
{
MoveToPlanet(ship, command);
if(!ship.GetPersonality().IsStaying())
command |= Command::LAND;
else if(ship.Position().Distance(ship.GetTargetPlanet()->Position()) < 100.)
ship.SetTargetPlanet(nullptr);
}
else if(ship.GetPersonality().IsStaying() && ship.GetSystem()->Objects().size())
{
unsigned i = Random::Int(ship.GetSystem()->Objects().size());
ship.SetTargetPlanet(&ship.GetSystem()->Objects()[i]);
}
}
// Pick a new target for the given ship.
shared_ptr<Ship> AI::FindTarget(const Ship &ship, const list<shared_ptr<Ship>> &ships) const
{
// If this ship has no government, it has no enemies.
shared_ptr<Ship> target;
const Government *gov = ship.GetGovernment();
if(!gov)
return target;
bool isPlayerEscort = ship.IsYours();
if(isPlayerEscort)
{
shared_ptr<Ship> locked = sharedTarget.lock();
if(locked && locked->GetSystem() == ship.GetSystem() && !locked->IsDisabled())
return locked;
}
// If this ship is not armed, do not make it fight.
double minRange = numeric_limits<double>::infinity();
double maxRange = 0.;
for(const Armament::Weapon &weapon : ship.Weapons())
if(weapon.GetOutfit() && !weapon.IsAntiMissile())
{
minRange = min(minRange, weapon.GetOutfit()->Range());
maxRange = max(maxRange, weapon.GetOutfit()->Range());
}
if(!maxRange)
return target;
shared_ptr<Ship> oldTarget = ship.GetTargetShip();
if(oldTarget && !oldTarget->IsTargetable())
oldTarget.reset();
shared_ptr<Ship> parentTarget;
if(ship.GetParent())
parentTarget = ship.GetParent()->GetTargetShip();
if(parentTarget && !parentTarget->IsTargetable())
parentTarget.reset();
// Find the closest enemy ship (if there is one). If this ship is "heroic,"
// it will attack any ship in system. Otherwise, if all its weapons have a
// range higher than 2000, it will engage ships up to 50% beyond its range.
// If a ship has short range weapons and is not heroic, it will engage any
// ship that is within 3000 of it.
const Personality &person = ship.GetPersonality();
double closest = person.IsHeroic() ? numeric_limits<double>::infinity() :
(minRange > 1000.) ? maxRange * 1.5 : 4000.;
const System *system = ship.GetSystem();
bool isDisabled = false;
for(const auto &it : ships)
if(it->GetSystem() == system && it->IsTargetable() && gov->IsEnemy(it->GetGovernment()))
{
if(person.IsNemesis() && !it->GetGovernment()->IsPlayer())
continue;
double range = it->Position().Distance(ship.Position());
// Preferentially focus on your previous target or your parent ship's
// target if they are nearby.
if(it == oldTarget || it == parentTarget)
range -= 500.;
// If your personality it to disable ships rather than destroy them,
// never target disabled ships.
if(it->IsDisabled() && !person.Plunders()
&& (person.Disables() || (!person.IsNemesis() && it != oldTarget)))
continue;
if(!person.Plunders())
range += 5000. * it->IsDisabled();
else
{
bool hasBoarded = Has(ship, it, ShipEvent::BOARD);
// Don't plunder unless there are no "live" enemies nearby.
range += 2000. * (2 * it->IsDisabled() - !hasBoarded);
}
// Focus on nearly dead ships.
range += 500. * (it->Shields() + it->Hull());
if(range < closest)
{
closest = range;
target = it;
isDisabled = it->IsDisabled();
}
}
bool cargoScan = ship.Attributes().Get("cargo scan");
bool outfitScan = ship.Attributes().Get("outfit scan");
if(!target && (cargoScan || outfitScan) && !isPlayerEscort)
{
closest = numeric_limits<double>::infinity();
for(const auto &it : ships)
if(it->GetSystem() == system && it->GetGovernment() != gov && it->IsTargetable())
{
if((cargoScan && !Has(ship, it, ShipEvent::SCAN_CARGO))
|| (outfitScan && !Has(ship, it, ShipEvent::SCAN_OUTFITS)))
{
double range = it->Position().Distance(ship.Position());
if(range < closest)
{
closest = range;
target = it;
}
}
}
}
// Run away if your target is not disabled and you are badly damaged.
if(!isDisabled && (ship.GetPersonality().IsFleeing() ||
(ship.Shields() + ship.Hull() < 1. && !ship.GetPersonality().IsHeroic())))
target.reset();
return target;
}
void AI::MovePlayer(Ship &ship, const PlayerInfo &player, const list<shared_ptr<Ship>> &ships)
{
Command command;
if(player.HasTravelPlan())
{
const System *system = player.TravelPlan().back();
ship.SetTargetSystem(system);
// Check if there's a particular planet there we want to visit.
for(const Mission &mission : player.Missions())
if(mission.Destination() && mission.Destination()->GetSystem() == system)
{
ship.SetDestination(mission.Destination());
break;
}
}
if(keyDown.Has(Command::NEAREST))
{
double closest = numeric_limits<double>::infinity();
int closeState = 0;
for(const shared_ptr<Ship> &other : ships)
if(other.get() != &ship && other->IsTargetable())
{
// Sort ships into one of three priority states:
// 0 = friendly, 1 = disabled enemy, 2 = active enemy.
int state = other->GetGovernment()->IsEnemy(ship.GetGovernment());
// Do not let "target nearest" select a friendly ship, so that
// if the player is repeatedly targeting nearest to, say, target
// a bunch of fighters, they won't start firing on friendly
// ships as soon as the last one is gone.
if((!state && !shift) || other->GetGovernment()->IsPlayer())
continue;
state += state * !other->IsDisabled();
double d = other->Position().Distance(ship.Position());
if(state > closeState || (state == closeState && d < closest))
{
ship.SetTargetShip(other);
closest = d;
closeState = state;
}
}
}
else if(keyDown.Has(Command::TARGET))
{
shared_ptr<const Ship> target = ship.GetTargetShip();
bool selectNext = !target || !target->IsTargetable();
for(const shared_ptr<Ship> &other : ships)
{
bool isPlayer = other->GetGovernment()->IsPlayer() || other->GetPersonality().IsEscort();
if(other == target)
selectNext = true;
else if(other.get() != &ship && selectNext && other->IsTargetable() && isPlayer == shift)
{
ship.SetTargetShip(other);
selectNext = false;
break;
}
}
if(selectNext)
ship.SetTargetShip(shared_ptr<Ship>());
}
else if(keyDown.Has(Command::BOARD))
{
shared_ptr<const Ship> target = ship.GetTargetShip();
if(!target || !target->IsDisabled() || target->IsDestroyed() || target->GetSystem() != ship.GetSystem())
{
double closest = numeric_limits<double>::infinity();
bool foundEnemy = false;
bool foundAnything = false;
for(const shared_ptr<Ship> &other : ships)
if(other->IsTargetable() && other->IsDisabled() && !other->IsDestroyed())
{
bool isEnemy = other->GetGovernment()->IsEnemy(ship.GetGovernment());
double d = other->Position().Distance(ship.Position());
if((isEnemy && !foundEnemy) || d < closest)
{
closest = d;
foundEnemy = isEnemy;
foundAnything = true;
ship.SetTargetShip(other);
}
}
if(!foundAnything)
keyDown.Clear(Command::BOARD);
}
}
else if(keyDown.Has(Command::LAND))
{
// If the player is right over an uninhabited planet, display a message
// explaining why they cannot land there.
string message;
for(const StellarObject &object : ship.GetSystem()->Objects())
if(!object.GetPlanet() && !object.GetSprite().IsEmpty())
{
double distance = ship.Position().Distance(object.Position());
if(distance < object.Radius())
message = object.LandingMessage();
}
const StellarObject *target = ship.GetTargetPlanet();
if(target && ship.Position().Distance(target->Position()) < target->Radius())
{
// Special case: if there are two planets in system and you have one
// selected, then press "land" again, do not toggle to the other if
// you are within landing range of the one you have selected.
}
else if(message.empty() && target)
{
bool found = false;
const StellarObject *next = nullptr;
for(const StellarObject &object : ship.GetSystem()->Objects())
if(object.GetPlanet())
{
if(found)
{
next = &object;
break;
}
else if(&object == ship.GetTargetPlanet())
found = true;
}
if(!next)
{
for(const StellarObject &object : ship.GetSystem()->Objects())
if(object.GetPlanet())
{
next = &object;
break;
}
}
ship.SetTargetPlanet(next);
if(next->GetPlanet() && !next->GetPlanet()->CanLand())
message = "The authorities on this planet refuse to clear you to land here.";
}
else if(message.empty())
{
double closest = numeric_limits<double>::infinity();
int count = 0;
for(const StellarObject &object : ship.GetSystem()->Objects())
if(object.GetPlanet())
{
++count;
double distance = ship.Position().Distance(object.Position());
const Planet *planet = object.GetPlanet();
if(planet == ship.GetDestination())
distance = 0.;
else if(!planet->HasSpaceport() && !planet->IsWormhole())
distance += 10000.;
if(distance < closest)
{
ship.SetTargetPlanet(&object);
closest = distance;
}
}
if(!ship.GetTargetPlanet())
message = "There are no planets in this system that you can land on.";
else if(!ship.GetTargetPlanet()->GetPlanet()->CanLand())
message = "The authorities on this planet refuse to clear you to land here.";
else if(count > 1)
{
message = "You can land on more than one planet in this system. Landing on ";
if(ship.GetTargetPlanet()->Name().empty())
message += "???.";
else
message += ship.GetTargetPlanet()->Name() + ".";
}
}
if(!message.empty())
Messages::Add(message);
}
else if(keyDown.Has(Command::JUMP))
{
if(!ship.GetTargetSystem())
{
double bestMatch = -2.;
const auto &links = (ship.Attributes().Get("jump drive") ?
ship.GetSystem()->Neighbors() : ship.GetSystem()->Links());
for(const System *link : links)
{
Point direction = link->Position() - ship.GetSystem()->Position();
double match = ship.Facing().Unit().Dot(direction.Unit());
if(match > bestMatch)
{
bestMatch = match;
ship.SetTargetSystem(link);
}
}
}
}
else if(keyDown.Has(Command::SCAN))
command |= Command::SCAN;
bool hasGuns = Preferences::Has("Automatic firing") && !ship.IsBoarding()
&& !(keyStuck | keyHeld).Has(Command::LAND | Command::JUMP | Command::BOARD);
if(hasGuns)
command |= AutoFire(ship, ships, false);
hasGuns |= keyHeld.Has(Command::PRIMARY);
if(keyHeld)
{
if(keyHeld.Has(Command::RIGHT | Command::LEFT))
command.SetTurn(keyHeld.Has(Command::RIGHT) - keyHeld.Has(Command::LEFT));
else if(keyHeld.Has(Command::BACK))
{
if(ship.Attributes().Get("reverse thrust"))
command |= Command::BACK;
else
command.SetTurn(TurnBackward(ship));
}
if(keyHeld.Has(Command::FORWARD))
command |= Command::FORWARD;
if(keyHeld.Has(Command::PRIMARY))
{
int index = 0;
for(const Armament::Weapon &weapon : ship.Weapons())
{
const Outfit *outfit = weapon.GetOutfit();
if(outfit && !outfit->Icon())
{
command.SetFire(index);
hasGuns |= !weapon.IsTurret();
}
++index;
}
}
if(keyHeld.Has(Command::SECONDARY))
{
int index = 0;
for(const Armament::Weapon &weapon : ship.Weapons())
{
const Outfit *outfit = weapon.GetOutfit();
if(outfit && outfit == player.SelectedWeapon())
command.SetFire(index);
++index;
}
}
if(keyHeld.Has(Command::AFTERBURNER))
command |= Command::AFTERBURNER;
if(keyHeld.Has(AutopilotCancelKeys()))
keyStuck = keyHeld;
}
if(hasGuns && Preferences::Has("Automatic aiming") && !command.Turn()
&& ship.GetTargetShip() && ship.GetTargetShip()->GetSystem() == ship.GetSystem()
&& !keyStuck.Has(Command::LAND | Command::JUMP | Command::BOARD))
{
Point distance = ship.GetTargetShip()->Position() - ship.Position();
if(distance.Unit().Dot(ship.Facing().Unit()) >= .8)
command.SetTurn(TurnToward(ship, TargetAim(ship)));
}
if(ship.IsBoarding())
keyStuck.Clear();
else if(keyStuck.Has(Command::LAND) && ship.GetTargetPlanet())
{
if(ship.GetPlanet())
keyStuck.Clear();
else
{
MoveToPlanet(ship, command);
command |= Command::LAND;
}
}
else if(keyStuck.Has(Command::JUMP) && ship.GetTargetSystem())
{
if(!ship.Attributes().Get("hyperdrive") && !ship.Attributes().Get("jump drive"))
{
Messages::Add("You do not have a hyperdrive installed.");
keyStuck.Clear();
}
else if(!ship.HyperspaceType())
{
Messages::Add("You cannot jump to the selected system.");
keyStuck.Clear();
}
else if(!ship.JumpsRemaining() && !ship.IsEnteringHyperspace())
{
Messages::Add("You do not have enough fuel to make a hyperspace jump.");
keyStuck.Clear();
}
else if(!ship.GetTargetSystem())
keyStuck.Clear();
else
{
PrepareForHyperspace(ship, command);
command |= Command::JUMP;
if(keyHeld.Has(Command::JUMP))
command |= Command::WAIT;
}
}
else if(keyStuck.Has(Command::BOARD) && ship.GetTargetShip())
{
shared_ptr<const Ship> target = ship.GetTargetShip();
if(!target || !target->IsTargetable() || !target->IsDisabled() || target->IsDestroyed())
keyStuck.Clear(Command::BOARD);
else
{
MoveTo(ship, command, target->Position(), 40., .8);
command |= Command::BOARD;
}
}
if(isLaunching)
command |= Command::DEPLOY;
if(isCloaking)
command |= Command::CLOAK;
ship.SetCommands(command);
}
// Fire whichever of the given ship's weapons can hit a hostile target.
Command AI::AutoFire(const Ship &ship, const list<shared_ptr<Ship>> &ships, bool secondary) const
{
Command command;
int index = -1;
// Special case: your target is not your enemy. Do not fire, because you do
// not want to risk damaging that target. The only time a ship other than
// the player will target a friendly ship is if the player has asked a ship
// for assistance.
shared_ptr<Ship> currentTarget = ship.GetTargetShip();
const Government *gov = ship.GetGovernment();
bool isSharingTarget = ship.IsYours() && currentTarget == sharedTarget.lock();
bool currentIsEnemy = currentTarget
&& currentTarget->GetGovernment()->IsEnemy(gov)
&& currentTarget->GetSystem() == ship.GetSystem();
if(currentTarget && !(currentIsEnemy || isSharingTarget))
currentTarget.reset();
// Only fire on disabled targets if you don't want to plunder them.
bool spareDisabled = (ship.GetPersonality().Disables() || ship.GetPersonality().Plunders());
// Find the longest range of any of your non-homing weapons.
double maxRange = 0.;
for(const Armament::Weapon &weapon : ship.Weapons())
if(weapon.IsReady() && !weapon.IsHoming() && (secondary || !weapon.GetOutfit()->Icon()))
maxRange = max(maxRange, weapon.GetOutfit()->Range());
// Extend the weapon range slightly to account for velocity differences.
maxRange *= 1.5;
// Find all enemy ships within range of at least one weapon.
vector<shared_ptr<const Ship>> enemies;
if(currentTarget)
enemies.push_back(currentTarget);
for(auto target : ships)
if(target->IsTargetable() && gov->IsEnemy(target->GetGovernment())
&& target->Velocity().Length() < 20.
&& target->GetSystem() == ship.GetSystem()
&& target->Position().Distance(ship.Position()) < maxRange
&& target != currentTarget)
enemies.push_back(target);
for(const Armament::Weapon &weapon : ship.Weapons())
{
++index;
// Skip weapons that are not ready to fire. Also skip homing weapons if
// no target is selected, and secondary weapons if only firing primaries.
if(!weapon.IsReady() || (!currentTarget && weapon.IsHoming()))
continue;
if(!secondary && weapon.GetOutfit()->Icon())
continue;
// Special case: if the weapon uses fuel, be careful not to spend so much
// fuel that you cannot leave the system if necessary.
if(weapon.GetOutfit()->FiringFuel())
{
double fuel = ship.Fuel() * ship.Attributes().Get("fuel capacity");
fuel -= weapon.GetOutfit()->FiringFuel();
// If the ship is not ever leaving this system, it does not need to
// reserve any fuel.
bool isStaying = ship.GetPersonality().IsStaying();
if(!secondary || fuel < (isStaying ? 0. : ship.JumpFuel()))
continue;
}
// Figure out where this weapon will fire from, but add some randomness
// depending on how accurate this ship's pilot is.
Point start = ship.Position() + ship.Facing().Rotate(weapon.GetPoint());
start += ship.GetPersonality().Confusion();
const Outfit *outfit = weapon.GetOutfit();
double vp = outfit->Velocity();
double lifetime = outfit->TotalLifetime();
if(currentTarget && (weapon.IsHoming() || weapon.IsTurret()))
{
bool hasBoarded = Has(ship, currentTarget, ShipEvent::BOARD);
if(currentTarget->IsDisabled() && spareDisabled && !hasBoarded)
continue;
Point p = currentTarget->Position() - start;
Point v = currentTarget->Velocity() - ship.Velocity();
// By the time this action is performed, the ships will have moved
// forward one time step.
p += v;
if(p.Length() < outfit->BlastRadius())
continue;
double steps = Armament::RendevousTime(p, v, vp);
if(steps == steps && steps <= lifetime)
{
command.SetFire(index);
continue;
}
}
// Don't fire homing weapons with no target.
if(weapon.IsHoming())
continue;
for(const shared_ptr<const Ship> &target : enemies)
{
if(!target->IsTargetable()
|| target->Velocity().Length() > 20.
|| target->GetSystem() != ship.GetSystem())
continue;
// Don't shoot ships we want to plunder.
bool hasBoarded = Has(ship, target, ShipEvent::BOARD);
if(target->IsDisabled() && spareDisabled && !hasBoarded)
continue;
Point p = target->Position() - start;
Point v = target->Velocity() - ship.Velocity();
// By the time this action is performed, the ships will have moved
// forward one time step.
p += v;
// Get the vector the weapon will travel along.
v = (ship.Facing() + weapon.GetAngle()).Unit() * vp - v;
// Extrapolate over the lifetime of the projectile.
v *= lifetime;
const Mask &mask = target->GetSprite().GetMask(step);
if(mask.Collide(-p, v, target->Facing()) < 1.)
{
command.SetFire(index);
break;
}
}
}
return command;
}
void ShipInfoDisplay::UpdateAttributes(const Ship &ship)
{
attributeLabels.clear();
attributeValues.clear();
attributesHeight = 10;
const Outfit &attributes = ship.Attributes();
attributeLabels.push_back(string());
attributeValues.push_back(string());
attributesHeight += 10;
attributeLabels.push_back("cost:");
attributeValues.push_back(Format::Number(ship.Cost()));
attributesHeight += 20;
attributeLabels.push_back(string());
attributeValues.push_back(string());
attributesHeight += 10;
if(attributes.Get("shield generation"))
{
attributeLabels.push_back("shields charge / max:");
attributeValues.push_back(Format::Number(60. * attributes.Get("shield generation"))
+ " / " + Format::Number(attributes.Get("shields")));
}
else
{
attributeLabels.push_back("shields:");
attributeValues.push_back(Format::Number(attributes.Get("shields")));
}
attributesHeight += 20;
if(attributes.Get("hull repair rate"))
{
attributeLabels.push_back("hull repair / max:");
attributeValues.push_back(Format::Number(60. * attributes.Get("hull repair rate"))
+ " / " + Format::Number(attributes.Get("hull")));
}
else
{
attributeLabels.push_back("hull:");
attributeValues.push_back(Format::Number(attributes.Get("hull")));
}
attributesHeight += 20;
double emptyMass = attributes.Get("mass");
attributeLabels.push_back("mass with no cargo:");
attributeValues.push_back(Format::Number(emptyMass));
attributesHeight += 20;
attributeLabels.push_back("cargo space:");
attributeValues.push_back(Format::Number(attributes.Get("cargo space")));
attributesHeight += 20;
attributeLabels.push_back("required crew / bunks:");
attributeValues.push_back(Format::Number(ship.RequiredCrew())
+ " / " + Format::Number(attributes.Get("bunks")));
attributesHeight += 20;
attributeLabels.push_back("fuel capacity:");
attributeValues.push_back(Format::Number(attributes.Get("fuel capacity")));
attributesHeight += 20;
double fullMass = emptyMass + attributes.Get("cargo space");
attributeLabels.push_back(string());
attributeValues.push_back(string());
attributesHeight += 10;
attributeLabels.push_back((emptyMass == fullMass) ? "movement:" : "movement, full / no cargo:");
attributeValues.push_back(string());
attributesHeight += 20;
attributeLabels.push_back("max speed:");
attributeValues.push_back(Format::Number(60. * attributes.Get("thrust") / attributes.Get("drag")));
attributesHeight += 20;
attributeLabels.push_back("acceleration:");
if(emptyMass == fullMass)
attributeValues.push_back(Format::Number(3600. * attributes.Get("thrust") / fullMass));
else
attributeValues.push_back(Format::Number(3600. * attributes.Get("thrust") / fullMass)
+ " / " + Format::Number(3600. * attributes.Get("thrust") / emptyMass));
attributesHeight += 20;
attributeLabels.push_back("turning:");
if(emptyMass == fullMass)
attributeValues.push_back(Format::Number(60. * attributes.Get("turn") / fullMass));
else
attributeValues.push_back(Format::Number(60. * attributes.Get("turn") / fullMass)
+ " / " + Format::Number(60. * attributes.Get("turn") / emptyMass));
attributesHeight += 20;
// Find out how much outfit, engine, and weapon space the chassis has.
map<string, double> chassis;
static const string names[] = {
"outfit space free:", "outfit space",
" weapon capacity:", "weapon capacity",
" engine capacity:", "engine capacity",
"guns ports free:", "gun ports",
"turret mounts free:", "turret mounts"
};
static const int NAMES = sizeof(names) / sizeof(names[0]);
for(int i = 1; i < NAMES; i += 2)
chassis[names[i]] = attributes.Get(names[i]);
for(const auto &it : ship.Outfits())
for(auto &cit : chassis)
cit.second -= it.second * it.first->Get(cit.first);
attributeLabels.push_back(string());
attributeValues.push_back(string());
attributesHeight += 10;
for(int i = 0; i < NAMES; i += 2)
{
attributeLabels.push_back(names[i]);
attributeValues.push_back(Format::Number(attributes.Get(names[i + 1]))
+ " / " + Format::Number(chassis[names[i + 1]]));
attributesHeight += 20;
}
if(ship.DroneBaysFree())
{
attributeLabels.push_back("drone bays:");
attributeValues.push_back(to_string(ship.DroneBaysFree()));
attributesHeight += 20;
}
if(ship.FighterBaysFree())
{
attributeLabels.push_back("fighter bays:");
attributeValues.push_back(to_string(ship.FighterBaysFree()));
attributesHeight += 20;
}
tableLabels.clear();
energyTable.clear();
heatTable.clear();
// Skip a spacer and the table header.
attributesHeight += 30;
tableLabels.push_back("idle:");
energyTable.push_back(Format::Number(60. * attributes.Get("energy generation")));
heatTable.push_back(Format::Number(
60. * (attributes.Get("heat generation") - attributes.Get("cooling"))));
attributesHeight += 20;
tableLabels.push_back("moving:");
energyTable.push_back(Format::Number(
-60. * (attributes.Get("thrusting energy") + attributes.Get("turning energy"))));
heatTable.push_back(Format::Number(
60. * (attributes.Get("thrusting heat") + attributes.Get("turning heat"))));
attributesHeight += 20;
double firingEnergy = 0.;
double firingHeat = 0.;
for(const auto &it : ship.Outfits())
if(it.first->IsWeapon() && it.first->Reload())
{
firingEnergy += it.second * it.first->FiringEnergy() / it.first->Reload();
firingHeat += it.second * it.first->FiringHeat() / it.first->Reload();
}
tableLabels.push_back("firing:");
energyTable.push_back(Format::Number(-60. * firingEnergy));
heatTable.push_back(Format::Number(60. * firingHeat));
attributesHeight += 20;
tableLabels.push_back("max:");
energyTable.push_back(Format::Number(attributes.Get("energy capacity")));
heatTable.push_back(Format::Number(60. * emptyMass * .1 * attributes.Get("heat dissipation")));
// Pad by 10 pixels on the top and bottom.
attributesHeight += 30;
}
void AI::DoSurveillance(Ship &ship, Command &command, const list<shared_ptr<Ship>> &ships) const
{
const shared_ptr<Ship> &target = ship.GetTargetShip();
if(target && (!target->IsTargetable() || target->GetSystem() != ship.GetSystem()))
ship.SetTargetShip(shared_ptr<Ship>());
if(target && ship.GetGovernment()->IsEnemy(target->GetGovernment()))
{
MoveIndependent(ship, command);
command |= AutoFire(ship, ships);
return;
}
bool cargoScan = ship.Attributes().Get("cargo scan");
bool outfitScan = ship.Attributes().Get("outfit scan");
double atmosphereScan = ship.Attributes().Get("atmosphere scan");
bool jumpDrive = ship.Attributes().Get("jump drive");
bool hyperdrive = ship.Attributes().Get("hyperdrive");
// This function is only called for ships that are in the player's system.
if(ship.GetTargetSystem())
{
PrepareForHyperspace(ship, command);
command |= Command::JUMP;
command |= Command::DEPLOY;
}
else if(ship.GetTargetPlanet())
{
MoveToPlanet(ship, command);
double distance = ship.Position().Distance(ship.GetTargetPlanet()->Position());
if(distance < atmosphereScan && !Random::Int(100))
ship.SetTargetPlanet(nullptr);
else
command |= Command::LAND;
}
else if(ship.GetTargetShip() && ship.GetTargetShip()->IsTargetable()
&& ship.GetTargetShip()->GetSystem() == ship.GetSystem())
{
bool mustScanCargo = cargoScan && !Has(ship, target, ShipEvent::SCAN_CARGO);
bool mustScanOutfits = outfitScan && !Has(ship, target, ShipEvent::SCAN_OUTFITS);
bool isInSystem = (ship.GetSystem() == target->GetSystem() && !target->IsEnteringHyperspace());
if(!isInSystem || (!mustScanCargo && !mustScanOutfits))
ship.SetTargetShip(shared_ptr<Ship>());
else
{
CircleAround(ship, command, *target);
command |= Command::SCAN;
}
}
else
{
shared_ptr<Ship> newTarget = FindTarget(ship, ships);
if(newTarget && ship.GetGovernment()->IsEnemy(newTarget->GetGovernment()))
{
ship.SetTargetShip(newTarget);
return;
}
vector<shared_ptr<Ship>> targetShips;
vector<const StellarObject *> targetPlanets;
vector<const System *> targetSystems;
if(cargoScan || outfitScan)
for(const auto &it : ships)
if(it->GetGovernment() != ship.GetGovernment() && it->IsTargetable()
&& it->GetSystem() == ship.GetSystem())
{
if(Has(ship, it, ShipEvent::SCAN_CARGO) && Has(ship, it, ShipEvent::SCAN_OUTFITS))
continue;
targetShips.push_back(it);
}
if(atmosphereScan)
for(const StellarObject &object : ship.GetSystem()->Objects())
if(!object.IsStar() && object.Radius() < 130.)
targetPlanets.push_back(&object);
if(jumpDrive)
for(const System *link : ship.GetSystem()->Neighbors())
targetSystems.push_back(link);
else if(hyperdrive)
for(const System *link : ship.GetSystem()->Links())
targetSystems.push_back(link);
unsigned total = targetShips.size() + targetPlanets.size() + targetSystems.size();
if(!total)
return;
unsigned index = Random::Int(total);
if(index < targetShips.size())
ship.SetTargetShip(targetShips[index]);
else
{
index -= targetShips.size();
if(index < targetPlanets.size())
ship.SetTargetPlanet(targetPlanets[index]);
else
ship.SetTargetSystem(targetSystems[index - targetPlanets.size()]);
}
}
}
// Load the cargo back into your ships. This may require selling excess, in
// which case a message will be returned.
void PlayerInfo::TakeOff()
{
shouldLaunch = false;
// This can only be done while landed.
if(!system || !planet)
return;
// Jobs are only available when you are landed.
availableJobs.clear();
availableMissions.clear();
doneMissions.clear();
soldOutfits.clear();
// Special persons who appeared last time you left the planet, can appear
// again.
for(const auto &it : GameData::Persons())
it.second.GetShip()->SetSystem(nullptr);
// Store the total cargo counts in case we need to adjust cost bases below.
map<string, int> originalTotals = cargo.Commodities();
Ship *flagship = Flagship();
bool canRecharge = planet->HasSpaceport() && planet->CanUseServices();
for(const shared_ptr<Ship> &ship : ships)
if(!ship->IsParked() && ship->GetSystem() == system && !ship->IsDisabled())
{
if(canRecharge)
ship->Recharge();
if(ship.get() != flagship)
{
ship->Cargo().SetBunks(ship->Attributes().Get("bunks") - ship->RequiredCrew());
cargo.TransferAll(&ship->Cargo());
}
}
if(flagship)
{
// Load up your flagship last, so that it will have space free for any
// plunder that you happen to acquire.
flagship->Cargo().SetBunks(flagship->Attributes().Get("bunks") - flagship->RequiredCrew());
cargo.TransferAll(&flagship->Cargo());
}
if(cargo.Passengers() && ships.size())
{
Ship &flagship = *ships.front();
int extra = min(cargo.Passengers(), flagship.Crew() - flagship.RequiredCrew());
if(extra)
{
flagship.AddCrew(-extra);
Messages::Add("You fired " + to_string(extra) + " crew members to free up bunks for passengers.");
flagship.Cargo().SetBunks(flagship.Attributes().Get("bunks") - flagship.Crew());
cargo.TransferAll(&flagship.Cargo());
}
}
if(ships.size())
{
Ship &flagship = *ships.front();
int extra = flagship.Crew() + flagship.Cargo().Passengers() - flagship.Attributes().Get("bunks");
if(extra > 0)
{
flagship.AddCrew(-extra);
Messages::Add("You fired " + to_string(extra) + " crew members because you have no bunks for them.");
flagship.Cargo().SetBunks(flagship.Attributes().Get("bunks") - flagship.Crew());
}
}
// For each fighter and drone you own, try to find a ship that has a bay to
// carry it in. Any excess ships will need to be sold.
vector<shared_ptr<Ship>> fighters;
vector<shared_ptr<Ship>> drones;
for(shared_ptr<Ship> &ship : ships)
{
if(ship->IsParked() || ship->GetSystem() != system || ship->IsDisabled())
continue;
bool fit = false;
const string &category = ship->Attributes().Category();
if(category == "Fighter")
{
for(shared_ptr<Ship> &parent : ships)
if(parent->GetSystem() == system && !parent->IsParked() && parent->FighterBaysFree())
{
parent->AddFighter(ship);
fit = true;
break;
}
if(!fit)
fighters.push_back(ship);
}
else if(category == "Drone")
{
for(shared_ptr<Ship> &parent : ships)
if(parent->GetSystem() == system && !parent->IsParked() && parent->DroneBaysFree())
{
parent->AddFighter(ship);
fit = true;
break;
}
if(!fit)
drones.push_back(ship);
}
}
if(!drones.empty() || !fighters.empty())
{
// If your fleet contains more fighters or drones than you can carry,
// some of them must be sold.
ostringstream out;
out << "Because none of your ships can carry them, you sold ";
if(!fighters.empty() && !drones.empty())
out << fighters.size()
<< (fighters.size() == 1 ? " fighter and " : " fighters and ")
<< drones.size()
<< (drones.size() == 1 ? " drone" : " drones");
else if(fighters.size())
out << fighters.size()
<< (fighters.size() == 1 ? " fighter" : " fighters");
else
out << drones.size()
<< (drones.size() == 1 ? " drone" : " drones");
int64_t income = 0;
for(const shared_ptr<Ship> &ship : fighters)
{
auto it = find(ships.begin(), ships.end(), ship);
if(it != ships.end())
{
income += ship->Cost();
ships.erase(it);
}
}
for(const shared_ptr<Ship> &ship : drones)
{
auto it = find(ships.begin(), ships.end(), ship);
if(it != ships.end())
{
income += ship->Cost();
ships.erase(it);
}
}
out << ", earning " << income << " credits.";
accounts.AddCredits(income);
Messages::Add(out.str());
}
// By now, all cargo should have been divvied up among your ships. So, any
// mission cargo or passengers left behind cannot be carried, and those
// missions have failed.
vector<const Mission *> missionsToRemove;
for(const auto &it : cargo.MissionCargo())
if(it.second)
{
Messages::Add("Mission \"" + it.first->Name()
+ "\" failed because you do not have space for the cargo.");
missionsToRemove.push_back(it.first);
}
for(const auto &it : cargo.PassengerList())
if(it.second)
{
Messages::Add("Mission \"" + it.first->Name()
+ "\" failed because you do not have enough passenger bunks free.");
missionsToRemove.push_back(it.first);
}
for(const Mission *mission : missionsToRemove)
RemoveMission(Mission::FAIL, *mission, nullptr);
// Any ordinary cargo left behind can be sold.
int64_t sold = cargo.Used();
int64_t income = 0;
int64_t totalBasis = 0;
if(sold)
for(const auto &commodity : cargo.Commodities())
{
if(!commodity.second)
continue;
// Figure out how much income you get for selling this cargo.
int64_t value = commodity.second * system->Trade(commodity.first);
income += value;
int original = originalTotals[commodity.first];
auto it = costBasis.find(commodity.first);
if(!original || it == costBasis.end() || !it->second)
continue;
// Now, figure out how much of that income is profit by calculating
// the cost basis for this cargo (which is just the total cost basis
// multiplied by the percent of the cargo you are selling).
int64_t basis = it->second * commodity.second / original;
it->second -= basis;
totalBasis += basis;
}
accounts.AddCredits(income);
cargo.Clear();
if(sold)
{
// Report how much excess cargo was sold, and what profit you earned.
ostringstream out;
out << "You sold " << sold << " tons of excess cargo for " << income << " credits";
if(totalBasis && totalBasis != income)
out << " (for a profit of " << (income - totalBasis) << " credits).";
else
out << ".";
Messages::Add(out.str());
}
}
