void Planet::AddBuilding(int building_id) {
if (this->Contains(building_id)) {
Logger().debugStream() << "Planet::AddBuilding this planet " << this->Name() << " already contained building " << building_id;
return;
}
//Logger().debugStream() << "Planet::AddBuilding " << this->Name() << " adding building: " << building_id;
if (Building* building = GetObject<Building>(building_id)) {
if (System* system = GetObject<System>(this->SystemID())) {
system->Insert(building);
} else {
Logger().errorStream() << "... planet is not located in a system?!?!";
building->MoveTo(X(), Y());
building->SetSystem(SystemID());
}
building->SetPlanetID(ID());
m_buildings.insert(building_id);
} else {
Logger().errorStream() << "Planet::AddBuilding() : Attempted to add an id of a non-building object to a planet.";
}
StateChangedSignal();
}
void Planet::PopGrowthProductionResearchPhase() {
UniverseObject::PopGrowthProductionResearchPhase();
bool just_conquered = m_just_conquered;
// do not do production if planet was just conquered
m_just_conquered = false;
if (!just_conquered)
ResourceCenterPopGrowthProductionResearchPhase();
PopCenterPopGrowthProductionResearchPhase();
// check for colonies without positive population, and change to outposts
if (!SpeciesName().empty() && GetMeter(METER_POPULATION)->Current() <= 0.0f) {
if (Empire* empire = GetEmpire(this->Owner())) {
empire->AddSitRepEntry(CreatePlanetDepopulatedSitRep(this->ID()));
if (!HasTag(TAG_STAT_SKIP_DEPOP)) {
// record depopulation of planet with species while owned by this empire
std::map<std::string, int>::iterator species_it = empire->SpeciesPlanetsDepoped().find(SpeciesName());
if (species_it == empire->SpeciesPlanetsDepoped().end())
empire->SpeciesPlanetsDepoped()[SpeciesName()] = 1;
else
species_it->second++;
}
}
// remove species
PopCenter::Reset();
}
if (!just_conquered) {
GetMeter(METER_SHIELD)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_SHIELD));
GetMeter(METER_DEFENSE)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_DEFENSE));
GetMeter(METER_TROOPS)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_TROOPS));
GetMeter(METER_REBEL_TROOPS)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_REBEL_TROOPS));
GetMeter(METER_SUPPLY)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_SUPPLY));
}
StateChangedSignal();
}
void Planet::PopGrowthProductionResearchPhase() {
UniverseObject::PopGrowthProductionResearchPhase();
bool just_conquered = m_just_conquered;
// do not do production if planet was just conquered
m_just_conquered = false;
if (!just_conquered)
ResourceCenterPopGrowthProductionResearchPhase();
PopCenterPopGrowthProductionResearchPhase();
// check for planets with zero population. If they have a species set, then
// they probably just starved
if (!SpeciesName().empty() && GetMeter(METER_POPULATION)->Current() == 0.0f) {
if (Empire* empire = GetEmpire(this->Owner())) {
// generate starvation sitrep for empire that owns this depopulated planet
empire->AddSitRepEntry(CreatePlanetStarvedToDeathSitRep(this->ID()));
// record depopulation of planet with species while owned by this empire
std::map<std::string, int>::iterator species_it = empire->SpeciesPlanetsDepoped().find(SpeciesName());
if (species_it == empire->SpeciesPlanetsDepoped().end())
empire->SpeciesPlanetsDepoped()[SpeciesName()] = 1;
else
species_it->second++;
}
// remove species
SetSpecies("");
}
if (!just_conquered) {
GetMeter(METER_SHIELD)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_SHIELD));
GetMeter(METER_DEFENSE)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_DEFENSE));
GetMeter(METER_TROOPS)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_TROOPS));
GetMeter(METER_REBEL_TROOPS)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_REBEL_TROOPS));
GetMeter(METER_SUPPLY)->SetCurrent(Planet::NextTurnCurrentMeterValue(METER_SUPPLY));
}
StateChangedSignal();
}
void Planet::SetGiveToEmpire(int empire_id) {
if (empire_id == m_ordered_given_to_empire_id) return;
m_ordered_given_to_empire_id = empire_id;
StateChangedSignal();
}
void UniverseObject::Rename(const std::string& name) {
m_name = name;
StateChangedSignal();
}
void Planet::SetIsAboutToBeBombarded(bool b) {
bool initial_status = m_is_about_to_be_bombarded;
if (b == initial_status) return;
m_is_about_to_be_bombarded = b;
StateChangedSignal();
}
void Ship::SetBombardPlanet(int planet_id) {
if (planet_id == m_ordered_bombard_planet_id) return;
m_ordered_bombard_planet_id = planet_id;
StateChangedSignal();
}
void UniverseObject::SetID(int id) {
m_id = id;
StateChangedSignal();
}
void System::SetOverlayTexture(const std::string& texture, double size) {
m_overlay_texture = texture;
m_overlay_size = size;
StateChangedSignal();
}
void Ship::SetInvadePlanet(int planet_id) {
if (planet_id == m_ordered_invade_planet_id) return;
m_ordered_invade_planet_id = planet_id;
StateChangedSignal();
}
void System::Insert(TemporaryPtr<UniverseObject> obj, int orbit/* = -1*/) {
if (!obj) {
Logger().errorStream() << "System::Insert() : Attempted to place a null object in a System";
return;
}
if (orbit < -1 || orbit >= static_cast<int>(m_orbits.size())) {
Logger().errorStream() << "System::Insert() : Attempted to place an object in invalid orbit";
return;
}
obj->MoveTo(this->X(), this->Y());
obj->SetSystem(this->ID());
if (obj->ObjectType() == OBJ_PLANET) {
if (orbit == -1) {
bool already_in_orbit = false;
for (int o = 0; o < static_cast<int>(m_orbits.size()); ++o) {
if (m_orbits[o] = obj->ID()) {
already_in_orbit = true;
break;
}
}
// if planet already in an orbit, do nothing
// if planet not in an orbit, find orbit to put planet in
if (!already_in_orbit) {
for (int o = 0; o < static_cast<int>(m_orbits.size()); ++o) {
if (m_orbits[o] == INVALID_OBJECT_ID) {
orbit = o;
m_orbits[orbit] = obj->ID();
break;
}
}
}
} else {
// check if desired orbit is occupied
// if yes, it is either already occupied by the inserted object or
// by another object. in either case, do nothing.
// if not, put object into the orbit, and remove from any other
// orbit it currently occupies.
if (!OrbitOccupied(orbit)) {
// check if object already in any different orbit
// ... if yes, remove it
for (int o = 0; o < static_cast<int>(m_orbits.size()); ++o) {
if (o != orbit && m_orbits[o] == obj->ID())
m_orbits[o] = INVALID_OBJECT_ID;
}
// put object into desired orbit
m_orbits[orbit] = obj->ID();
}
}
}
// if not a planet, don't need to put into an orbit
switch (obj->ObjectType()) {
case OBJ_SHIP:
m_ships.insert(obj->ID());
break;
case OBJ_FLEET: {
m_fleets.insert(obj->ID());
std::vector<TemporaryPtr<Fleet> > fleets;
fleets.push_back(boost::dynamic_pointer_cast<Fleet>(obj));
FleetsInsertedSignal(fleets);
break;
}
case OBJ_PLANET:
m_planets.insert(obj->ID());
break;
case OBJ_FIELD:
m_fields.insert(obj->ID());
break;
case OBJ_SYSTEM:
Logger().errorStream() << "System::Insert inserting a system into another system...??";
break;
case OBJ_BUILDING:
m_buildings.insert(obj->ID());
break;
default:
Logger().errorStream() << "System::Insert inserting an unknown object type";
}
m_objects.insert(obj->ID());
StateChangedSignal();
}
void Ship::SetOrderedScrapped(bool b) {
if (b == m_ordered_scrapped) return;
m_ordered_scrapped = b;
StateChangedSignal();
}
void Building::SetOrderedScrapped(bool b) {
bool initial_status = m_ordered_scrapped;
if (b == initial_status) return;
m_ordered_scrapped = b;
StateChangedSignal();
}
void Ship::SetFleetID(int fleet_id) {
if (m_fleet_id != fleet_id) {
m_fleet_id = fleet_id;
StateChangedSignal();
}
}
void Building::SetPlanetID(int planet_id) {
if (planet_id != m_planet_id) {
m_planet_id = planet_id;
StateChangedSignal();
}
}
void Fleet::SetRoute(const std::list<int>& route) {
if (route.empty())
throw std::invalid_argument("Fleet::SetRoute() : Attempted to set an empty route.");
if (UnknownRoute())
throw std::invalid_argument("Fleet::SetRoute() : Attempted to set an unknown route.");
if (m_prev_system != SystemID() && m_prev_system == route.front() && !CanChangeDirectionEnRoute())
throw std::invalid_argument("Fleet::SetRoute() : Illegally attempted to change a fleet's direction while it was in transit.");
m_travel_route = route;
// calculate length of line segments between systems on route, and sum up to determine length of route between
// systems on route. (Might later add distance from fleet to first system on route to this to get the total
// route length, or this may itself be the total route length if the fleet is at the first system on the route).
m_travel_distance = 0.0;
for (std::list<int>::const_iterator it = m_travel_route.begin(); it != m_travel_route.end(); ++it) {
std::list<int>::const_iterator next_it = it; ++next_it;
if (next_it == m_travel_route.end())
break; // current system is the last on the route, so don't need to add any additional distance.
const System* cur_sys = GetSystem(*it);
if (!cur_sys) {
Logger().errorStream() << "Fleet::SetRoute() couldn't get system with id " << *it;
return;
}
const System* next_sys = GetSystem(*next_it);
if (!next_sys) {
Logger().errorStream() << "Fleet::SetRoute() couldn't get system with id " << *next_it;
return;
}
double dist_x = next_sys->X() - cur_sys->X();
double dist_y = next_sys->Y() - cur_sys->Y();
m_travel_distance += std::sqrt(dist_x*dist_x + dist_y*dist_y);
}
// if resetting to no movement while in a system
if (SystemID() != INVALID_OBJECT_ID && SystemID() == m_travel_route.back()) {
m_moving_to = INVALID_OBJECT_ID;
m_next_system = INVALID_OBJECT_ID;
m_prev_system = INVALID_OBJECT_ID;
} else {
// if we're already moving, add in the distance from where we are to the first system in the route
if (SystemID() != route.front()) {
const System* starting_system = GetSystem(route.front());
if (!starting_system) {
Logger().errorStream() << "Fleet::SetRoute couldn't get system with id " << route.front();
return;
}
double dist_x = starting_system->X() - this->X();
double dist_y = starting_system->Y() - this->Y();
m_travel_distance += std::sqrt(dist_x*dist_x + dist_y*dist_y);
}
m_moving_to = m_travel_route.back();
if (m_prev_system != SystemID() && m_prev_system == m_travel_route.front()) {
m_prev_system = m_next_system; // if already in transit and turning around, swap prev and next
} else if (SystemID() == route.front()) {
m_prev_system = SystemID();
}
std::list<int>::const_iterator it = m_travel_route.begin();
m_next_system = m_prev_system == SystemID() ? (*++it) : (*it);
}
StateChangedSignal();
}
void System::SetStarType(StarType type) {
m_star = type;
if (m_star <= INVALID_STAR_TYPE || NUM_STAR_TYPES <= m_star)
Logger().errorStream() << "System::SetStarType set star type to " << boost::lexical_cast<std::string>(type);
StateChangedSignal();
}
void Planet::SetSurfaceTexture(const std::string& texture) {
m_surface_texture = texture;
StateChangedSignal();
}
void Ship::SetColonizePlanet(int planet_id) {
if (planet_id == m_ordered_colonize_planet_id) return;
m_ordered_colonize_planet_id = planet_id;
StateChangedSignal();
}
void Ship::SetArrivedOnTurn(int turn) {
if (m_arrived_on_turn != turn) {
m_arrived_on_turn = turn;
StateChangedSignal();
}
}
void System::AddWormhole(int id) {
if (!HasWormholeTo(id) && id != this->ID()) {
m_starlanes_wormholes[id] = true;
StateChangedSignal();
}
}