void ShipInfoDisplay::UpdateAttributes(const Ship &ship)
{
bool isGeneric = ship.Name().empty() || ship.GetPlanet();
attributeLabels.clear();
attributeValues.clear();
attributesHeight = 20;
const Outfit &attributes = ship.Attributes();
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 = ship.Mass();
attributeLabels.push_back(isGeneric ? "mass with no cargo:" : "mass:");
attributeValues.push_back(Format::Number(emptyMass));
attributesHeight += 20;
attributeLabels.push_back(isGeneric ? "cargo space:" : "cargo:");
if(isGeneric)
attributeValues.push_back(Format::Number(attributes.Get("cargo space")));
else
attributeValues.push_back(Format::Number(ship.Cargo().Used())
+ " / " + 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(isGeneric ? "fuel capacity:" : "fuel:");
double fuelCapacity = attributes.Get("fuel capacity");
if(isGeneric)
attributeValues.push_back(Format::Number(fuelCapacity));
else
attributeValues.push_back(Format::Number(ship.Fuel() * fuelCapacity)
+ " / " + Format::Number(fuelCapacity));
attributesHeight += 20;
double fullMass = emptyMass + (isGeneric ? attributes.Get("cargo space") : ship.Cargo().Used());
isGeneric &= (fullMass != emptyMass);
attributeLabels.push_back(string());
attributeValues.push_back(string());
attributesHeight += 10;
attributeLabels.push_back(isGeneric ? "movement, full / no cargo:" : "movement:");
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(!isGeneric)
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(!isGeneric)
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",
"gun 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.BaysFree(false))
{
attributeLabels.push_back("drone bays:");
attributeValues.push_back(to_string(ship.BaysFree(false)));
attributesHeight += 20;
}
if(ship.BaysFree(true))
{
attributeLabels.push_back("fighter bays:");
attributeValues.push_back(to_string(ship.BaysFree(true)));
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")
+ attributes.Get("solar collection"))));
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("reverse thrusting energy")
+ attributes.Get("turning energy"))));
heatTable.push_back(Format::Number(
60. * (attributes.Get("thrusting heat")
+ attributes.Get("reverse 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;
double shieldEnergy = attributes.Get("shield energy");
double hullEnergy = attributes.Get("hull energy");
tableLabels.push_back((shieldEnergy && hullEnergy) ? "shields / hull:" :
hullEnergy ? "repairing hull:" : "charging shields:");
energyTable.push_back(Format::Number(-60. * (shieldEnergy + hullEnergy)));
double shieldHeat = attributes.Get("shield heat");
double hullHeat = attributes.Get("hull heat");
heatTable.push_back(Format::Number(60. * (shieldHeat + hullHeat)));
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::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);
}
