bool Fleet::removeShips(uint32_t type, uint32_t number){
std::map<std::pair<int32_t, uint32_t>, uint32_t> ships = ((RefQuantityListObjectParam*)(obj->getParameter(4,1)))->getRefQuantityList();
if(ships[std::pair<int32_t, uint32_t>(rst_Design, type)] >= number){
ships[std::pair<int32_t, uint32_t>(rst_Design, type)] -= number;
if(ships[std::pair<int32_t, uint32_t>(rst_Design, type)] == 0){
ships.erase(std::pair<int32_t, uint32_t>(rst_Design, type));
}
((RefQuantityListObjectParam*)(obj->getParameter(4,1)))->setRefQuantityList(ships);
DesignStore* ds = Game::getGame()->getDesignStore();
bool colonise = false;
for(std::map<std::pair<int32_t, uint32_t>, uint32_t>::iterator itcurr = ships.begin();
itcurr != ships.end(); ++itcurr){
if(ds->getDesign(itcurr->first.second)->getPropertyValue(ds->getPropertyByName("Colonise")) == 1.0){
colonise = true;
break;
}
}
OrderManager* om = Game::getGame()->getOrderManager();
OrderQueueObjectParam* orderqueue = ((OrderQueueObjectParam*)(obj->getParameter(3,1)));
if(colonise){
std::set<uint32_t> allowed = orderqueue->getAllowedOrders();
allowed.insert(om->getOrderTypeByName("Colonise"));
orderqueue->setAllowedOrders(allowed);
}else{
std::set<uint32_t> allowed = orderqueue->getAllowedOrders();
allowed.erase(om->getOrderTypeByName("Colonise"));
orderqueue->setAllowedOrders(allowed);
}
obj->touchModTime();
return true;
}
return false;
}
bool Build::doOrder(IGObject::Ptr ob)
{
Planet* planet = static_cast<Planet*>(ob->getObjectBehaviour());
uint32_t usedshipres = resources[1];
if(usedshipres == 0)
return true;
int ownerid = planet->getOwner();
if(ownerid == 0){
//currently not owned by anyone, just forget about it
return true;
}
planet->addResource(1, 1);
if(planet->removeResource(1, usedshipres)){
//create fleet
Game* game = Game::getGame();
IGObject::Ptr fleet = game->getObjectManager()->createNewObject();
game->getObjectTypeManager()->setupObject(fleet, game->getObjectTypeManager()->getObjectTypeByName("Fleet"));
//add fleet to container
fleet->addToParent(ob->getID());
fleet->setName(fleetname->getString().c_str());
Fleet * thefleet = ((Fleet*)(fleet->getObjectBehaviour()));
thefleet->setSize(2);
thefleet->setOwner(ownerid); // set ownerid
thefleet->setPosition(planet->getPosition());
thefleet->setVelocity(Vector3d(0LL, 0ll, 0ll));
uint32_t queueid = Game::getGame()->getOrderManager()->addOrderQueue(fleet->getID(), ownerid);
OrderQueueObjectParam* oqop = static_cast<OrderQueueObjectParam*>(fleet->getParameterByType(obpT_Order_Queue));
oqop->setQueueId(queueid);
thefleet->setDefaultOrderTypes();
thefleet->setIcon("common/object-icons/ship");
thefleet->setMedia("common-2d/foreign/vegastrike/ship-small/" + ((MiniSec*)(game->getRuleset()))->getFleetMediaNames()->getName());
//set ship type
IdMap fleettype = fleetlist->getList();
for(IdMap::iterator itcurr = fleettype.begin(); itcurr != fleettype.end(); ++itcurr){
thefleet->addShips(itcurr->first, itcurr->second);
Design::Ptr design = Game::getGame()->getDesignStore()->getDesign(itcurr->first);
design->addComplete(itcurr->second);
Game::getGame()->getDesignStore()->designCountsUpdated(design);
}
//add fleet to universe
Game::getGame()->getObjectManager()->addObject(fleet);
Game::getGame()->getPlayerManager()->getPlayer(ownerid)->getPlayerView()->addOwnedObject(fleet->getID());
Message::Ptr msg( new Message() );
msg->setSubject("Build Fleet order complete");
msg->setBody(std::string("The construction of your new fleet \"") + fleetname->getString() + "\" is complete.");
msg->addReference(rst_Action_Order, rsorav_Completion);
msg->addReference(rst_Object, fleet->getID());
msg->addReference(rst_Object, ob->getID());
Game::getGame()->getPlayerManager()->getPlayer(ownerid)->postToBoard(msg);
return true;
}
return false;
}
void TaeTurn::doTurn() {
//check to make sure the game is still ging and this is not a combat turn
if(isGameOver) {
gameOver();
return;
} else if(combat) {
doCombatTurn();
return;
}
std::set<uint32_t>::iterator itcurr;
Game* game = Game::getGame();
OrderManager* ordermanager = game->getOrderManager();
ObjectManager* objectmanager = game->getObjectManager();
ObjectTypeManager* obtm = game->getObjectTypeManager();
PlayerManager::Ptr playermanager = game->getPlayerManager();
//build map for storing orders
std::map<uint32_t, std::list<IGObject::Ptr > > playerOrders;
containerids.clear();
//separate orders by player
std::set<uint32_t> objects = objectmanager->getAllIds();
for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->getType() == planettype || ob->getType() == fleettype) {
OrderQueueObjectParam* oqop = dynamic_cast<OrderQueueObjectParam*>(ob->getParameterByType(obpT_Order_Queue));
if(oqop != NULL) {
OrderQueue::Ptr orderqueue = ordermanager->getOrderQueue(oqop->getQueueId());
if(orderqueue != NULL) {
Order * currOrder = orderqueue->getFirstOrder();
if(currOrder != NULL) {
uint32_t owner = ((OwnedObject*)(ob->getObjectBehaviour()))->getOwner();
std::list<IGObject::Ptr >::iterator i = playerOrders[owner].end();
playerOrders[owner].insert(i, ob);
}
}
}
}
}
//Do orders for players in the correct order
//The order in which orders are processed is rotated each turn
std::set<uint32_t> players = playermanager->getAllIds();
itcurr = players.begin();
for(int i = 0; i < playerTurn; i++) {
itcurr++;
}
for(uint32_t it = 0; it < players.size(); it++) {
if(itcurr == players.end()) {
itcurr = players.begin();
}
if(playerOrders[*itcurr].size() > 0) {
for(std::list<IGObject::Ptr >::iterator i = playerOrders[*itcurr].begin(); i != playerOrders[*itcurr].end(); i++) {
OrderQueue::Ptr orderqueue = ordermanager->getOrderQueue(((OrderQueueObjectParam*)((*i)->getParameterByType(obpT_Order_Queue)))->getQueueId());
Order* currOrder = orderqueue->getFirstOrder();
if(currOrder!= NULL) {
if(currOrder->doOrder(*i)) {
orderqueue->removeFirstOrder();
} else {
orderqueue->updateFirstOrder();
}
}
if((*i)->getContainerType() >= 1) {
containerids.insert((*i)->getID());
}
objectmanager->doneWithObject((*i)->getID());
}
}
itcurr++;
}
awardArtifacts();
//Check for end game condition of less than 3 artifacts remaining
objects = objectmanager->getAllIds();
int numArtifacts = 0;
for(itcurr = objects.begin(); itcurr != objects.end(); itcurr++) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->getType() == obtm->getObjectTypeByName("Planet")) {
Planet* p = (Planet*) ob->getObjectBehaviour();
if(p->getResource(3) > 0) {
numArtifacts++;
}
}
}
if(numArtifacts < 3) {
isGameOver = true;
gameOver();
return;
}
//Update which player's turn it is
playerTurn = (playerTurn + 1) % playermanager->getNumPlayers();
objectmanager->clearRemovedObjects();
// to once a turn
for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->isAlive()) {
ob->getObjectBehaviour()->doOnceATurn();
}
objectmanager->doneWithObject(ob->getID());
}
// find the objects that are visible to each player
std::set<uint32_t> vis = objectmanager->getAllIds();
for(std::set<uint32_t>::iterator itplayer = players.begin(); itplayer != players.end(); ++itplayer) {
Player::Ptr player = playermanager->getPlayer(*itplayer);
PlayerView::Ptr playerview = player->getPlayerView();
for(std::set<uint32_t>::iterator itob = vis.begin(); itob != vis.end(); ++itob) {
ObjectView::Ptr obv = playerview->getObjectView(*itob);
if(obv == NULL) {
if(objectmanager->getObject(*itob)->isAlive()) {
playerview->addVisibleObject( *itob, true );
}
objectmanager->doneWithObject(*itob);
} else {
IGObject::Ptr ro = objectmanager->getObject(*itob);
uint64_t obmt = ro->getModTime();
objectmanager->doneWithObject(*itob);
if(obmt > obv->getModTime()) {
obv->setModTime(obmt);
playerview->updateObjectView(*itob);
}
}
}
// remove dead objects
std::set<uint32_t> goneobjects;
std::set<uint32_t> knownobjects = playerview->getVisibleObjects();
set_difference(knownobjects.begin(), knownobjects.end(), vis.begin(), vis.end(), inserter(goneobjects, goneobjects.begin()));
for(std::set<uint32_t>::iterator itob = goneobjects.begin(); itob != goneobjects.end(); ++itob) {
ObjectView::Ptr obv = playerview->getObjectView(*itob);
if(!obv->isGone()) {
obv->setGone(true);
playerview->updateObjectView(*itob);
}
}
//Replace colonist fleets
int fleets = 0;
IGObject::Ptr homePlanet;
for(std::set<uint32_t>::iterator itob = objects.begin(); itob != objects.end(); ++itob) {
IGObject::Ptr ob = objectmanager->getObject(*itob);
if(ob->getName().compare("Colonist Fleet") == 0) {
uint32_t owner = ((OwnedObject*)(ob->getObjectBehaviour()))->getOwner();
if(owner == *itplayer) {
fleets++;
}
}
if(ob->getName().compare(string(player->getName() + "'s Home Planet")) == 0) {
homePlanet = ob;
}
}
for(int i = fleets; i < 6; i++) {
IGObject::Ptr fleet = fleetBuilder->createFleet(FleetBuilder::PASSENGER_FLEET, FleetBuilder::RANDOM_SHIP, player, homePlanet, "Colonist Fleet");
game->getObjectManager()->addObject(fleet);
player->getPlayerView()->addVisibleObject(fleet->getID(), true);
}
//Send end of turn message to each player
Message::Ptr msg( new Message() );
msg->setSubject("Turn complete");
stringstream out;
out << "Your Current Score: \n";
out << "Money: " << player->getScore(1) << "\n";
out << "Technology: " << player->getScore(2) << "\n";
out << "People: " << player->getScore(3) << "\n";
out << "Raw Materials: " << player->getScore(4) << "\n";
out << "Alien Artifacts: " << player->getScore(5);
msg->setBody(out.str());
player->postToBoard(msg);
//Alert players to the turn order for next round
msg.reset( new Message() );
msg->setSubject("Turn Order");
string body = "The order for the next turn is: ";
itcurr = players.begin();
for(int i = 0; i < playerTurn; i++) {
itcurr++;
}
for(uint32_t it = 0; it < players.size(); it++) {
if(itcurr == players.end()) {
itcurr = players.begin();
}
body += playermanager->getPlayer(*itcurr)->getName();
body += " ";
itcurr++;
}
msg->setBody(body);
player->postToBoard(msg);
}
//Initialize combat if the next turn is a combat turn
if(combat) {
initCombat();
}
playermanager->updateAll();
}
void TaeTurn::doCombatTurn() {
std::set<uint32_t>::iterator itcurr;
Game* game = Game::getGame();
OrderManager* ordermanager = game->getOrderManager();
ObjectManager* objectmanager = game->getObjectManager();
ObjectTypeManager* obtm = game->getObjectTypeManager();
PlayerManager::Ptr playermanager = game->getPlayerManager();
containerids.clear();
// Do orders
std::set<uint32_t> objects = objectmanager->getAllIds();
for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->getType() == planettype || ob->getType() == fleettype) {
OrderQueueObjectParam* oqop = dynamic_cast<OrderQueueObjectParam*>(ob->getParameterByType(obpT_Order_Queue));
if(oqop != NULL) {
OrderQueue::Ptr orderqueue = ordermanager->getOrderQueue(oqop->getQueueId());
if(orderqueue != NULL) {
Order * currOrder = orderqueue->getFirstOrder();
if(currOrder != NULL) {
if(currOrder->doOrder(ob)) {
orderqueue->removeFirstOrder();
} else {
orderqueue->updateFirstOrder();
}
}
if(ob->getContainerType() >= 1) {
containerids.insert(ob->getID());
}
objectmanager->doneWithObject((ob)->getID());
}
}
}
}
//Determine winner
uint32_t winner = 0;
uint32_t loser = 0;
for(map<uint32_t, int>::iterator i = strength.begin(); i != strength.end(); ++i) {
if(winner == 0) {
winner = i->first;
} else {
if(strength[winner] < i->second) {
winner = i->first;
} else {
loser = i->first;
}
}
}
//Remove losing combatants
uint32_t losingRegion;
uint32_t winningRegion;
set<uint32_t> removedSystems;
if(isInternal) {
//Internal combat removes losing leader and awards one point to the winner
for(map<uint32_t, uint32_t>::iterator i = combatants.begin(); i != combatants.end(); ++i) {
IGObject::Ptr ob = objectmanager->getObject(i->first);
Fleet* f = (Fleet*) ob->getObjectBehaviour();
if(f->getOwner() != winner) {
sendHome(i->first);
Player::Ptr p = playermanager->getPlayer(winner);
p->setScore(2, p->getScore(2) + 1);
losingRegion = i->second;
winningRegion = losingRegion;
}
}
objects = objectmanager->getAllIds();
for(itcurr = objects.begin(); itcurr!= objects.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->getType() == obtm->getObjectTypeByName("Star System")) {
StarSystem* sysData = (StarSystem*) ob->getObjectBehaviour();
if(sysData->getRegion() == losingRegion) {
sysData->setRegion(0);
removedSystems.insert(*itcurr);
}
}
}
} else {
//External combat removes the losing leader and losing colonies.
//1 point is awarded for the leader and each colony removed
string shipType;
//set shiptype, losing/winning regions, and send home the losing leader
for(map<uint32_t, uint32_t>::iterator i = combatants.begin(); i != combatants.end(); ++i) {
IGObject::Ptr ob = objectmanager->getObject(i->first);
Fleet* f = (Fleet*) ob->getObjectBehaviour();
if(f->getOwner() != winner) {
losingRegion = i->second;
shipType = ob->getName();
sendHome(i->first);
} else {
winningRegion = i->second;
}
}
//set the correct resource type
int resourceType;
if(shipType.compare("Merchant Leader") == 0) {
resourceType = 4;
} else if(shipType.compare("Scientist Leader") == 0) {
resourceType = 5;
} else if(shipType.compare("Settler Leader") == 0) {
resourceType = 6;
} else {
resourceType = 7;
}
//add 1 to the winner for removing the leader
Player::Ptr player = playermanager->getPlayer(winner);
player->setScore(resourceType - 3, player->getScore(resourceType-3) + 1);
//remove all losing colonies
objects = objectmanager->getAllIds();
for(itcurr = objects.begin(); itcurr!= objects.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->getType() == obtm->getObjectTypeByName("Planet")) {
IGObject::Ptr sys = objectmanager->getObject(ob->getParent());
StarSystem* sysData = (StarSystem*) sys->getObjectBehaviour();
if(sysData->getRegion() == losingRegion) {
Planet* p = (Planet*) ob->getObjectBehaviour();
sysData->setRegion(0);
if(p->getResource(resourceType) > 0) {
p->removeResource(resourceType, 1);
player->setScore(resourceType - 3, player->getScore(resourceType-3) + 1);
} else {
removedSystems.insert(sys->getID());
}
} else if(sysData->getRegion() == winningRegion) {
sysData->setRegion(0);
removedSystems.insert(sys->getID());
}
}
}
}
//rebuild region
for(itcurr = removedSystems.begin(); itcurr!= removedSystems.end(); ++itcurr) {
rebuildRegion(*itcurr);
}
//Check for combat
combat = false;
while(!combatQueue.empty() && !combat) {
pair<bool, map<uint32_t, uint32_t> > temp = combatQueue.front();
combatQueue.pop();
isInternal = temp.first;
combatants = temp.second;
combat = true;
uint32_t region = 0;
for(map<uint32_t, uint32_t>::iterator i = combatants.begin(); i != combatants.end() && combat; i++) {
IGObject::Ptr ob = objectmanager->getObject(i->first);
IGObject::Ptr sys = objectmanager->getObject(ob->getParent());
StarSystem* sysData = (StarSystem*) sys->getObjectBehaviour();
i->second = sysData->getRegion();
if(region == 0) {
region = sysData->getRegion();
} else if(region != sysData->getRegion()) {
combat = false;
}
}
}
//Cleanup and Set visibility
objects = objectmanager->getAllIds();
set<uint32_t> views;
for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->getType() == obtm->getObjectTypeByName("Fleet") && !combat) {
Fleet* f = (Fleet*) ob->getObjectBehaviour();
f->toggleCombat();
f->setCombatant(false);
}
//Set visibility
views.insert(ob->getID());
}
std::set<uint32_t> players = playermanager->getAllIds();
std::set<uint32_t> vis = objectmanager->getAllIds();
//clear the removed objecs
objectmanager->clearRemovedObjects();
objects = objectmanager->getAllIds();
for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->isAlive()) {
ob->getObjectBehaviour()->doOnceATurn();
}
objectmanager->doneWithObject(ob->getID());
}
for(std::set<uint32_t>::iterator itplayer = players.begin(); itplayer != players.end(); ++itplayer) {
Player::Ptr player = playermanager->getPlayer(*itplayer);
PlayerView::Ptr playerview = player->getPlayerView();
//Update visibility
playerview->addVisibleObjects(views);
for(std::set<uint32_t>::iterator itob = vis.begin(); itob != vis.end(); ++itob) {
ObjectView::Ptr obv = playerview->getObjectView(*itob);
if(obv == NULL) {
if(objectmanager->getObject(*itob)->isAlive()) {
playerview->addVisibleObject(*itob, true);
}
objectmanager->doneWithObject(*itob);
} else {
IGObject::Ptr ro = objectmanager->getObject(*itob);
uint64_t obmt = ro->getModTime();
objectmanager->doneWithObject(*itob);
if(obmt > obv->getModTime()) {
obv->setModTime(obmt);
playerview->updateObjectView(*itob);
}
}
}
// remove dead objects
std::set<uint32_t> goneobjects;
std::set<uint32_t> knownobjects = playerview->getVisibleObjects();
set_difference(knownobjects.begin(), knownobjects.end(), vis.begin(), vis.end(), inserter(goneobjects, goneobjects.begin()));
for(std::set<uint32_t>::iterator itob = goneobjects.begin(); itob != goneobjects.end(); ++itob) {
ObjectView::Ptr obv = playerview->getObjectView(*itob);
if(!obv->isGone()) {
obv->setGone(true);
playerview->updateObjectView(*itob);
}
}
//Replace colonist fleets
int fleets = 0;
IGObject::Ptr homePlanet;
for(std::set<uint32_t>::iterator itob = objects.begin(); itob != objects.end(); ++itob) {
IGObject::Ptr ob = objectmanager->getObject(*itob);
if(ob->getName().compare("Colonist Fleet") == 0) {
uint32_t owner = ((OwnedObject*)(ob->getObjectBehaviour()))->getOwner();
if(owner == *itplayer) {
fleets++;
}
}
if(ob->getName().compare(string(player->getName() + "'s Home Planet")) == 0) {
homePlanet = ob;
}
}
for(int i = fleets; i < 6; i++) {
IGObject::Ptr fleet = fleetBuilder->createFleet(FleetBuilder::PASSENGER_FLEET, FleetBuilder::RANDOM_SHIP, player, homePlanet, "Colonist Fleet");
game->getObjectManager()->addObject(fleet);
player->getPlayerView()->addVisibleObject(fleet->getID(), true);
}
//Send end of turn message to each player
Message::Ptr msg( new Message() );
msg->setSubject("Combat Complete!");
stringstream out;
Player::Ptr win = playermanager->getPlayer(winner);
out << win->getName() << " has won the battle with a strength of ";
out << strength[winner] << "!";
msg->setBody(out.str());
player->postToBoard(msg);
msg.reset( new Message() );
msg->setSubject("Turn complete");
stringstream out2;
out2 << "Your Current Score: \n";
out2 << "Money: " << player->getScore(1) << "\n";
out2 << "Technology: " << player->getScore(2) << "\n";
out2 << "People: " << player->getScore(3) << "\n";
out2 << "Raw Materials: " << player->getScore(4) << "\n";
out2 << "Alien Artifacts: " << player->getScore(5);
msg->setBody(out2.str());
player->postToBoard(msg);
}
if(combat) {
initCombat();
}
playermanager->updateAll();
}
//This function gets the top bid for the given object
pair<IGObject::Ptr ,uint32_t> Colonize::getTopPlayerAndBid(IGObject::Ptr obj) {
pair<IGObject::Ptr ,uint32_t> result;
result.second = 0;
Planet* origin = dynamic_cast<Planet*>(obj->getObjectBehaviour());
assert(origin);
Logger::getLogger()->debug("\tCollecting all bids on object %s",origin->getName().c_str());
Game* game = Game::getGame();
OrderManager* ordM = game->getOrderManager();
ObjectManager* objM = game->getObjectManager();
//Construct the map to be used, the identifier is the planet, the value is the bid
map<IGObject::Ptr ,uint32_t> bids;
//Get all objects from object manager
set<uint32_t> objectsIds = objM->getAllIds();
//Iterate over every object
for(set<uint32_t>::iterator i = objectsIds.begin(); i != objectsIds.end(); ++i)
{
//Get current object
IGObject::Ptr currObj = objM->getObject(*i);
//Print out current planet
Planet* bidder = dynamic_cast<Planet*>(currObj->getObjectBehaviour());
if (bidder != NULL) {
Logger::getLogger()->debug("\t\tLooking at orders on object %s",bidder->getName().c_str());
}
//Get order queue from object
OrderQueueObjectParam* oqop = dynamic_cast<OrderQueueObjectParam*>(currObj->getParameterByType(obpT_Order_Queue));
OrderQueue::Ptr oq;
//Validate that the oq exists
if(oqop != NULL && (oq = ordM->getOrderQueue(oqop->getQueueId())) != NULL)
{
//Iterate over all orders
for (uint32_t j = 0; j < oq->getNumberOrders(); j++)
{
OwnedObject *orderedObj = dynamic_cast<OwnedObject*>(currObj->getObjectBehaviour());
Order* order = NULL;
if ( orderedObj != NULL ) {
order = oq->getOrder(j, orderedObj->getOwner());
}
Logger::getLogger()->debug("\t\tThere exists a %s order on %s", order->getName().c_str(), bidder->getName().c_str());
//if order is a colonize order
if( order != NULL && order->getName() == "Colonize")
{
Colonize* colonize = dynamic_cast<Colonize*>(order);
assert(colonize);
//Get the list of planetIDs and the # of units to move
IdMap list = colonize->getTargetList()->getList();
//Iterate over all suborders
for(IdMap::iterator i = list.begin(); i != list.end(); ++i) {
uint32_t planetID = i->first;
uint32_t numUnits = i->second;
format debug("\t\t\tEncountered suborder to Colonize %1% with %2% units");
debug % planetID; debug % numUnits;
Logger::getLogger()->debug(debug.str().c_str());
IGObject::Ptr target = Game::getGame()->getObjectManager()->getObject(planetID);
if ( target == obj ) {
bids[currObj] += numUnits;
}
}
}
else if ( order->getName() != "Colonize")
{
j = oq->getNumberOrders() + 1; //force the loop to exit, we have "left" the frontal Colonize orders
}
}
currObj->touchModTime();
}
objM->doneWithObject(currObj->getID());
}
//Iterate over all bids and restrict them to the maximum armies availible on that planet
for(map<IGObject::Ptr ,uint32_t>::iterator i = bids.begin(); i != bids.end(); ++i) {
Logger::getLogger()->debug("Iterating over all bids to pick the highest legal bid.");
//FIXME: Somewhere in this "for" the server crashes when a single bid is created for 1 unit when planet only has 1 unit left
//Restrict players bid to 1 less than their current reinforcements
Planet* planet = dynamic_cast<Planet*>(i->first->getObjectBehaviour());
assert(planet);
result.first = i->first;
uint32_t numUnits = i->second;
uint32_t maxUnits = planet->getResource("Army").first;
//If there is overflow of numUnits, check for maxUnits over 0 insures we don't set unsigned to < 0
if ( numUnits >= maxUnits && maxUnits > 0) {
if ( maxUnits > 0)
numUnits = maxUnits - 1;
else
numUnits = 0;
}
i->second = numUnits;
result.second = i->second;
}
sendPlayerMessages(obj, bids,result);
if (result.first == NULL)
{
}
format debugMsg("Found highest bidder to be from planet #%1% with %2% units");
debugMsg % result.first->getName(); debugMsg % result.second;
Logger::getLogger()->debug(debugMsg.str().c_str());
return result;
}
bool BuildFleet::doOrder(IGObject::Ptr ob)
{
Logger::getLogger()->debug("Entering BuildFleet::doOrder");
Planet* planet = static_cast<Planet*>(ob->getObjectBehaviour());
Game* game = Game::getGame();
ResourceManager::Ptr resman = game->getResourceManager();
const uint32_t resType = resman->getResourceDescription("Factories")->getResourceType();
const uint32_t resValue = planet->getResourceSurfaceValue(resType);
int ownerid = planet->getOwner();
if(ownerid == 0){
Logger::getLogger()->debug("Exiting BuildFleet::doOrder ownerid == 0");
//currently not owned by anyone, just forget about it
return true;
}
uint32_t runningTotal = resources[1];
if (resValue == 0) {
Message::Ptr msg(new Message());
msg->setSubject("Build Fleet order error");
msg->setBody(std::string("The construction of your new fleet \"") + fleetname->getString() + "\" has been delayed, you do not have any production points this turn.");
Game::getGame()->getPlayerManager()->getPlayer(ownerid)->postToBoard(msg);
return false;
} else if(runningTotal > resValue) {
if (planet->removeResource(resType, resValue)) {
removeResource(1, resValue);
runningTotal = resources[1];
uint32_t planetFactories = planet->getFactoriesPerTurn();
turns = static_cast<uint32_t>(ceil(runningTotal / planetFactories));
Message::Ptr msg(new Message());
msg->setSubject("Build Fleet order slowed");
msg->setBody(std::string("The construction of your new fleet \"") + fleetname->getString() + "\" has been delayed.");
Game::getGame()->getPlayerManager()->getPlayer(ownerid)->postToBoard(msg);
return false;
}
} else if(runningTotal <= resValue && planet->removeResource(resType, runningTotal)){
//create fleet
//this is probably unnecessary
resources[1] = 0;
Game* game = Game::getGame();
IGObject::Ptr fleet = game->getObjectManager()->createNewObject();
game->getObjectTypeManager()->setupObject(fleet, game->getObjectTypeManager()->getObjectTypeByName("Fleet"));
//add fleet to container
fleet->addToParent(ob->getID());
fleet->setName(fleetname->getString().c_str());
Fleet * thefleet = dynamic_cast<Fleet*>(fleet->getObjectBehaviour());
thefleet->setSize(2);
thefleet->setOwner(ownerid); // set ownerid
thefleet->setPosition(planet->getPosition());
thefleet->setVelocity(Vector3d(0LL, 0ll, 0ll));
uint32_t queueid = Game::getGame()->getOrderManager()->addOrderQueue(fleet->getID(), ownerid);
OrderQueueObjectParam* oqop = static_cast<OrderQueueObjectParam*>(fleet->getParameterByType(obpT_Order_Queue));
oqop->setQueueId(queueid);
thefleet->setDefaultOrderTypes();
//set ship type
IdMap fleettype = fleetlist->getList();
for(IdMap::iterator itcurr = fleettype.begin(); itcurr != fleettype.end(); ++itcurr){
thefleet->addShips(itcurr->first, itcurr->second);
Design::Ptr design = Game::getGame()->getDesignStore()->getDesign(itcurr->first);
design->addComplete(itcurr->second);
Game::getGame()->getDesignStore()->designCountsUpdated(design);
}
//add fleet to universe
Game::getGame()->getObjectManager()->addObject(fleet);
Game::getGame()->getPlayerManager()->getPlayer(ownerid)->getPlayerView()->addOwnedObject(fleet->getID());
Message::Ptr msg( new Message() );
msg->setSubject("Build Fleet order complete");
msg->setBody(std::string("The construction of your new fleet \"") + fleetname->getString() + "\" is complete.");
msg->addReference(rst_Action_Order, rsorav_Completion);
msg->addReference(rst_Object, fleet->getID());
msg->addReference(rst_Object, ob->getID());
Game::getGame()->getPlayerManager()->getPlayer(ownerid)->postToBoard(msg);
Logger::getLogger()->debug("Exiting BuildFleet::doOrder on Success");
return true;
}
Logger::getLogger()->debug("Exiting BuildFleet::doOrder on failure");
return false;
}
void taeRuleset::onPlayerAdded(Player* player) {
Logger::getLogger()->debug("TaE onPlayerAdded");
Game *game = Game::getGame();
PlayerView* playerview = player->getPlayerView();
ObjectTypeManager* obtm = game->getObjectTypeManager();
//Set Player's score to 0
player->setScore(1,0);
player->setScore(2,0);
player->setScore(3,0);
player->setScore(4,0);
player->setScore(5,0);
//Set visibility of current designs
std::set<uint32_t> allotherdesigns = Game::getGame()->getDesignStore()->getDesignIds();
for(std::set<uint32_t>::const_iterator desid = allotherdesigns.begin(); desid != allotherdesigns.end(); ++desid){
DesignView* dv = new DesignView();
dv->setDesignId(*desid);
playerview->addVisibleDesign(dv);
}
for(uint32_t i = 1; i <= game->getDesignStore()->getMaxComponentId(); ++i){
playerview->addUsableComponent(i);
}
std::set<uint32_t> mydesignids;
//Add system and planet to hold player's fleets
IGObject* sys1 = game->getObjectManager()->createNewObject();
obtm->setupObject(sys1, obtm->getObjectTypeByName("Star System"));
StarSystem* sys1ob = (StarSystem*)(sys1->getObjectBehaviour());
sys1ob->setSize(60000ll);
sys1->setName(player->getName() + "'s System");
sys1ob->setPosition(Vector3d(1ll+80000*player->getID(), 1ll, 0ll));
sys1ob->setInhabitable(true);
sys1ob->setDestroyed(true);
sys1->addToParent(1);
game->getObjectManager()->addObject(sys1);
IGObject *p = game->getObjectManager()->createNewObject();
obtm->setupObject(p, obtm->getObjectTypeByName("Planet"));
Planet * pob = (Planet*)(p->getObjectBehaviour());
pob->setSize(2);
p->setName(player->getName() + "'s Home Planet");
pob->setPosition(sys1ob->getPosition());
OrderQueue *planetoq = new OrderQueue();
planetoq->setObjectId(p->getID());
planetoq->addOwner(player->getID());
game->getOrderManager()->addOrderQueue(planetoq);
OrderQueueObjectParam* oqop = static_cast<OrderQueueObjectParam*>(p->getParameterByType(obpT_Order_Queue));
oqop->setQueueId(planetoq->getQueueId());
pob->setDefaultOrderTypes();
p->addToParent(sys1->getID());
game->getObjectManager()->addObject(p);
//Setup starting fleets
IGObject* fleet;
//Colonist fleets
for(int i = 0; i < 6; i++) {
fleet = fleetBuilder->createFleet(FleetBuilder::PASSENGER_FLEET, FleetBuilder::RANDOM_SHIP, player, p, "Colonist Fleet");
game->getObjectManager()->addObject(fleet);
}
//Leader fleets
fleet = fleetBuilder->createFleet(FleetBuilder::VIP_FLEET, FleetBuilder::MERCHANT_SHIP, player, p, "Merchant Leader");
game->getObjectManager()->addObject(fleet);
fleet = fleetBuilder->createFleet(FleetBuilder::VIP_FLEET, FleetBuilder::SCIENTIST_SHIP, player, p, "Scientist Leader");
game->getObjectManager()->addObject(fleet);
fleet = fleetBuilder->createFleet(FleetBuilder::VIP_FLEET, FleetBuilder::SETTLER_SHIP, player, p, "Settler Leader");
game->getObjectManager()->addObject(fleet);
fleet = fleetBuilder->createFleet(FleetBuilder::VIP_FLEET, FleetBuilder::MINING_SHIP, player, p, "Mining Leader");
game->getObjectManager()->addObject(fleet);
//Bomber fleets
for(int i = 0; i < 2; i++) {
fleet = fleetBuilder->createFleet(FleetBuilder::BOMBER_FLEET, NULL, player, p, "Bomber");
game->getObjectManager()->addObject(fleet);
}
//Set visibility of new designs and objects
std::set<uint32_t> objids = game->getObjectManager()->getAllIds();
for(std::set<uint32_t>::iterator itcurr = objids.begin(); itcurr != objids.end(); ++itcurr){
ObjectView* obv = new ObjectView();
obv->setObjectId(*itcurr);
obv->setCompletelyVisible(true);
playerview->addVisibleObject(obv);
}
std::set<uint32_t> playerids = game->getPlayerManager()->getAllIds();
for(std::set<uint32_t>::iterator playerit = playerids.begin(); playerit != playerids.end(); ++playerit){
Player* oplayer = game->getPlayerManager()->getPlayer(*playerit);
game->getPlayerManager()->updatePlayer(oplayer->getID());
}
}
void taeRuleset::createBoard(string path, uint32_t galaxy) {
Game* game = Game::getGame();
ObjectManager* obm = game->getObjectManager();
ObjectTypeManager* obtm = game->getObjectTypeManager();
stack<string> lines;
string line;
int row = 0;
ifstream file (path.c_str());
//Attempt to read in a custom map
if (file.is_open())
{
while(!file.eof()) {
getline (file,line);
lines.push(line);
}
if(lines.top().compare("") == 0) {
lines.pop();
}
file.close();
} else {
//Build default map
lines.push(string("....MMMMM.A.M..."));
lines.push(string(".A..M.......M..A"));
lines.push(string("...MMA......MM.."));
lines.push(string("MMMM.........MMM"));
lines.push(string(".............AMM"));
lines.push(string("..............M."));
lines.push(string("MMMM....A...MMM."));
lines.push(string(".A.MMMM.....M..."));
lines.push(string("......MMMMMMM.A."));
lines.push(string(".....A.........."));
lines.push(string("..........A....."));
}
while(!lines.empty()) {
line = lines.top();
lines.pop();
for(int i = 0; i < line.length(); i++) {
//Create a star system
IGObject* sys1 = obm->createNewObject();
obtm->setupObject(sys1, obtm->getObjectTypeByName("Star System"));
StarSystem* sys1ob = (StarSystem*)(sys1->getObjectBehaviour());
sys1ob->setSize(60000ll);
char* name = new char[8];
sprintf(name, "%d, %d", i, row);
sys1->setName(name);
sys1ob->setPosition(Vector3d(1ll + 80000ll*i, 1ll+80000ll*(row+1), 0ll));
sys1ob->setDestroyed(false);
sys1->addToParent(galaxy);
obm->addObject(sys1);
//Create a planet
IGObject *p = obm->createNewObject();
obtm->setupObject(p, obtm->getObjectTypeByName("Planet"));
Planet * pob = (Planet*)(p->getObjectBehaviour());
pob->setSize(2);
char* planetName = new char[20];
sprintf(planetName, "Planet %d, %d", i, row);
p->setName(planetName);
pob->setPosition(sys1ob->getPosition());
OrderQueue *planetoq = new OrderQueue();
planetoq->setObjectId(p->getID());
planetoq->addOwner(0);
game->getOrderManager()->addOrderQueue(planetoq);
OrderQueueObjectParam* oqop = static_cast<OrderQueueObjectParam*>(p->getParameterByType(obpT_Order_Queue));
oqop->setQueueId(planetoq->getQueueId());
pob->setDefaultOrderTypes();
p->addToParent(sys1->getID());
obm->addObject(p);
if(line[i] == '.') {
sys1ob->setInhabitable(true);
} else if (line[i] == 'M') {
sys1ob->setInhabitable(false);
pob->addResource(1,1);
} else if (line[i] == 'A') {
sys1ob->setInhabitable(true);
sys1ob->setRegion(sys1->getID());
pob->addResource(3,1);
pob->addResource(5,1);
}
}
row++;
}
}
void RftsTurn::doTurn() {
Game* game = Game::getGame();
OrderManager* ordermanager = game->getOrderManager();
ObjectManager* objectmanager = game->getObjectManager();
PlayerManager::Ptr pm = game->getPlayerManager();
set<uint32_t> objectsIds = objectmanager->getAllIds();
// currently just go through each obj and do each order
// will be prioritized/sorted soon TODO
for(set<uint32_t>::iterator i = objectsIds.begin();
i != objectsIds.end(); ++i)
{
IGObject::Ptr currObj = objectmanager->getObject(*i);
OrderQueueObjectParam* oqop = dynamic_cast<OrderQueueObjectParam*>(currObj->getParameterByType(obpT_Order_Queue));
OrderQueue::Ptr oq;
if(oqop != NULL &&
(oq = ordermanager->getOrderQueue(oqop->getQueueId())) != NULL)
{
for(uint32_t j = 0; j < oq->getNumberOrders(); j++)
{
OwnedObject *orderedObj = dynamic_cast<OwnedObject*>(currObj->getObjectBehaviour());
assert(orderedObj);
Order* order = oq->getOrder(j, orderedObj->getOwner());
if(order->doOrder(currObj))
{
oq->removeOrder(j, orderedObj->getOwner());
j--; // list has been reordered
}
else
oq->updateFirstOrder(); // CHECK
}
currObj->touchModTime();
}
objectmanager->doneWithObject(currObj->getID());
}
objectmanager->clearRemovedObjects();
// re-explore new area
setPlayerVisibleObjects();
// to once a turn (right at the end)
objectsIds = objectmanager->getAllIds();
for(std::set<uint32_t>::iterator i = objectsIds.begin();
i != objectsIds.end(); ++i)
{
IGObject::Ptr obj = objectmanager->getObject(*i);
obj->getObjectBehaviour()->doOnceATurn();
objectmanager->doneWithObject(obj->getID());
}
objectmanager->clearRemovedObjects();
// update in case fleets were destroyed in combat
setPlayerVisibleObjects();
set<uint32_t> players = pm->getAllIds();
for(set<uint32_t>::iterator i = players.begin(); i != players.end(); ++i)
PlayerInfo::getPlayerInfo(*i).clearPdbUpgrade();
Player::Ptr winner = getWinner();
if(winner != NULL)
{
string body;
Message::Ptr gameOver( new Message() );
gameOver->setSubject("Game over!");
if( game->getTurnNumber() ==
static_cast<unsigned>(strtol(Settings::getSettings()->get("game_length").c_str(), NULL, 10)) )
body = "Game length elapsed, winner is: ";
else
body = "Overwhelming victory by: ";
body += winner->getName();
gameOver->setBody(PlayerInfo::appAllVictoryPoints(body));
for(set<uint32_t>::iterator i = players.begin(); i != players.end(); ++i)
pm->getPlayer(*i)->postToBoard( Message::Ptr( new Message(*gameOver) ));
}
int turn = game->getTurnNumber() % 3;
if(turn == 0){
game->setTurnName("Production, Construction, Movement");
}else if(turn == 1){
game->setTurnName("Construction, Movement");
}else{
game->setTurnName("Movement");
}
}
void MinisecTurn::doTurn(){
std::set<uint32_t>::iterator itcurr;
Game* game = Game::getGame();
OrderManager* ordermanager = game->getOrderManager();
ObjectManager* objectmanager = game->getObjectManager();
RSPCombat* combatstrategy = new RSPCombat();
PlayerManager::Ptr playermanager = game->getPlayerManager();
//sort by order type
std::set<uint32_t> movers;
std::set<uint32_t> otherorders;
std::set<uint32_t> interceptors;
containerids.clear();
std::set<uint32_t> possiblecombatants;
std::set<uint32_t> objects = objectmanager->getAllIds();
for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->getType() == planettype || ob->getType() == fleettype){
possiblecombatants.insert(ob->getID());
OrderQueueObjectParam* oqop = dynamic_cast<OrderQueueObjectParam*>(ob->getParameterByType(obpT_Order_Queue));
if(oqop != NULL){
OrderQueue::Ptr orderqueue = ordermanager->getOrderQueue(oqop->getQueueId());
if(orderqueue != NULL){
Order * currOrder = orderqueue->getFirstOrder();
if(currOrder != NULL){
if(currOrder->getType() == ordermanager->getOrderTypeByName("Move")){
movers.insert(ob->getID());
} else if (currOrder->getType() == ordermanager->getOrderTypeByName("Intercept")){
interceptors.insert(ob->getID());
}else{
otherorders.insert(ob->getID());
}
}
}
}
}
if(ob->getContainerType() >= 1){
containerids.insert(ob->getID());
}
objectmanager->doneWithObject(ob->getID());
}
// do move
for(itcurr = movers.begin(); itcurr != movers.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
OrderQueueObjectParam* oqop = dynamic_cast<OrderQueueObjectParam*>(ob->getParameterByType(obpT_Order_Queue));
OrderQueue::Ptr orderqueue = ordermanager->getOrderQueue(oqop->getQueueId());
Order * currOrder = orderqueue->getFirstOrder();
if(currOrder->doOrder(ob)){
orderqueue->removeFirstOrder();
}else{
orderqueue->updateFirstOrder();
}
objectmanager->doneWithObject(ob->getID());
}
// do interceptions
for(itcurr = interceptors.begin(); itcurr != interceptors.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
OrderQueueObjectParam* oqop = dynamic_cast<OrderQueueObjectParam*>(ob->getParameterByType(obpT_Order_Queue));
OrderQueue::Ptr orderqueue = ordermanager->getOrderQueue(oqop->getQueueId());
Order * currOrder = orderqueue->getFirstOrder();
if(currOrder->doOrder(ob)){
orderqueue->removeFirstOrder();
}else{
orderqueue->updateFirstOrder();
}
objectmanager->doneWithObject(ob->getID());
}
// do combat
std::list<std::map<uint32_t, std::set<uint32_t> > > combats;
for(itcurr = possiblecombatants.begin(); itcurr != possiblecombatants.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
uint32_t playerid1;
Vector3d pos1;
uint32_t size1;
if(ob->getType() == planettype){
Planet* planet = (Planet*)(ob->getObjectBehaviour());
playerid1 = planet->getOwner();
pos1 = planet->getPosition();
size1 = planet->getSize();
}else{
Fleet* fleet = (Fleet*)(ob->getObjectBehaviour());
playerid1 = fleet->getOwner();
pos1 = fleet->getPosition();
size1 = fleet->getSize();
}
if(playerid1 == 0){
objectmanager->doneWithObject(ob->getID());
continue;
}
bool placed = false;
for(std::list<std::map<uint32_t, std::set<uint32_t> > >::iterator itlist = combats.begin();
itlist != combats.end(); ++itlist){
std::map<uint32_t, std::set<uint32_t> > themap = *itlist;
for(std::map<uint32_t, std::set<uint32_t> >::iterator itmap = themap.begin();
itmap != themap.end(); ++itmap){
std::set<uint32_t> theset = itmap->second;
for(std::set<uint32_t>::iterator itset = theset.begin(); itset != theset.end(); ++itset){
IGObject::Ptr itbobj = objectmanager->getObject(*itset);
uint32_t playerid2;
Vector3d pos2;
uint32_t size2;
if(itbobj->getType() == planettype){
Planet* planet = (Planet*)(itbobj->getObjectBehaviour());
playerid2 = planet->getOwner();
pos2 = planet->getPosition();
size2 = planet->getSize();
}else{
Fleet* fleet = (Fleet*)(itbobj->getObjectBehaviour());
playerid2 = fleet->getOwner();
pos2 = fleet->getPosition();
size2 = fleet->getSize();
}
if(playerid2 == 0){
objectmanager->doneWithObject(itbobj->getID());
continue;
}
uint64_t diff = pos1.getDistance(pos2);
if(diff <= size1 / 2 + size2 / 2){
themap[playerid1].insert(ob->getID());
*itlist = themap;
placed = true;
objectmanager->doneWithObject(itbobj->getID());
break;
}
objectmanager->doneWithObject(itbobj->getID());
}
if(placed)
break;
}
if(placed)
break;
}
if(!placed){
std::map<uint32_t, std::set<uint32_t> > themap;
std::set<uint32_t> theset;
theset.insert(ob->getID());
themap[playerid1] = theset;
combats.push_back(themap);
}
objectmanager->doneWithObject(ob->getID());
}
for(std::list<std::map<uint32_t, std::set<uint32_t> > >::iterator itlist = combats.begin();
itlist != combats.end(); ++itlist){
std::map<uint32_t, std::set<uint32_t> > themap = *itlist;
if(themap.size() >= 2){
combatstrategy->doCombat(themap);
}
}
objectmanager->clearRemovedObjects();
// do other orders (nop, buildfleet, colonise)
for(itcurr = otherorders.begin(); itcurr != otherorders.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob != NULL){
if(ob->getType() == planettype || ob->getType() == fleettype){
OrderQueueObjectParam* oqop = dynamic_cast<OrderQueueObjectParam*>(ob->getParameterByType(obpT_Order_Queue));
if(oqop != NULL){
OrderQueue::Ptr orderqueue = ordermanager->getOrderQueue(oqop->getQueueId());
if(orderqueue != NULL){
Order * currOrder = orderqueue->getFirstOrder();
if(currOrder != NULL){
if(currOrder->doOrder(ob)){
orderqueue->removeFirstOrder();
}else{
orderqueue->updateFirstOrder();
}
}
}
}
}
objectmanager->doneWithObject(ob->getID());
}
}
objectmanager->clearRemovedObjects();
// to once a turn (right at the end)
objects = objectmanager->getAllIds();
for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) {
IGObject::Ptr ob = objectmanager->getObject(*itcurr);
if(ob->isAlive()){
ob->getObjectBehaviour()->doOnceATurn();
}
objectmanager->doneWithObject(ob->getID());
}
// find the objects that are visible to each player
std::set<uint32_t> vis = objectmanager->getAllIds();
std::set<uint32_t> players = playermanager->getAllIds();
uint32_t numaliveplayers = 0;
uint32_t numdeadplayers = 0;
for(std::set<uint32_t>::iterator itplayer = players.begin(); itplayer != players.end(); ++itplayer){
Player::Ptr player = playermanager->getPlayer(*itplayer);
PlayerView::Ptr playerview = player->getPlayerView();
for(std::set<uint32_t>::iterator itob = vis.begin(); itob != vis.end(); ++itob){
ObjectView::Ptr obv = playerview->getObjectView(*itob);
if(!obv){
if(objectmanager->getObject(*itob)->isAlive()){
playerview->addVisibleObject( *itob, true );
}
objectmanager->doneWithObject(*itob);
}else{
IGObject::Ptr ro = objectmanager->getObject(*itob);
uint64_t obmt = ro->getModTime();
objectmanager->doneWithObject(*itob);
if(obmt > obv->getModTime()){
obv->setModTime(obmt);
playerview->updateObjectView(*itob);
}
}
}
// remove dead objects
std::set<uint32_t> goneobjects;
std::set<uint32_t> knownobjects = playerview->getVisibleObjects();
set_difference(knownobjects.begin(), knownobjects.end(), vis.begin(), vis.end(), inserter(goneobjects, goneobjects.begin()));
for(std::set<uint32_t>::iterator itob = goneobjects.begin(); itob != goneobjects.end(); ++itob){
ObjectView::Ptr obv = playerview->getObjectView(*itob);
if(!obv->isGone()){
obv->setGone(true);
playerview->updateObjectView(*itob);
}
}
if(!player->isAlive() || playerview->getNumberOwnedObjects() == 0){
if(player->isAlive()){
Message::Ptr msg( new Message() );
msg->setSubject("You lost");
msg->setBody("You do not own any objects, therefore you game has finished.");
msg->addReference(rst_Action_Player, rspav_Eliminated);
player->postToBoard(msg);
player->setIsAlive(false);
}
numdeadplayers++;
}else{
numaliveplayers++;
}
}
if(numaliveplayers == 1){
//find alive player
Player::Ptr player;
for(std::set<uint32_t>::iterator itplayer = players.begin(); itplayer != players.end(); ++itplayer){
player = playermanager->getPlayer(*itplayer);
if(player->isAlive())
break;
}
if(player->getScore(0) != numdeadplayers - 1){
Message::Ptr msg( new Message() );
msg->setSubject("You won!");
msg->setBody("You have eliminated all the competing players. Congratulations!");
player->postToBoard(msg);
player->setScore(0, numdeadplayers - 1);
}
}
playermanager->updateAll();
delete combatstrategy;
}
