void ResearchWnd::QueueItemMoved(GG::ListBox::Row* row, std::size_t position)
{
if (QueueRow* queue_row = boost::polymorphic_downcast<QueueRow*>(row))
HumanClientApp::GetApp()->Orders().IssueOrder(
OrderPtr(new ResearchQueueOrder(HumanClientApp::GetApp()->EmpireID(),
queue_row->tech_name, position)));
}
int IssueRequeueProductionOrder(int old_queue_index, int new_queue_index) {
if (old_queue_index == new_queue_index) {
Logger().errorStream() << "AIInterface::IssueRequeueProductionOrder : passed same old and new indexes... nothing to do.";
return 0;
}
int empire_id = AIClientApp::GetApp()->EmpireID();
Empire* empire = AIClientApp::GetApp()->Empires().Lookup(empire_id);
const ProductionQueue& queue = empire->GetProductionQueue();
if (old_queue_index < 0 || static_cast<int>(queue.size()) <= old_queue_index) {
Logger().errorStream() << "AIInterface::IssueRequeueProductionOrder : passed old_queue_index outside range of items on queue.";
return 0;
}
// After removing an earlier entry in queue, all later entries are shifted down one queue index, so
// inserting before the specified item index should now insert before the previous item index. This
// also allows moving to the end of the queue, rather than only before the last item on the queue.
int actual_new_index = new_queue_index;
if (old_queue_index < new_queue_index)
actual_new_index = new_queue_index - 1;
if (new_queue_index < 0 || static_cast<int>(queue.size()) <= actual_new_index) {
Logger().errorStream() << "AIInterface::IssueRequeueProductionOrder : passed new_queue_index outside range of items on queue.";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ProductionQueueOrder(empire_id, old_queue_index, new_queue_index)));
return 1;
}
int IssueScrapOrder(const std::vector<int>& object_ids) {
if (object_ids.empty()) {
Logger().errorStream() << "AIInterface::IssueScrapOrder : passed empty vector of object_ids";
return 0;
}
int empire_id = AIClientApp::GetApp()->EmpireID();
// make sure all objects exist and are owned just by this player
for (std::vector<int>::const_iterator it = object_ids.begin(); it != object_ids.end(); ++it) {
TemporaryPtr<const UniverseObject> obj = GetUniverseObject(*it);
if (!obj) {
Logger().errorStream() << "AIInterface::IssueScrapOrder : passed an invalid object_id";
return 0;
}
if (!obj->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueScrapOrder : passed object_id of object not owned by player";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(new ScrapOrder(empire_id, *it)));
}
return 1;
}
int IssueCreateShipDesignOrder(const std::string& name, const std::string& description,
const std::string& hull, const std::vector<std::string> parts,
const std::string& icon, const std::string& model, bool nameDescInStringTable)
{
if (name.empty() || description.empty() || hull.empty()) {
Logger().errorStream() << "AIInterface::IssueCreateShipDesignOrderOrder : passed an empty name, description, or hull.";
return 0;
}
if (!ShipDesign::ValidDesign(hull, parts)) {
Logger().errorStream() << "AIInterface::IssueCreateShipDesignOrderOrder : pass a hull and parts that do not make a valid ShipDesign";
return 0;
}
int empire_id = AIClientApp::GetApp()->EmpireID();
int current_turn = CurrentTurn();
// create design from stuff chosen in UI
ShipDesign* design = new ShipDesign(name, description, current_turn, ClientApp::GetApp()->EmpireID(),
hull, parts, icon, model, nameDescInStringTable);
if (!design) {
Logger().errorStream() << "AIInterface::IssueCreateShipDesignOrderOrder failed to create a new ShipDesign object";
return 0;
}
int new_design_id = AIClientApp::GetApp()->GetNewDesignID();
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(new ShipDesignOrder(empire_id, new_design_id, *design)));
delete design;
return 1;
}
void ResearchWnd::QueueItemDeletedSlot(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)));
}
int IssueGiveObjectToEmpireOrder(int object_id, int recipient_id) {
int empire_id = AIClientApp::GetApp()->EmpireID();
if (Empires().Lookup(recipient_id) == 0) {
Logger().errorStream() << "AIInterface::IssueGiveObjectToEmpireOrder : given invalid recipient empire id";
return 0;
}
if (Empires().GetDiplomaticStatus(empire_id, recipient_id) != DIPLO_PEACE) {
Logger().errorStream() << "AIInterface::IssueGiveObjectToEmpireOrder : attempting to give to empire not at peace";
return 0;
}
TemporaryPtr<UniverseObject> obj = GetUniverseObject(object_id);
if (!obj) {
Logger().errorStream() << "AIInterface::IssueGiveObjectToEmpireOrder : passed invalid object id";
return 0;
}
if (!obj->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueGiveObjectToEmpireOrder : passed object not owned by player";
return 0;
}
if (obj->ObjectType() != OBJ_FLEET && obj->ObjectType() != OBJ_PLANET) {
Logger().errorStream() << "AIInterface::IssueGiveObjectToEmpireOrder : passed object that is not a fleet or planet";
return 0;
}
TemporaryPtr<System> system = GetSystem(obj->SystemID());
if (!system) {
Logger().errorStream() << "AIInterface::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) {
Logger().errorStream() << "AIInterface::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();
}
}
int IssueBombardOrder(int ship_id, int planet_id) {
int empire_id = AIClientApp::GetApp()->EmpireID();
// make sure ship_id is a ship...
TemporaryPtr<const Ship> ship = GetShip(ship_id);
if (!ship) {
Logger().errorStream() << "AIInterface::IssueBombardOrder : passed an invalid ship_id";
return 0;
}
if (ship->TotalWeaponsDamage() <= 0) {
Logger().errorStream() << "AIInterface::IssueBombardOrder : ship can't attack / bombard";
return 0;
}
if (!ship->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueBombardOrder : ship isn't owned by the order-issuing empire";
return 0;
}
// verify that planet exists and is occupied by another empire
TemporaryPtr<const Planet> planet = GetPlanet(planet_id);
if (!planet) {
Logger().errorStream() << "AIInterface::IssueBombardOrder : no planet with passed planet_id";
return 0;
}
if (planet->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueBombardOrder : planet is already owned by the order-issuing empire";
return 0;
}
if (!planet->Unowned() && Empires().GetDiplomaticStatus(planet->Owner(), empire_id) != DIPLO_WAR) {
Logger().errorStream() << "AIInterface::IssueBombardOrder : planet owned by an empire not at war with order-issuing empire";
return 0;
}
if (GetUniverse().GetObjectVisibilityByEmpire(planet_id, empire_id) < VIS_BASIC_VISIBILITY) {
Logger().errorStream() << "AIInterface::IssueBombardOrder : planet that empire reportedly has insufficient visibility of, but will be allowed to proceed pending investigation";
//return;
}
int ship_system_id = ship->SystemID();
if (ship_system_id == INVALID_OBJECT_ID) {
Logger().errorStream() << "AIInterface::IssueBombardOrder : given id of ship not in a system";
return 0;
}
int planet_system_id = planet->SystemID();
if (ship_system_id != planet_system_id) {
Logger().errorStream() << "AIInterface::IssueBombardOrder : given ids of ship and planet not in the same system";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(new BombardOrder(empire_id, ship_id, planet_id)));
return 1;
}
void ResearchWnd::AddTechToQueueSlot(const std::string& tech_name) {
if (!m_enabled)
return;
int empire_id = HumanClientApp::GetApp()->EmpireID();
const Empire* empire = Empires().Lookup(empire_id);
if (!empire)
return;
const ResearchQueue& queue = empire->GetResearchQueue();
OrderSet& orders = HumanClientApp::GetApp()->Orders();
if (!queue.InQueue(tech_name))
orders.IssueOrder(OrderPtr(new ResearchQueueOrder(empire_id, tech_name, -1)));
}
int IssueColonizeOrder(int ship_id, int planet_id) {
int empire_id = AIClientApp::GetApp()->EmpireID();
// make sure ship_id is a ship...
TemporaryPtr<const Ship> ship = GetShip(ship_id);
if (!ship) {
Logger().errorStream() << "AIInterface::IssueColonizeOrder : passed an invalid ship_id";
return 0;
}
// get fleet of ship
TemporaryPtr<const Fleet> fleet = GetFleet(ship->FleetID());
if (!fleet) {
Logger().errorStream() << "AIInterface::IssueColonizeOrder : ship with passed ship_id has invalid fleet_id";
return 0;
}
// make sure player owns ship and its fleet
if (!fleet->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueColonizeOrder : empire does not own fleet of passed ship";
return 0;
}
if (!ship->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueColonizeOrder : empire does not own passed ship";
return 0;
}
// verify that planet exists and is un-occupied.
TemporaryPtr<const Planet> planet = GetPlanet(planet_id);
if (!planet) {
Logger().errorStream() << "AIInterface::IssueColonizeOrder : no planet with passed planet_id";
return 0;
}
if ((!planet->Unowned()) && !( planet->OwnedBy(empire_id) && planet->CurrentMeterValue(METER_POPULATION)==0)) {
Logger().errorStream() << "AIInterface::IssueColonizeOrder : planet with passed planet_id "<<planet_id<<" is already owned, or colonized by own empire";
return 0;
}
// verify that planet is in same system as the fleet
if (planet->SystemID() != fleet->SystemID()) {
Logger().errorStream() << "AIInterface::IssueColonizeOrder : fleet and planet are not in the same system";
return 0;
}
if (ship->SystemID() == INVALID_OBJECT_ID) {
Logger().errorStream() << "AIInterface::IssueColonizeOrder : ship is not in a system";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(new ColonizeOrder(empire_id, ship_id, planet_id)));
return 1;
}
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 = Empires().Lookup(client_empire_id);
if (!empire)
return;
HumanClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ProductionQueueOrder(client_empire_id, queue_idx, quantity, blocksize)));
empire->UpdateProductionQueue();
}
void ProductionWnd::DeleteQueueItem(GG::ListBox::iterator it) {
if (!m_order_issuing_enabled)
return;
int client_empire_id = HumanClientApp::GetApp()->EmpireID();
Empire* empire = Empires().Lookup(client_empire_id);
if (!empire)
return;
HumanClientApp::GetApp()->Orders().IssueOrder(
OrderPtr(new ProductionQueueOrder(client_empire_id, std::distance(m_queue_lb->begin(), it))));
empire->UpdateProductionQueue();
}
int IssueDequeueTechOrder(const std::string& tech_name) {
const Tech* tech = GetTech(tech_name);
if (!tech) {
Logger().errorStream() << "AIInterface::IssueDequeueTechOrder : passed tech_name that is not the name of a tech.";
return 0;
}
int empire_id = AIClientApp::GetApp()->EmpireID();
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(new ResearchQueueOrder(empire_id, tech_name)));
return 1;
}
void ResearchWnd::AddTechsToQueueSlot(const std::vector<std::string>& tech_vec, int pos) {
if (!m_enabled)
return;
int empire_id = HumanClientApp::GetApp()->EmpireID();
Empire* empire = GetEmpire(empire_id);
if (!empire)
return;
const ResearchQueue& queue = empire->GetResearchQueue();
OrderSet& orders = HumanClientApp::GetApp()->Orders();
for (std::vector<std::string>::const_iterator it = tech_vec.begin(); it != tech_vec.end(); ++it) {
const std::string& tech_name = *it;
if (empire->TechResearched(tech_name))
continue;
// AddTechsToQueueSlot is currently used for (i) adding a tech and any not-yet-queued prereqs to the
// end of the queue (but any already-queued prereqs are NOT to be moved to the end of the queue), or
// (ii) prioritizing a tech by placing it and any not-yet-completed techs, whether currently queued or not,
// to the front of the queue. If at some time this routine is desired to be used to move a group of techs from
// early positions in the queue to later positions, the below tests would need to change.
// If we're adding to the end of the queue (pos==-1), we'll need to put in a ResearchQueueOrder iff the tech is
// not yet in the queue. Otherwise (adding to beginning) we'll need to put in a ResearchQueueOrder if the tech is
// not yet in the queue or if the tech's current position in the queue is after the desired position. When
// adding/moving a group of techs to the queue beginning, we increment our insertion point for every tech we add,
// or that we skipped because it happened to already be in the right spot.
if (pos == -1) {
if (!queue.InQueue(tech_name)) {
orders.IssueOrder(OrderPtr(new ResearchQueueOrder(empire_id, tech_name, pos)));
}
} else if (!queue.InQueue(tech_name) || ((queue.find(tech_name) - queue.begin()) > pos)) {
orders.IssueOrder(OrderPtr(new ResearchQueueOrder(empire_id, tech_name, pos)));
pos += 1;
} else {
if ((queue.find(tech_name) - queue.begin()) == pos)
pos += 1;
}
}
empire->UpdateResearchQueue();
}
int IssueEnqueueBuildingProductionOrder(const std::string& item_name, int location_id) {
int empire_id = AIClientApp::GetApp()->EmpireID();
Empire* empire = AIClientApp::GetApp()->Empires().Lookup(empire_id);
if (!empire->ProducibleItem(BT_BUILDING, item_name, location_id)) {
Logger().errorStream() << "AIInterface::IssueEnqueueBuildingProductionOrder : specified item_name and location_id that don't indicate an item that can be built at that location";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ProductionQueueOrder(empire_id, BT_BUILDING, item_name, 1, location_id)));
return 1;
}
int IssueEnqueueShipProductionOrder(int design_id, int location_id) {
int empire_id = AIClientApp::GetApp()->EmpireID();
Empire* empire = AIClientApp::GetApp()->Empires().Lookup(empire_id);
if (!empire->ProducibleItem(BT_SHIP, design_id, location_id)) {
Logger().errorStream() << "AIInterface::IssueEnqueueShipProductionOrder : specified design_id and location_id that don't indicate a design that can be built at that location";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ProductionQueueOrder(empire_id, BT_SHIP, design_id, 1, location_id)));
return 1;
}
int IssueEnqueueTechOrder(const std::string& tech_name, int position) {
const Tech* tech = GetTech(tech_name);
if (!tech) {
ErrorLogger() << "IssueEnqueueTechOrder : passed tech_name that is not the name of a tech.";
return 0;
}
int empire_id = AIClientApp::GetApp()->EmpireID();
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ResearchQueueOrder(empire_id, tech_name, position)));
return 1;
}
void ProductionWnd::AddBuildToQueueSlot(BuildType build_type, int design_id, int number, int location) {
if (!m_order_issuing_enabled)
return;
int client_empire_id = HumanClientApp::GetApp()->EmpireID();
Empire* empire = Empires().Lookup(client_empire_id);
if (!empire)
return;
HumanClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ProductionQueueOrder(client_empire_id, build_type, design_id, number, location)));
empire->UpdateProductionQueue();
m_build_designator_wnd->CenterOnBuild(m_queue_lb->NumRows() - 1);
}
void ProductionWnd::QueueItemPaused(GG::ListBox::iterator it, bool pause) {
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),
pause, -1.0f)));
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);
}
int IssueNewFleetOrder(const std::string& fleet_name, const std::vector<int>& ship_ids) {
if (ship_ids.empty()) {
Logger().errorStream() << "AIInterface::IssueNewFleetOrder : passed empty vector of ship_ids";
return 0;
}
if (fleet_name.empty()) {
Logger().errorStream() << "AIInterface::IssueNewFleetOrder : tried to create a nameless fleet";
return 0;
}
int empire_id = AIClientApp::GetApp()->EmpireID();
TemporaryPtr<const Ship> ship = TemporaryPtr<Ship>();
// make sure all ships exist and are owned just by this player
for (std::vector<int>::const_iterator it = ship_ids.begin(); it != ship_ids.end(); ++it) {
ship = GetShip(*it);
if (!ship) {
Logger().errorStream() << "AIInterface::IssueNewFleetOrder : passed an invalid ship_id";
return 0;
}
if (!ship->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueNewFleetOrder : passed ship_id of ship not owned by player";
return 0;
}
}
// make sure all ships are at a system, and that all are at the same system
int system_id = ship->SystemID();
if (system_id == INVALID_OBJECT_ID) {
Logger().errorStream() << "AIInterface::IssueNewFleetOrder : passed ship_ids of ships at different locations";
return 0;
}
std::vector<int>::const_iterator it = ship_ids.begin();
for (++it; it != ship_ids.end(); ++it) {
TemporaryPtr<const Ship> ship2 = GetShip(*it);
if (ship2->SystemID() != system_id) {
Logger().errorStream() << "AIInterface::IssueNewFleetOrder : passed ship_ids of ships at different locations";
return 0;
}
}
int new_fleet_id = ClientApp::GetApp()->GetNewObjectID();
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(new NewFleetOrder(empire_id, fleet_name, new_fleet_id, system_id, ship_ids)));
return new_fleet_id;
}
void ResearchWnd::AddMultipleTechsToQueueSlot(const std::vector<std::string>& tech_vec) {
if (!m_enabled)
return;
int empire_id = HumanClientApp::GetApp()->EmpireID();
const Empire* empire = Empires().Lookup(empire_id);
if (!empire)
return;
const ResearchQueue& queue = empire->GetResearchQueue();
OrderSet& orders = HumanClientApp::GetApp()->Orders();
for (std::vector<std::string>::const_iterator it = tech_vec.begin(); it != tech_vec.end(); ++it) {
const std::string& tech_name = *it;
if (!queue.InQueue(tech_name))
orders.IssueOrder(OrderPtr(new ResearchQueueOrder(empire_id, tech_name, -1)));
}
}
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 = Empires().Lookup(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();
}
int IssueDequeueProductionOrder(int queue_index) {
int empire_id = AIClientApp::GetApp()->EmpireID();
Empire* empire = AIClientApp::GetApp()->Empires().Lookup(empire_id);
const ProductionQueue& queue = empire->GetProductionQueue();
if (queue_index < 0 || static_cast<int>(queue.size()) <= queue_index) {
Logger().errorStream() << "AIInterface::IssueDequeueProductionOrder : passed queue_index outside range of items on queue.";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ProductionQueueOrder(empire_id, queue_index)));
return 1;
}
int IssueAggressionOrder(int object_id, bool aggressive) {
int empire_id = AIClientApp::GetApp()->EmpireID();
TemporaryPtr<const Fleet> fleet = GetFleet(object_id);
if (!fleet) {
Logger().errorStream() << "AIInterface::IssueAggressionOrder : no fleet with passed id";
return 0;
}
if (!fleet->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueAggressionOrder : passed object_id of object not owned by player";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new AggressiveOrder(empire_id, object_id, aggressive)));
return 1;
}
int IssueFleetTransferOrder(int ship_id, int new_fleet_id) {
int empire_id = AIClientApp::GetApp()->EmpireID();
TemporaryPtr<const Ship> ship = GetShip(ship_id);
if (!ship) {
Logger().errorStream() << "AIInterface::IssueFleetTransferOrder : passed an invalid ship_id " << ship_id;
return 0;
}
int ship_sys_id = ship->SystemID();
if (ship_sys_id == INVALID_OBJECT_ID) {
Logger().errorStream() << "AIInterface::IssueFleetTransferOrder : ship is not in a system";
return 0;
}
if (!ship->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueFleetTransferOrder : passed ship_id of ship not owned by player";
return 0;
}
TemporaryPtr<const Fleet> fleet = GetFleet(new_fleet_id);
if (!fleet) {
Logger().errorStream() << "AIInterface::IssueFleetTransferOrder : passed an invalid new_fleet_id " << new_fleet_id;
return 0;
}
int fleet_sys_id = fleet->SystemID();
if (fleet_sys_id == INVALID_OBJECT_ID) {
Logger().errorStream() << "AIInterface::IssueFleetTransferOrder : new fleet is not in a system";
return 0;
}
if (!fleet->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueFleetTransferOrder : passed fleet_id "<< new_fleet_id << " of fleet not owned by player";
return 0;
}
if (fleet_sys_id != ship_sys_id) {
Logger().errorStream() << "AIInterface::IssueFleetTransferOrder : new fleet in system " << fleet_sys_id << " and ship in system "<< ship_sys_id << " are not in the same system";
return 0;
}
std::vector<int> ship_ids;
ship_ids.push_back(ship_id);
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(new FleetTransferOrder(empire_id, new_fleet_id, ship_ids)));
return 1;
}
int IssueChangeProductionQuantityOrder(int queue_index, int new_quantity, int new_blocksize) {
int empire_id = AIClientApp::GetApp()->EmpireID();
Empire* empire = AIClientApp::GetApp()->Empires().Lookup(empire_id);
const ProductionQueue& queue = empire->GetProductionQueue();
if (queue_index < 0 || static_cast<int>(queue.size()) <= queue_index) {
Logger().errorStream() << "AIInterface::IssueChangeProductionQuantityOrder : passed queue_index outside range of items on queue.";
return 0;
}
if (queue[queue_index].item.build_type != BT_SHIP) {
Logger().errorStream() << "AIInterface::IssueChangeProductionQuantityOrder : passed queue_index for a non-ship item.";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ProductionQueueOrder(empire_id, queue_index, new_quantity, new_blocksize)));
return 1;
}
int IssueRenameOrder(int object_id, const std::string& new_name) {
if (new_name.empty()) {
Logger().errorStream() << "AIInterface::IssueRenameOrder : passed an empty new name";
return 0;
}
int empire_id = AIClientApp::GetApp()->EmpireID();
TemporaryPtr<const UniverseObject> obj = GetUniverseObject(object_id);
if (!obj) {
Logger().errorStream() << "AIInterface::IssueRenameOrder : passed an invalid object_id";
return 0;
}
if (!obj->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueRenameOrder : passed object_id of object not owned by player";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(new RenameOrder(empire_id, object_id, new_name)));
return 1;
}
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();
}
int IssueChangeFocusOrder(int planet_id, const std::string& focus) {
int empire_id = AIClientApp::GetApp()->EmpireID();
TemporaryPtr<const Planet> planet = GetPlanet(planet_id);
if (!planet) {
Logger().errorStream() << "AIInterface::IssueChangeFocusOrder : no planet with passed planet_id "<<planet_id;
return 0;
}
if (!planet->OwnedBy(empire_id)) {
Logger().errorStream() << "AIInterface::IssueChangeFocusOrder : empire does not own planet with passed planet_id";
return 0;
}
if (false) { // todo: verify that focus is valid for specified planet
Logger().errorStream() << "AIInterface::IssueChangeFocusOrder : invalid focus specified";
return 0;
}
AIClientApp::GetApp()->Orders().IssueOrder(OrderPtr(
new ChangeFocusOrder(empire_id, planet_id, focus)));
return 1;
}