void ProductionQueueOrder::ExecuteImpl() const {
ValidateEmpireID();
Empire* empire = GetEmpire(EmpireID());
try {
if (m_item.build_type == BT_BUILDING || m_item.build_type == BT_SHIP) {
empire->PlaceBuildInQueue(m_item, m_number, m_location, m_new_index);
} else if (m_new_blocksize != INVALID_QUANTITY) {
DebugLogger() << "ProductionQueueOrder quantity " << m_new_quantity << " Blocksize " << m_new_blocksize;
empire->SetBuildQuantityAndBlocksize(m_index, m_new_quantity, m_new_blocksize);
} else if (m_new_quantity != INVALID_QUANTITY) {
empire->SetBuildQuantity(m_index, m_new_quantity);
} else if (m_new_index != INVALID_INDEX) {
empire->MoveBuildWithinQueue(m_index, m_new_index);
} else if (m_rally_point_id != INVALID_OBJECT_ID) {
DebugLogger() << "ProductionQueueOrder setting rally point to id: " << m_rally_point_id;
empire->SetBuildRallyPoint(m_index, m_rally_point_id);
} else if (m_index != INVALID_INDEX) {
DebugLogger() << "ProductionQueueOrder removing build from index " << m_index;
empire->RemoveBuildFromQueue(m_index);
} else {
ErrorLogger() << "Malformed ProductionQueueOrder.";
}
} catch (const std::exception& e) {
ErrorLogger() << "Build order execution threw exception: " << e.what();
}
}
void ProductionQueueOrder::ExecuteImpl() const {
ValidateEmpireID();
Empire* empire = GetEmpire(EmpireID());
try {
if (m_build_type == BT_BUILDING)
empire->PlaceBuildInQueue(BT_BUILDING, m_item_name, m_number, m_location);
else if (m_build_type == BT_SHIP)
empire->PlaceBuildInQueue(BT_SHIP, m_design_id, m_number, m_location);
else if (m_new_blocksize != INVALID_QUANTITY) {
DebugLogger() << "ProductionQueueOrder quantity " << m_new_quantity << " Blocksize " << m_new_blocksize;
empire->SetBuildQuantityAndBlocksize(m_index, m_new_quantity, m_new_blocksize);
}
else if (m_new_quantity != INVALID_QUANTITY)
empire->SetBuildQuantity(m_index, m_new_quantity);
else if (m_new_index != INVALID_INDEX)
empire->MoveBuildWithinQueue(m_index, m_new_index);
else if (m_index != INVALID_INDEX) {
DebugLogger() << "ProductionQueueOrder removing build from index " << m_index;
empire->RemoveBuildFromQueue(m_index);
}
else
ErrorLogger() << "Malformed ProductionQueueOrder.";
} catch (const std::exception& e) {
ErrorLogger() << "Build order execution threw exception: " << e.what();
}
}
std::string IncapacitationEvent::CombatLogDescription(int viewing_empire_id) const {
std::shared_ptr<const UniverseObject> object = GetUniverseObject(object_id);
std::string template_str, object_str;
int owner_id = object_owner_id;
if (!object && object_id < 0) {
template_str = UserString("ENC_COMBAT_FIGHTER_INCAPACITATED_STR");
object_str = UserString("OBJ_FIGHTER");
} else if (!object) {
template_str = UserString("ENC_COMBAT_UNKNOWN_DESTROYED_STR");
object_str = UserString("ENC_COMBAT_UNKNOWN_OBJECT");
} else if (object->ObjectType() == OBJ_PLANET) {
template_str = UserString("ENC_COMBAT_PLANET_INCAPACITATED_STR");
object_str = PublicNameLink(viewing_empire_id, object_id);
} else { // ships or other to-be-determined objects...
template_str = UserString("ENC_COMBAT_DESTROYED_STR");
object_str = PublicNameLink(viewing_empire_id, object_id);
}
std::string owner_string = " ";
if (const Empire* owner = GetEmpire(owner_id))
owner_string += owner->Name() + " ";
std::string object_link = FighterOrPublicNameLink(viewing_empire_id, object_id, object_owner_id);
return str(FlexibleFormat(template_str) % owner_string % object_link);
}
void ProductionWnd::UpdateQueue() {
DebugLogger() << "ProductionWnd::UpdateQueue()";
ScopedTimer timer("ProductionWnd::UpdateQueue");
m_queue_wnd->SetEmpire(m_empire_shown_id);
QueueListBox* queue_lb = m_queue_wnd->GetQueueListBox();
std::size_t first_visible_queue_row = std::distance(queue_lb->begin(), queue_lb->FirstRowShown());
queue_lb->Clear();
const Empire* empire = GetEmpire(m_empire_shown_id);
if (!empire)
return;
const ProductionQueue& queue = empire->GetProductionQueue();
int i = 0;
for (ProductionQueue::const_iterator it = queue.begin(); it != queue.end(); ++it, ++i) {
QueueRow* row = new QueueRow(queue_lb->RowWidth(), *it, i);
GG::Connect(row->RowQuantChangedSignal, &ProductionWnd::ChangeBuildQuantityBlockSlot, this);
queue_lb->Insert(row);
}
if (!queue_lb->Empty())
queue_lb->BringRowIntoView(--queue_lb->end());
if (first_visible_queue_row < queue_lb->NumRows())
queue_lb->BringRowIntoView(boost::next(queue_lb->begin(), first_visible_queue_row));
}
BuildingsPanel::BuildingsPanel(GG::X w, int columns, int planet_id) :
AccordionPanel(w),
m_planet_id(planet_id),
m_columns(columns),
m_building_indicators()
{
SetName("BuildingsPanel");
if (m_columns < 1) {
ErrorLogger() << "Attempted to create a BuidingsPanel with less than 1 column";
m_columns = 1;
}
GG::Connect(m_expand_button->LeftClickedSignal, &BuildingsPanel::ExpandCollapseButtonPressed, this);
// get owner, connect its production queue changed signal to update this panel
TemporaryPtr<const UniverseObject> planet = GetUniverseObject(m_planet_id);
if (planet) {
if (const Empire* empire = GetEmpire(planet->Owner())) {
const ProductionQueue& queue = empire->GetProductionQueue();
GG::Connect(queue.ProductionQueueChangedSignal, &BuildingsPanel::Refresh, this);
}
}
Refresh();
}
DWORD CHARACTER::GetAID() const
{
char szQuery[1024+1];
DWORD dwAID = 0;
snprintf(szQuery, sizeof(szQuery), "SELECT id FROM player_index%s WHERE pid1=%u OR pid2=%u OR pid3=%u OR pid4=%u AND empire=%u",
get_table_postfix(), GetPlayerID(), GetPlayerID(), GetPlayerID(), GetPlayerID(), GetEmpire());
SQLMsg* pMsg = DBManager::instance().DirectQuery(szQuery);
if (pMsg != NULL)
{
if (pMsg->Get()->uiNumRows == 0)
{
M2_DELETE(pMsg);
return 0;
}
MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);
str_to_number(dwAID, row[0]);
M2_DELETE(pMsg);
return dwAID;
}
else
{
return 0;
}
}
void MessageWnd::HandlePlayerChatMessage(const std::string& text, int sender_player_id, int recipient_player_id) {
const ClientApp* app = ClientApp::GetApp();
if (!app) {
ErrorLogger() << "MessageWnd::HandlePlayerChatMessage couldn't get client app!";
return;
}
const std::map<int, PlayerInfo>& players = app->Players();
std::map<int, PlayerInfo>::const_iterator player_it = players.find(sender_player_id);
if (player_it == players.end()) {
ErrorLogger() << "MessageWnd::HandlePlayerChatMessage couldn't message sending player with id: " << sender_player_id;
return;
}
const std::string& sender_name = player_it->second.name;
const int& sender_empire_id = player_it->second.empire_id;
GG::Clr sender_colour(ClientUI::TextColor());
if (const Empire* sender_empire = GetEmpire(sender_empire_id))
sender_colour = sender_empire->Color();
std::string filtered_message = StringtableTextSubstitute(text);
std::string wrapped_text = RgbaTag(sender_colour) + sender_name + ": " + filtered_message + "</rgba>";
*m_display += wrapped_text + "\n";
m_display_show_time = GG::GUI::GetGUI()->Ticks();
}
void EmpireManager::EliminateEmpire(int id) {
if (Empire* emp = GetEmpire(id)) {
emp->EliminationCleanup();
m_eliminated_empires.insert(id);
} else {
ErrorLogger() << "Tried to eliminate nonexistant empire with ID " << id;
}
}
int IssueGiveObjectToEmpireOrder(int object_id, int recipient_id) {
int empire_id = AIClientApp::GetApp()->EmpireID();
if (GetEmpire(recipient_id) == 0) {
ErrorLogger() << "IssueGiveObjectToEmpireOrder : given invalid recipient empire id";
return 0;
}
if (Empires().GetDiplomaticStatus(empire_id, recipient_id) != DIPLO_PEACE) {
ErrorLogger() << "IssueGiveObjectToEmpireOrder : attempting to give to empire not at peace";
return 0;
}
TemporaryPtr<UniverseObject> obj = GetUniverseObject(object_id);
if (!obj) {
ErrorLogger() << "IssueGiveObjectToEmpireOrder : passed invalid object id";
return 0;
}
if (!obj->OwnedBy(empire_id)) {
ErrorLogger() << "IssueGiveObjectToEmpireOrder : passed object not owned by player";
return 0;
}
if (obj->ObjectType() != OBJ_FLEET && obj->ObjectType() != OBJ_PLANET) {
ErrorLogger() << "IssueGiveObjectToEmpireOrder : passed object that is not a fleet or planet";
return 0;
}
TemporaryPtr<System> system = GetSystem(obj->SystemID());
if (!system) {
ErrorLogger() << "IssueGiveObjectToEmpireOrder : couldn't get system of object";
return 0;
}
// can only give to empires with something present to receive the gift
bool recipient_has_something_here = false;
std::vector<TemporaryPtr<const UniverseObject> > system_objects =
Objects().FindObjects<const UniverseObject>(system->ObjectIDs());
for (std::vector<TemporaryPtr<const UniverseObject> >::const_iterator it = system_objects.begin();
it != system_objects.end(); ++it)
{
TemporaryPtr<const UniverseObject> obj = *it;
if (obj->Owner() == recipient_id) {
recipient_has_something_here = true;
break;
}
}
if (!recipient_has_something_here) {
ErrorLogger() << "IssueGiveObjectToEmpireOrder : recipient empire has nothing in system";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new GiveObjectToEmpireOrder(empire_id, object_id, recipient_id)));
return 1;
}
void ResearchWnd::QueueItemMoved(GG::ListBox::Row* row, std::size_t position) {
if (QueueRow* queue_row = boost::polymorphic_downcast<QueueRow*>(row)) {
int empire_id = HumanClientApp::GetApp()->EmpireID();
HumanClientApp::GetApp()->Orders().IssueOrder(
OrderPtr(new ResearchQueueOrder(empire_id, queue_row->tech_name, position)));
if (Empire* empire = GetEmpire(empire_id))
empire->UpdateResearchQueue();
}
}
void ResearchWnd::DeleteQueueItem(GG::ListBox::iterator it) {
if (!m_enabled)
return;
int empire_id = HumanClientApp::GetApp()->EmpireID();
OrderSet& orders = HumanClientApp::GetApp()->Orders();
if (QueueRow* queue_row = boost::polymorphic_downcast<QueueRow*>(*it))
orders.IssueOrder(OrderPtr(new ResearchQueueOrder(empire_id, queue_row->tech_name)));
if (Empire* empire = GetEmpire(empire_id))
empire->UpdateResearchQueue();
}
void ResearchWnd::Refresh() {
// useful at start of turn or when loading empire from save.
// since empire object is recreated based on turn update from server,
// connections of signals emitted from the empire must be remade
m_empire_connection.disconnect();
if (Empire* empire = GetEmpire(HumanClientApp::GetApp()->EmpireID()))
m_empire_connection = GG::Connect(empire->GetResearchQueue().ResearchQueueChangedSignal,
&ResearchWnd::ResearchQueueChangedSlot, this);
Update();
}
std::string ColorByOwner::Decorate(const std::string& object_id_str, const std::string& content) const {
GG::Clr color = ClientUI::DefaultLinkColor();
const Empire* empire = 0;
// get object indicated by object_id, and then get object's owner, if any
int object_id = CastStringToInt(object_id_str);
TemporaryPtr<const UniverseObject> object = Objects().Object(object_id);
if (object && !object->Unowned())
empire = GetEmpire(object->Owner());
if (empire)
color = empire->Color();
return GG::RgbaTag(color) + content + "</rgba>";
}
void ResearchQueueOrder::ExecuteImpl() const {
ValidateEmpireID();
Empire* empire = GetEmpire(EmpireID());
if (!empire) return;
if (m_remove) {
DebugLogger() << "ResearchQueueOrder::ExecuteImpl: removing from queue tech: " << m_tech_name;
empire->RemoveTechFromQueue(m_tech_name);
}
else
empire->PlaceTechInQueue(m_tech_name, m_position);
}
std::string EmpireManager::Dump() const {
std::string retval = "Empires:\n";
for (const_iterator it = begin(); it != end(); ++it)
retval += it->second->Dump();
retval += "Diplomatic Statuses:\n";
for (std::map<std::pair<int, int>, DiplomaticStatus>::const_iterator it = m_empire_diplomatic_statuses.begin();
it != m_empire_diplomatic_statuses.end(); ++it)
{
const Empire* empire1 = GetEmpire(it->first.first);
const Empire* empire2 = GetEmpire(it->first.second);
if (!empire1 || !empire2)
continue;
retval += " * " + empire1->Name() + " / " + empire2->Name() + " : ";
switch (it->second) {
case DIPLO_WAR: retval += "War"; break;
case DIPLO_PEACE: retval += "Peace"; break;
default: retval += "?"; break;
}
retval += "\n";
}
return retval;
}
void ProductionWnd::DeleteQueueItem(GG::ListBox::iterator it) {
if (!m_order_issuing_enabled)
return;
int client_empire_id = HumanClientApp::GetApp()->EmpireID();
Empire* empire = GetEmpire(client_empire_id);
if (!empire)
return;
HumanClientApp::GetApp()->Orders().IssueOrder(
OrderPtr(new ProductionQueueOrder(client_empire_id, std::distance(m_queue_wnd->GetQueueListBox()->begin(), it))));
empire->UpdateProductionQueue();
}
void ProductionWnd::ChangeBuildQuantityBlockSlot(int queue_idx, int quantity, int blocksize) {
if (!m_order_issuing_enabled)
return;
int client_empire_id = HumanClientApp::GetApp()->EmpireID();
Empire* empire = GetEmpire(client_empire_id);
if (!empire)
return;
HumanClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ProductionQueueOrder(client_empire_id, queue_idx, quantity, blocksize)));
empire->UpdateProductionQueue();
}
void ProductionWnd::AddBuildToQueueSlot(const ProductionQueue::ProductionItem& item, int number, int location, int pos) {
if (!m_order_issuing_enabled)
return;
int client_empire_id = HumanClientApp::GetApp()->EmpireID();
Empire* empire = GetEmpire(client_empire_id);
if (!empire)
return;
HumanClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ProductionQueueOrder(client_empire_id, item, number, location, pos)));
empire->UpdateProductionQueue();
m_build_designator_wnd->CenterOnBuild(pos >= 0 ? pos : m_queue_wnd->GetQueueListBox()->NumRows() - 1);
}
boost::statechart::result PlayingGame::react(const VictoryDefeat& msg) {
if (TRACE_EXECUTION) DebugLogger() << "(HumanClientFSM) PlayingGame.VictoryDefeat";
Message::VictoryOrDefeat victory_or_defeat;
std::string reason_string;
int empire_id;
ExtractMessageData(msg.m_message, victory_or_defeat, reason_string, empire_id);
const Empire* empire = GetEmpire(empire_id);
std::string empire_name = UserString("UNKNOWN_EMPIRE");
if (empire)
empire_name = empire->Name();
//ClientUI::MessageBox(boost::io::str(FlexibleFormat(UserString(reason_string)) % empire_name));
return discard_event();
}
void ProductionWnd::QueueItemMoved(GG::ListBox::Row* row, std::size_t position) {
if (!m_order_issuing_enabled)
return;
int client_empire_id = HumanClientApp::GetApp()->EmpireID();
Empire* empire = GetEmpire(client_empire_id);
if (!empire)
return;
HumanClientApp::GetApp()->Orders().IssueOrder(
OrderPtr(new ProductionQueueOrder(client_empire_id,
boost::polymorphic_downcast<QueueRow*>(row)->queue_index,
position)));
empire->UpdateProductionQueue();
}
void ProductionWnd::UpdateInfoPanel() {
const Empire* empire = GetEmpire(m_empire_shown_id);
if (!empire) {
m_production_info_panel->SetName(UserString("PRODUCTION_WND_TITLE"));
m_production_info_panel->ClearLocalInfo();
return;
} else {
m_production_info_panel->SetEmpireID(m_empire_shown_id);
}
const ProductionQueue& queue = empire->GetProductionQueue();
float PPs = empire->ProductionPoints();
float total_queue_cost = queue.TotalPPsSpent();
m_production_info_panel->SetTotalPointsCost(PPs, total_queue_cost);
// find if there is a local location
int prod_loc_id = this->SelectedPlanetID();
TemporaryPtr<UniverseObject> loc_obj = GetUniverseObject(prod_loc_id);
if (loc_obj) {
// extract available and allocated PP at production location
std::map<std::set<int>, float> available_pp = queue.AvailablePP(empire->GetResourcePool(RE_INDUSTRY));
const std::map<std::set<int>, float>& allocated_pp = queue.AllocatedPP();
float available_pp_at_loc = 0.0f, allocated_pp_at_loc = 0.0f; // for the resource sharing group containing the selected production location
for (std::map<std::set<int>, float>::const_iterator map_it = available_pp.begin();
map_it != available_pp.end(); ++map_it)
{
if (map_it->first.find(prod_loc_id) != map_it->first.end()) {
available_pp_at_loc = map_it->second;
break;
}
}
for (std::map<std::set<int>, float>::const_iterator map_it = allocated_pp.begin();
map_it != allocated_pp.end(); ++map_it)
{
if (map_it->first.find(prod_loc_id) != map_it->first.end()) {
allocated_pp_at_loc = map_it->second;
break;
}
}
m_production_info_panel->SetLocalPointsCost(available_pp_at_loc, allocated_pp_at_loc, loc_obj->Name());
} else {
// else clear local info...
m_production_info_panel->ClearLocalInfo();
}
}
void ProductionWnd::Refresh() {
// useful at start of turn or when loading empire from save, or when
// the selected empire shown has changed.
// because empire object is recreated based on turn update from server,
// connections of signals emitted from the empire must be remade after
// getting a turn update
m_empire_connection.disconnect();
if (Empire* empire = GetEmpire(m_empire_shown_id))
m_empire_connection = GG::Connect(empire->GetProductionQueue().ProductionQueueChangedSignal,
&ProductionWnd::ProductionQueueChangedSlot, this);
UpdateInfoPanel();
UpdateQueue();
m_build_designator_wnd->Refresh();
}
void ResearchWnd::UpdateInfoPanel() {
const Empire* empire = GetEmpire(HumanClientApp::GetApp()->EmpireID());
if (!empire)
return;
const ResearchQueue& queue = empire->GetResearchQueue();
float RPs = empire->ResourceOutput(RE_RESEARCH);
float total_queue_cost = queue.TotalRPsSpent();
m_research_info_panel->SetTotalPointsCost(RPs, total_queue_cost);
/* Altering research queue may have freed up or required more RP. Signalling that the
ResearchResPool has changed causes the MapWnd to be signalled that that pool has changed,
which causes the resource indicator to be updated (which polls the ResearchQueue to
determine how many RPs are being spent). If/when RP are stockpilable, this might matter,
so then the following line should be uncommented.*/
//empire->GetResearchResPool().ChangedSignal();
}
void ResearchWnd::UpdateInfoPanel() {
const Empire* empire = GetEmpire(HumanClientApp::GetApp()->EmpireID());
if (!empire)
return;
const ResearchQueue& queue = empire->GetResearchQueue();
double RPs = empire->ResourceProduction(RE_RESEARCH);
double total_queue_cost = queue.TotalRPsSpent();
ResearchQueue::const_iterator underfunded_it = queue.UnderfundedProject();
double RPs_to_underfunded_projects = underfunded_it == queue.end() ? 0.0 : underfunded_it->allocated_rp;
m_research_info_panel->Reset(RPs, total_queue_cost, queue.ProjectsInProgress(), RPs_to_underfunded_projects, queue.size());
/* Altering research queue may have freed up or required more RP. Signalling that the
ResearchResPool has changed causes the MapWnd to be signalled that that pool has changed,
which causes the resource indicator to be updated (which polls the ResearchQueue to
determine how many RPs are being spent). If/when RP are stockpilable, this might matter,
so then the following line should be uncommented.*/
//empire->GetResearchResPool().ChangedSignal();
}
void ResearchWnd::UpdateQueue() {
const Empire* empire = GetEmpire(HumanClientApp::GetApp()->EmpireID());
if (!empire)
return;
const ResearchQueue& queue = empire->GetResearchQueue();
std::size_t first_visible_queue_row = std::distance(m_queue_lb->begin(), m_queue_lb->FirstRowShown());
m_queue_lb->Clear();
const GG::X QUEUE_WIDTH = m_queue_lb->Width() - 8 - 14;
for (ResearchQueue::const_iterator it = queue.begin(); it != queue.end(); ++it) {
const ResearchQueue::Element& elem = *it;
m_queue_lb->Insert(new QueueRow(QUEUE_WIDTH, elem));
}
if (!m_queue_lb->Empty())
m_queue_lb->BringRowIntoView(--m_queue_lb->end());
if (first_visible_queue_row < m_queue_lb->NumRows())
m_queue_lb->BringRowIntoView(boost::next(m_queue_lb->begin(), first_visible_queue_row));
}
void HumanClientApp::StartTurn() {
DebugLogger() << "HumanClientApp::StartTurn";
const Empire *empire = GetEmpire(EmpireID());
if (empire) {
double RP = empire->ResourceOutput(RE_RESEARCH);
double PP = empire->ResourceOutput(RE_INDUSTRY);
int turn_number = CurrentTurn();
float ratio = (RP/(PP+0.0001));
const GG::Clr color = empire->Color();
DebugLogger() << "Current Output (turn " << turn_number << ") RP/PP: " << ratio << " (" << RP << "/" << PP << ")";
DebugLogger() << "EmpireColors: " << static_cast<int>(color.r)
<< " " << static_cast<int>(color.g)
<< " " << static_cast<int>(color.b)
<< " " << static_cast<int>(color.a);
}
ClientApp::StartTurn();
m_fsm->process_event(TurnEnded());
}
boost::statechart::result PlayingGame::react(const PlayerChat& msg) {
TraceLogger(FSM) << "(HumanClientFSM) PlayingGame.PlayerChat: " << msg.m_message.Text();
std::string text;
int sending_player_id;
boost::posix_time::ptime timestamp;
ExtractServerPlayerChatMessageData(msg.m_message, sending_player_id, timestamp, text);
std::string player_name{UserString("PLAYER") + " " + std::to_string(sending_player_id)};
GG::Clr text_color{Client().GetClientUI().TextColor()};
auto players = Client().Players();
auto player_it = players.find(sending_player_id);
if (player_it != players.end()) {
player_name = player_it->second.name;
if (auto empire = GetEmpire(player_it->second.empire_id))
text_color = empire->Color();
}
Client().GetClientUI().GetMessageWnd()->HandlePlayerChatMessage(text, player_name, text_color, timestamp, Client().PlayerID());
return discard_event();
}
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 ProductionWnd::QueueItemRallied(GG::ListBox::iterator it, int object_id) {
if (!m_order_issuing_enabled)
return;
int client_empire_id = HumanClientApp::GetApp()->EmpireID();
Empire* empire = GetEmpire(client_empire_id);
if (!empire)
return;
int rally_point_id = object_id;
if (rally_point_id == INVALID_OBJECT_ID) {
// get rally point from selected system
rally_point_id = SidePanel::SystemID();
}
if (rally_point_id == INVALID_OBJECT_ID)
return;
HumanClientApp::GetApp()->Orders().IssueOrder(
OrderPtr(new ProductionQueueOrder(client_empire_id, std::distance(m_queue_wnd->GetQueueListBox()->begin(), it),
rally_point_id, false, false)));
empire->UpdateProductionQueue();
}
