bool UnloadArmament::doOrder(IGObject::Ptr ob){ Fleet* fleet = dynamic_cast<Fleet*>(ob->getObjectBehaviour()); ObjectManager* obman = Game::getGame()->getObjectManager(); ObjectTypeManager* otman = Game::getGame()->getObjectTypeManager(); ResourceManager::Ptr resman = Game::getGame()->getResourceManager(); std::set<uint32_t>objs = obman->getObjectsByPos(fleet->getPosition(), 10000); IGObject::Ptr planetObj; Planet* planet; for (std::set<uint32_t>::const_iterator itcurr = objs.begin(); itcurr != objs.end(); ++itcurr) { if (obman->getObject(*itcurr)->getType() == otman->getObjectTypeByName("Planet")) { planetObj = obman->getObject(*itcurr); planet = dynamic_cast<Planet*>(planetObj->getObjectBehaviour()); Logger::getLogger()->debug("UnloadArmaments::doOrder Found Planet %s for Unload Armaments Order", planetObj->getName().c_str()); const uint32_t factoryType = resman->getResourceDescription("Factories")->getResourceType(); IdMap weapontype = weaponlist->getList(); for(IdMap::iterator weaponit = weapontype.begin(); weaponit != weapontype.end(); ++weaponit) { if (planet->removeResource(factoryType, 1)) { if (fleet->removeResource(weaponit->first, weaponit->second)) { Logger::getLogger()->debug("UnloadArmaments::doOrder success, adding to resource %d: #:%d", weaponit->first, weaponit->second); planet->addResource(weaponit->first, weaponit->second); planetObj->touchModTime(); return true; } } else { turns = 1; return true; } } } } return false; }
void DumpWorldToSyncLog( char *_filename ) { FILE *file = fopen( _filename, "a" ); if( !file ) return; fprintf( file, "\n\nBegin Final Object Positions\n" ); for( int i = 0; i < g_app->GetWorld()->m_teams.Size(); ++i ) { Team *team = g_app->GetWorld()->m_teams[i]; for( int j = 0; j < team->m_fleets.Size(); ++j ) { Fleet *fleet = team->m_fleets[j]; char *state = fleet->LogState(); fprintf( file, "%s\n", state ); } } for( int i = 0; i < g_app->GetWorld()->m_objects.Size(); ++i ) { if( g_app->GetWorld()->m_objects.ValidIndex(i) ) { WorldObject *obj = g_app->GetWorld()->m_objects[i]; char *state = obj->LogState(); fprintf( file, "%s\n", state ); } } fclose(file); }
//Sends a fleet back to it's home planet void TaeTurn::sendHome(uint32_t fleet) { Game* game = Game::getGame(); ObjectManager* obm = game->getObjectManager(); ObjectTypeManager* obtm = game->getObjectTypeManager(); PlayerManager::Ptr pm = game->getPlayerManager(); IGObject::Ptr fleetobj = obm->getObject(fleet); //Check to make sure it is really a fleet if(fleetobj->getType() != obtm->getObjectTypeByName("Fleet")) { return; } //Get all the required objects Fleet* f = (Fleet*) fleetobj->getObjectBehaviour(); Player::Ptr p = pm->getPlayer(f->getOwner()); IGObject::Ptr sys = obm->getObject(fleetobj->getParent()); StarSystem* sysData = (StarSystem*) sys->getObjectBehaviour(); //Remove fleet from system sysData->setRegion(0); fleetobj->removeFromParent(); //Find it's home planet std::set<uint32_t> objects = obm->getAllIds(); std::set<uint32_t>::iterator itcurr; for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) { IGObject::Ptr ob = obm->getObject(*itcurr); if(ob->getName().compare(string(p->getName() + "'s Home Planet")) == 0) { Planet* p = (Planet*) ob->getObjectBehaviour(); f->setPosition(p->getPosition()); fleetobj->addToParent(ob->getID()); } } }
std::map<uint32_t, std::pair<std::string, uint32_t> > LoadArmament::generateListOptions(){ Logger::getLogger()->debug("Entering LoadArmament::generateListOptions"); std::map<uint32_t, std::pair<std::string, uint32_t> > options; Game* game = Game::getGame(); IGObject::Ptr selectedObj = game->getObjectManager()->getObject( game->getOrderManager()->getOrderQueue(orderqueueid)->getObjectId()); Fleet* fleet = dynamic_cast<Fleet*>(selectedObj->getObjectBehaviour()); ObjectManager* obman = Game::getGame()->getObjectManager(); ObjectTypeManager* otman = Game::getGame()->getObjectTypeManager(); ResourceManager::Ptr resman = Game::getGame()->getResourceManager(); std::set<uint32_t>objs = obman->getObjectsByPos(fleet->getPosition(), 10000); for (std::set<uint32_t>::iterator itcurr = objs.begin(); itcurr != objs.end(); ++itcurr) { if (obman->getObject(*itcurr)->getType() == otman->getObjectTypeByName("Planet")) { IGObject::Ptr planetObj = obman->getObject(*itcurr); Planet* planet = dynamic_cast<Planet*>(planetObj->getObjectBehaviour()); Logger::getLogger()->debug("Found Planet %s for Load Armaments Order", planetObj->getName().c_str()); std::map<uint32_t, std::pair<uint32_t, uint32_t> > reslist = planet->getResources(); for (std::map<uint32_t, std::pair<uint32_t, uint32_t> >::iterator it = reslist.begin(); it != reslist.end(); ++it) { if (resman->getResourceDescription(it->first)->getUnitSingular() == "weapon") { options[it->first] = std::pair<std::string, uint32_t>(resman->getResourceDescription(it->first)->getNamePlural(), planet->getResourceSurfaceValue(it->first)); } } } } Logger::getLogger()->debug("Exiting LoadArmament::generateListOptions"); return options; }
bool Fleet::operator == (const Fleet& fleet) const{ return (_ownerID==fleet.OwnerID() && _source_planet_id==fleet.SourcePlanetID() && _destination_planet_id==fleet.DestinationPlanetID() && _num_ships==fleet.NumShips() && _turns_remaining==fleet.TurnsRemaining() ); }
void PlanetWarsGame::advanceGame() { //Make planets grow ships. const int numPlanets = static_cast<int>(m_planets.size()); for (int i = 0; i < numPlanets; ++i) { m_planets[i]->growFleets(); } //Advance fleets. for (FleetList::iterator it = m_fleets.begin(); it != m_fleets.end(); ++it) { (*it)->advance(); } //Welcome (or fight) the arrived fleets. for (int i = 0; i < numPlanets; ++i) { m_planets[i]->welcomeArrivedFleets(); } //Clean up arrived fleets. FleetList::iterator itFleet = m_fleets.begin(); while (itFleet != m_fleets.end()) { FleetList::iterator itCurrent = itFleet; ++itFleet; Fleet* fleet = (*itCurrent); if (fleet->getTurnsRemaining() <= 0) { delete fleet; m_fleets.erase(itCurrent); } } }
int Move::getETA(IGObject *ob) const{ Fleet* fleet = ((Fleet*)(ob->getObjectBehaviour())); unsigned long long distance = coords->getPosition().getDistance(fleet->getPosition()); unsigned long max_speed = 3000000; if(distance == 0) return 1; return (int)((distance - 1) / max_speed) + 1; }
void panel_clicked_fleet(int mx, int my, int mb) { Fleet *flt = (Fleet*)cur_object; if(mx >= 800 && mb == 4) { --panel_offset; panel_draw_fleet(); SDL_Rect screenrec = {800, 12+24*SKIP, 224, 24*23}; screenrec.h = min(int(screenrec.h), 24*(flt->NumShips())); update(&screenrec); return; } if(mx >= 800 && mb == 5) { ++panel_offset; panel_draw_fleet(); SDL_Rect screenrec = {800, 12+24*SKIP, 224, 24*23}; screenrec.h = min(int(screenrec.h), 24*(flt->NumShips())); update(&screenrec); return; } int line = my; line -= 12+24*SKIP; if(line >= 0) line /= 24; if(line < 0 || line > 22 || line >= int(flt->NumShips()) - panel_offset) { if(selection >= 0) { update(800, 12+24*(SKIP+selection-panel_offset), 224, 24); selection = -1; panel_draw_fleet(); } return; } line += panel_offset; if(mb == 3) { } else if(mb == 1) { SDL_Rect screenrec = {800, 12+24*SKIP, 224, 24}; if(selection >= 0) { screenrec.y = 12+24*(SKIP+selection); update(&screenrec); } if(selection != line) { selection = line; screenrec.y = 12+24*(SKIP+selection); update(&screenrec); panel_draw_fleet(); } else { cur_ship = line; panel = PANEL_SHIP; panel_init(); } audio_play(click2, 8, 8); } }
Fleet* Fleet::Clone(int empire_id) const { Visibility vis = GetUniverse().GetObjectVisibilityByEmpire(this->ID(), empire_id); if (!(vis >= VIS_BASIC_VISIBILITY && vis <= VIS_FULL_VISIBILITY)) return 0; Fleet* retval = new Fleet(); retval->Copy(this, empire_id); return retval; }
bool Bombard::doOrder(IGObject *fleet) { Game *game = Game::getGame(); ObjectManager *om = game->getObjectManager(); ObjectTypeManager *odm = game->getObjectTypeManager(); Random *rand = game->getRandom(); IGObject *planetObj = om->getObject(planet->getObjectId()); if(planetObj->getType() != odm->getObjectTypeByName("Planet")) { Logger::getLogger()->debug("Player tried to bombard something illogical"); return true; } Fleet *fleetData = dynamic_cast<Fleet*>(fleet->getObjectBehaviour()); Planet *planetData = dynamic_cast<Planet*>(planetObj->getObjectBehaviour()); char planetShipTech = PlayerInfo::getPlayerInfo(planetData->getOwner()).getShipTechLevel(); double attack = fleetData->getAttack(); planetData->removeResource("Industry", static_cast<uint32_t>(attack * INDUSTRY_DMG * (1+rand->getInRange(-2,2)/100.) )); planetData->removeResource("Social Environment", static_cast<uint32_t>(attack * SOCIAL_DMG * (1+rand->getInRange(-2,2)/100.) )); planetData->removeResource("Planetary Environment", static_cast<uint32_t>(attack * PLANETARY_DMG * (1+rand->getInRange(-2,2)/100.) )); planetData->removeResource(string("PDB") + planetShipTech, static_cast<uint32_t>(attack * PDB_DMG / 10. * (1+rand->getInRange(-2,2)/100.) )); PlayerInfo::getPlayerInfo(fleetData->getOwner()).addVictoryPoints(VICTORY_POINTS); // PDBs counter-attack at: PDB level * 6 * numPDBs fleetData->takeDamage( (planetShipTech - '0') * 6 * planetData->getResource(string("PDB") + planetShipTech).first); Message *msg = new Message(); msg->setSubject("Bombard complete"); string body = "Fleet \"" + fleet->getName() + "\" bombarded " + planetObj->getName(); msg->setBody(PlayerInfo::appAllVictoryPoints(body)); msg->addReference(rst_Action_Order, rsorav_Completion); msg->addReference(rst_Object, fleet->getID()); msg->addReference(rst_Object, planetObj->getID()); game->getPlayerManager()->getPlayer(fleetData->getOwner())->postToBoard(msg); game->getPlayerManager()->getPlayer(planetData->getOwner())->postToBoard(msg); return true; }
void Planet::welcomeArrivedFleets() { const int ownerId = m_owner->getId(); //Tally up the ships for each force. const int numArrivedFleets = static_cast<int>(m_landedFleets.size()); if (numArrivedFleets == 0) { return; } int playerShips[3]; playerShips[0] = (ownerId == 0) ? m_numShips : 0; playerShips[1] = (ownerId == 1) ? m_numShips : 0; playerShips[2] = (ownerId == 2) ? m_numShips : 0; for (int i = 0; i < numArrivedFleets; ++i) { Fleet* fleet = m_landedFleets[i]; playerShips[fleet->getOwner()->getId()] += fleet->getNumShips(); } m_landedFleets.clear(); //Check who won. //Check whether the owner stays the same. if (playerShips[ownerId] >= std::max(playerShips[(ownerId+1)%3], playerShips[(ownerId+2)%3])) { this->setNumShips(playerShips[ownerId] - std::max(playerShips[(ownerId+1)%3], playerShips[(ownerId+2)%3])); return; } //Otherwise, find the new owner. if (playerShips[1] > playerShips[2]) { this->setOwner(m_game->getFirstPlayer()); const int remainingShips = playerShips[1] - std::max(playerShips[2], playerShips[0]); this->setNumShips(remainingShips); } else if (playerShips[2] > playerShips[1]) { this->setOwner(m_game->getSecondPlayer()); const int remainingShips = playerShips[2] - std::max(playerShips[1], playerShips[0]); this->setNumShips(remainingShips); } else if (ownerId == 0 && playerShips[2] == playerShips[1]) { //The invading fleets are larger than the neutral planet, but equal in size. //Planet stays neutral. this->setNumShips(0); } //There should be no other cases. }
void StarSystem::addFleet(Fleet& input_fleet) { fleets.insert(std::pair<int,Fleet>(input_fleet.getID(),input_fleet) ); // cout << "added fleet with id " << input_fleet.getID() << endl; }
void NormalGame::display_stats() { STACKTRACE; pause(); int i; for (i = 0; i < num_players; i += 1) { Fleet *fleet = player_fleet[i]; switch (log->type) { case Log::log_net1client: case Log::log_net1server: { // if (log->get_direction(player_control[i]->channel) & Log::direction_write) message.print(6000, 15, "%s status: : %d / ?? Ships, %d / ??? points", player_name[i], fleet->getSize(), fleet->getCost()); // else // message.print(6000, 15, "%s status: : %d / %d points", buffy, fleet->cost, player_total_fleet[i]); } break; default: { message.print(6000, 15, "%s status: : %d / ?? Ships, %d / ??? points", player_name[i], fleet->getSize(), fleet->getCost()); } break; } } unpause(); return; }
std::string PlanetWarsGame::toString(Player* pov) const { std::stringstream gameState; const int numPlanets = static_cast<int>(m_planets.size()); //Write the planets. for (int i = 0; i < numPlanets; ++i) { Planet* planet = m_planets[i]; gameState << "P " << planet->getX() << " " << planet->getY() << " " << pov->povId(planet->getOwner()) << " " << planet->getNumShips() << " " << planet->getGrowthRate() << std::endl; } //Write the fleets. for (FleetList::const_iterator it = m_fleets.begin(); it != m_fleets.end(); ++it) { Fleet* fleet = (*it); gameState << "F " << pov->povId(fleet->getOwner()) << " " << fleet->getNumShips() << " " << fleet->getSource()->getId() << " " << fleet->getDestination()->getId() << " " << fleet->getTotalTripLength() << " " << fleet->getTurnsRemaining() << std::endl; } gameState << "go" << std::endl; return gameState.str(); }
void CargoHolder::AdjustAmounts(CargoType ct, long amount) { if (amount == 0) return; if (ct >= 0) { mContains[ct] += amount; } else if (ct == POPULATION) { mPopulation += amount; } else if (ct == FUEL) { Fleet * f = dynamic_cast<Fleet *>(this); if (f == NULL) { assert(false); } else f->AdjustFuel(amount); } else { assert(false); } }
int my_list_proc( int msg, DIALOG* d, int c ) { STACKTRACE; int old_d1 = d->d1; Fleet *fleet = (Fleet*)d->dp3; int ret = d_list_proc2( msg, d, c ); if ( d->d1 != old_d1 || msg == MSG_START ) { ShipType* type = fleet->getShipType(d->d1); ASSERT(type != NULL); selectDialog[SELECT_DIALOG_TITLE].flags |= D_DIRTY; sprintf(selectTitleString, "%s\n%s\n%d of %d points", selectShipPrompt, (type != NULL) ? type->name : 0, (type != NULL) ? type->cost : 0, fleet->getCost()); BITMAP* panel = NULL; TW_DATAFILE* data = tw_load_datafile_object( type->data->file, "SHIP_P00_PCX" ); if ( data ) { BITMAP* bmp = (BITMAP*)data->dat; panel = create_bitmap_ex( bitmap_color_depth(screen), bmp->w, bmp->h ); blit( bmp, panel, 0, 0, 0, 0, bmp->w, bmp->h ); tw_unload_datafile_object( data ); data = tw_load_datafile_object( type->data->file, "SHIP_P01_PCX" ); bmp = (BITMAP*)data->dat; blit( bmp, panel, 0, 0, 4, 65, bmp->w, bmp->h ); tw_unload_datafile_object( data ); color_correct_bitmap( panel, 0 ); } if ( selectDialog[SELECT_DIALOG_PIC].dp ) destroy_bitmap( (BITMAP*)selectDialog[SELECT_DIALOG_PIC].dp ); selectDialog[SELECT_DIALOG_PIC].dp = panel; scare_mouse(); SEND_MESSAGE( &selectDialog[SELECT_DIALOG_PIC], MSG_DRAW, 0 ); unscare_mouse(); } return ret; }
std::map<uint32_t, std::pair<std::string, uint32_t> > UnloadArmament::generateListOptions(){ Logger::getLogger()->debug("Entering UnloadArmament::generateListOptions"); std::map<uint32_t, std::pair<std::string, uint32_t> > options; Game* game = Game::getGame(); IGObject::Ptr selectedObj = game->getObjectManager()->getObject( game->getOrderManager()->getOrderQueue(orderqueueid)->getObjectId()); Fleet* fleet = dynamic_cast<Fleet*>(selectedObj->getObjectBehaviour()); ResourceManager::Ptr resman = Game::getGame()->getResourceManager(); std::map<uint32_t, std::pair<uint32_t, uint32_t> > objs = fleet->getResources(); for (std::map<uint32_t, std::pair<uint32_t, uint32_t> >::iterator itcurr = objs.begin(); itcurr != objs.end(); ++itcurr) { options[itcurr->first] = std::pair<std::string, uint32_t>(resman->getResourceDescription(itcurr->first)->getNamePlural(), itcurr->second.first); } Logger::getLogger()->debug("Exiting UnloadArmament::generateListOptions"); return options; }
void Planet::advanceState(uint nr_turns, Fleets* arrivingFleets){ Fleet* tempFleet; for(uint i=1;i<=nr_turns;i++){ uint ships[NUM_PLAYERS]; ships[PLAYER_NEUTRAL]=ships[PLAYER_1]=ships[PLAYER_2]=0; if(_ownerID!=PLAYER_NEUTRAL){ ships_count+=_growth_rate; } ships[_ownerID]=ships_count; for(uint j=0;j<arrivingFleets->size();j++){ tempFleet = arrivingFleets->at(j); if(tempFleet->TurnsRemaining()==i){ ships[tempFleet->OwnerID()]+=tempFleet->NumShips(); } } //std::cerr << "arriving ships: " << ships[0] << " " << ships[1] << " " << ships[2] << std::endl; uint greatest_id = _ownerID; uint second_greatest_id=0; for(uint j=0;j<NUM_PLAYERS;j++){ if(ships[j]>ships[greatest_id]) greatest_id=j; } for(uint j=0;j<NUM_PLAYERS;j++){ if(j!=greatest_id && ships[j]>ships[second_greatest_id]) second_greatest_id=j; } //std::cerr << "Player " << greatest_id << " has ships: " << ships[greatest_id] << " second: " << second_greatest_id << " " << ships[second_greatest_id] << std::endl; if(ships[greatest_id]==ships[second_greatest_id]){ ships_count = 0; } else { //std::cerr << "setting owner: " << greatest_id << " new ship count: " << ships[greatest_id]-ships[second_greatest_id] << std::endl; _ownerID = greatest_id; ships_count = ships[greatest_id]-ships[second_greatest_id]; } } }
void TempFleet::ChaseeGone(SpaceObject * chasee) { Planet * planet = chasee->InOrbit(); Message * mess = NCGetOwner()->AddMessage("Chasee has vanished", chasee); if (planet == NULL) mess->AddItem("Last location", new Location(*chasee), true); else mess->AddItem("Last location", planet); Fleet * f = dynamic_cast<Fleet *>(GetRealCH()); if (f != NULL) { deque<WayOrder *> const & ords = f->GetOrders(); int i; for (i = 0; i < ords.size(); ++i) { if (ords[i]->GetLocation() == chasee) { if (planet == NULL) ords[i]->SetLocation(new Location(*chasee), true); else ords[i]->SetLocation(planet); } } } }
void GameController::onSetFleetShipNumber(int ships) { Fleet* fleet = NULL; fleet = fleets.last(); fleet->getSource()->setShips(fleet->getSource()->getShips() - ships); fleet->setNumShips(ships); fleet->setKillPercent(fleet->getSource()->getKillPercent()); fleet->setArrivalTurn(currentTurn+2); fleet->getSource()->blink(); fleet->getDestination()->blink(); fleet = new Fleet(); fleets.append(fleet); emit displayControl(QString("<font color=%1>%2</font>:Select source planet").arg(players[currentPlayer]->getColor().name()).arg(players[currentPlayer]->getName())); }
void GameController::onSetSelectPlanet(Planet* planet) { Fleet* fleet = NULL; /* on first selection and since last assumes that the vector is not empty */ if(fleets.isEmpty()) { fleet = new Fleet(); fleets.append(fleet); } fleet = fleets.last(); if(fleet->getSource() == NULL) /* selecting source */ { if(planet->getOwner() != players[currentPlayer]) /* if trying to choose a source planet that isn't yours */ return; planet->blink(); fleet->setSource(planet); fleet->setKillPercent(planet->getKillPercent()); fleet->setOwner(players[currentPlayer]); emit displayControl(QString("<font color=%1>%2</font>:Select destination planet").arg(players[currentPlayer]->getColor().name()).arg(players[currentPlayer]->getName())); } else if(fleet->getDestination() == NULL) /* selecting destination */ { if(fleet->getSource() == planet) /* source and destination are the same */ return; planet->blink(); fleet->setDestination(planet); emit displayShipNumber(); emit displayControl(QString("<font color=%1>%2</font>:Number of ships").arg(players[currentPlayer]->getColor().name()).arg(players[currentPlayer]->getName())); } }
//The colonize order checks to make sure the system is valid, then adds a resource to the planet, checks for //external combat, and awards one point to the player with the leader in the region of the new colony. bool Colonize::doOrder(IGObject::Ptr obj) { ObjectManager* obm = Game::getGame()->getObjectManager(); ObjectTypeManager* obtm = Game::getGame()->getObjectTypeManager(); Fleet* fleetData = (Fleet*)(obj->getObjectBehaviour()); Player::Ptr player = Game::getGame()->getPlayerManager()->getPlayer(fleetData->getOwner()); IGObject::Ptr newStarSys = obm->getObject(starSys->getObjectId()); //Perform last minute checks to make sure the system can be colonized if(newStarSys->getType() != obtm->getObjectTypeByName("Star System")) { //Not a star system Logger::getLogger()->debug("Trying to colonize to an object which is not a star system"); Message::Ptr msg( new Message() ); msg->setSubject("Colonize order failed"); msg->setBody(string("You're fleet, \"" + obj->getName() + "\" tried to colonize an object which is not a star system!")); msg->addReference(rst_Object, obj->getID()); player->postToBoard(msg); return false; } if(!((StarSystem*)(newStarSys->getObjectBehaviour()))->canBeColonized(isMining)) { //Not colonizable Logger::getLogger()->debug("Player tried to colonize a system which cannot be colonized."); Message::Ptr msg( new Message() ); msg->setSubject("Colonize order failed"); msg->setBody(string("You're fleet, \"" + obj->getName() + "\" tried to colonize a fleet which cannot be colonized!")); msg->addReference(rst_Object, obj->getID()); player->postToBoard(msg); return false; } //Find the star system's planet set<uint32_t> children = newStarSys->getContainedObjects(); uint32_t pid; bool planetFound = false; for(set<uint32_t>::iterator i=children.begin(); i != children.end(); i++) { if(obm->getObject(*i)->getType() == obtm->getObjectTypeByName("Planet")) { pid = *i; planetFound = true; } } if(!planetFound) { Logger::getLogger()->debug("Colonize Order: No planet found in target star system"); return false; } //Add resource to planet Planet* planet = (Planet*)(obm->getObject(pid)->getObjectBehaviour()); Design::Ptr ship = Game::getGame()->getDesignStore()->getDesign(fleetData->getShips().begin()->first); uint32_t scoreType = 0; string leaderName; if(ship->getName().compare("MerchantShip") == 0) { planet->addResource(4, 1); scoreType = 1; leaderName = "MerchantLeaderShip"; } else if(ship->getName().compare("ScientistShip") == 0) { planet->addResource(5, 1); scoreType = 2; leaderName = "ScientistLeaderShip"; } else if(ship->getName().compare("SettlerShip") == 0) { planet->addResource(6, 1); scoreType = 3; leaderName = "SettlerLeaderShip"; } else if(ship->getName().compare("MiningShip") == 0) { planet->addResource(7, 1); scoreType = 4; leaderName = "MiningLeaderShip"; } //Get bordering star systems' regions StarSystem* starSysData = (StarSystem*)(newStarSys->getObjectBehaviour()); set<uint32_t> regions = getBorderingRegions(); //Put the newly colonized ship into the proper region //If it does not border any regions, then set it to a new one with a unique id if(regions.size() == 0) { starSysData->setRegion(starSys->getObjectId()); stringstream out; out << starSysData->getRegion(); Logger::getLogger()->debug(string("System " + newStarSys->getName() + " added to region " + out.str()).c_str()); } else if(regions.size() == 1) { // Add +1 to the resource score of the player with the correct leader // in this region int leaderID = getLeaderInRegion(*(regions.begin()), leaderName); if(leaderID < 0 && leaderName.compare("SettlerLeaderShip") != 0) { leaderID = getLeaderInRegion(*(regions.begin()), "SettlerLeaderShip"); } if(leaderID >= 0) { Fleet* leader = (Fleet*) ((obm->getObject((uint32_t) leaderID))->getObjectBehaviour()); Player::Ptr owner = Game::getGame()->getPlayerManager()->getPlayer(leader->getOwner()); owner->setScore(scoreType, owner->getScore(scoreType) + 1); } //Add the newly colonized system to the region starSysData->setRegion(*(regions.begin())); stringstream out; out << starSysData->getRegion(); Logger::getLogger()->debug(string("System " + newStarSys->getName() + " added to region " + out.str()).c_str()); } else { // This means that 2 regions are being connected. Perform check // for external combat map<uint32_t, uint32_t> settlers; map<uint32_t, uint32_t> scientists; map<uint32_t, uint32_t> merchants; map<uint32_t, uint32_t> miners; for(set<uint32_t>::iterator i = regions.begin(); i != regions.end(); i++) { int temp = getLeaderInRegion(*i, "SettlerLeaderShip"); if(temp != -1) { settlers[temp] = *i; } temp = getLeaderInRegion(*i, "ScientistLeaderShip"); if(temp != -1) { scientists[temp] = *i; } temp = getLeaderInRegion(*i, "MerchantLeaderShip"); if(temp != -1) { merchants[temp] = *i; } temp = getLeaderInRegion(*i, "MiningLeaderShip"); if(temp != -1) { miners[temp] = *i; } } TaeTurn* turn = (TaeTurn*) Game::getGame()->getTurnProcess(); bool conflict = false; if(settlers.size() > 1) { //Settler Conflict! turn->queueCombatTurn(false, settlers); conflict = true; } if(scientists.size() > 1) { //Scientist Conflict! turn->queueCombatTurn(false, scientists); conflict = true; } if(merchants.size() > 1) { //Merchant Conflict! turn->queueCombatTurn(false, merchants); conflict = true; } if(miners.size() > 1) { //Miner Conflict! turn->queueCombatTurn(false, miners); conflict = true; } if(!conflict) { uint32_t region = *(regions.begin()); set<uint32_t> objects = obm->getAllIds(); for(set<uint32_t>::iterator i = objects.begin(); i != objects.end(); i++) { IGObject::Ptr ob = obm->getObject(*i); if(ob->getType() == obtm->getObjectTypeByName("Star System")) { StarSystem* sys = (StarSystem*) ob->getObjectBehaviour(); uint32_t r = sys->getRegion(); if(r != region && regions.count(r) > 0) { sys->setRegion(region); } } } } } obm->doneWithObject(newStarSys->getID()); // post completion message Message::Ptr msg( new Message() ); msg->setSubject("Colonize fleet order complete"); msg->setBody(string("You're fleet, \"" + obj->getName() + "\" has colonized ") + newStarSys->getName() + "."); msg->addReference(rst_Action_Order, rsorav_Completion); msg->addReference(rst_Object, starSys->getObjectId()); msg->addReference(rst_Object, obj->getID()); player->postToBoard(msg); //Remove fleet obj->removeFromParent(); obm->scheduleRemoveObject(obj->getID()); return true; }
void GameController::onChangeTurn() { currentTurn++; /* impose production on owned planets */ for(int i=0; i<players.size(); i++) { Player* tempP = players[i]; for(int j=0; j<players[i]->getPlanets().size(); j++) { Planet* tempPl = tempP->getPlanets()[j]; tempPl->setShips( tempPl->getShips() + tempPl->getProduction()); } } for(int k=0; k<fleets.size(); k++) { Fleet* tempF = fleets[k]; /* fleet has arrived */ if(fleets[k]->getArrivalTurn() == currentTurn) { /* fleet owner same as destination owner, so reinforcing a planet */ if(tempF->getOwner() == tempF->getDestination()->getOwner()) { tempF->getDestination()->setShips(tempF->getDestination()->getShips() + tempF->getNumShips()); } else /* attacking planet */ { double attackScore, defenseScore; attackScore = tempF->getNumShips()*tempF->getKillPercent(); defenseScore = tempF->getDestination()->getShips()*tempF->getDestination()->getKillPercent(); if(attackScore >= defenseScore) /* attackers win */ { if(tempF->getDestination()->getOwner() != NULL) tempF->getDestination()->getOwner()->removeFromPlanets(tempF->getDestination()); tempF->getOwner()->addToPlanets(tempF->getDestination()); tempF->getDestination()->setOwner(tempF->getOwner()); tempF->getDestination()->setShips((int)attackScore-defenseScore); emit displayInfo(QString("Turn %1: Planet %2 has fallen to %3").arg(currentTurn).arg(tempF->getDestination()->getName()).arg(tempF->getOwner()->getName())); } else /* defense wins */ { tempF->getDestination()->setShips((int)defenseScore-attackScore); emit displayInfo(QString("Turn %1: Planet %2 has held against an attack from %3.").arg(currentTurn).arg(tempF->getDestination()->getName()).arg(tempF->getOwner()->getName())); } } /* processed fleet, so remove it */ fleets.removeAt(k); } } if(currentPlayer < players.size() - 1) currentPlayer++; else currentPlayer = 0; emit displayControl(QString("<font color=%1>%2</font>:Select source planet").arg(players[currentPlayer]->getColor().name()).arg(players[currentPlayer]->getName())); }
void PlanetWarsGame::reset() { this->logMessage("Reloading the game... "); //Attempt to read the map from file. std::ifstream mapFile(m_mapFileName.c_str()); if (mapFile.fail()) { this->logError("Unable to open the map file."); return; } std::string mapString = std::string(std::istreambuf_iterator<char>(mapFile), std::istreambuf_iterator<char>()); //Attempt to parse the map. bool failed = false; std::vector<Planet*> planets; std::list<Fleet*> fleets; //Lines on which we find fleets. std::vector<size_t> fleetLines; //Process each line in the map file, reading the fleet and planet information from //respective lines. std::vector<std::string> lines = Tokenize(mapString, "\n"); for (size_t i = 0; i < lines.size(); ++i) { std::string& line = lines[i]; //Remove comments. size_t commentBegin = line.find('#'); if (commentBegin != std::string::npos) line = line.substr(0, commentBegin); if (TrimSpaces(line).size() == 0) continue; //Split the line into individual elements. std::vector<std::string> tokens = Tokenize(line, " "); if (tokens.size() == 0) continue; if (tokens[0] == "P") { //Record a planet. if (tokens.size() != 6) { std::stringstream message; message <<"Map file error [line " << i << "]: expected 6 tokens on a planet line, have " << tokens.size() <<"."; this->logError(message.str()); failed = true; break; } Planet* planet = new Planet(this); planet->setX(atof(tokens[1].c_str())); planet->setY(atof(tokens[2].c_str())); planet->setOwner(this->getPlayer(atoi(tokens[3].c_str()))); planet->setNumShips(atoi(tokens[4].c_str())); planet->setGrowthRate(atoi(tokens[5].c_str())); planet->setId(planets.size()); planet->setGame(this); planets.push_back(planet); } else if (tokens[0] == "F") { //Record a fleet. if (tokens.size() != 7) { std::stringstream message; message <<"Map file error [line " << i << "]: expected 7 tokens on a fleet line, have " << tokens.size() <<"."; this->logError(message.str()); failed = true; break; } Fleet* fleet = new Fleet(this); fleet->setOwner(this->getPlayer(atoi(tokens[1].c_str()))); fleet->setNumShips(atoi(tokens[2].c_str())); fleet->setSourceId(atoi(tokens[3].c_str())); fleet->setDestinationId(atoi(tokens[4].c_str())); fleet->setTotalTripLength(atoi(tokens[5].c_str())); fleet->setTurnsRemaining(atoi(tokens[6].c_str())); fleets.push_back(fleet); fleetLines.push_back(i); } else { std::stringstream message; message << "Map file error [line " << i << "]: a non-empty line that does not contain a planet or a fleet."; this->logError(message.str()); failed = true; break; } } const int numPlanets = static_cast<int>(planets.size()); //Resolve planet references inside fleets. int fleetIndex = 0; if (!failed) { for (FleetList::iterator it = fleets.begin(); it != fleets.end(); ++it) { Fleet* fleet = *it; //Attempt to resolve the source planet. const int sourceId = fleet->getSourceId(); if (sourceId < 0 || sourceId >= numPlanets) { std::stringstream message; message << "Map file error [line " << fleetLines[fleetIndex] << "]: fleet refers to an invalid planet with id=" << sourceId << "."; this->logError(message.str()); failed = true; break; } else { fleet->setSource(planets[sourceId]); } //Attempt to resolve the destination planet. const int destinationId = fleet->getDestinationId(); if (destinationId < 0 || destinationId >= numPlanets) { std::stringstream message; message << "Map file error [line " << fleetLines[fleetIndex] << "]: fleet refers to an invalid planet with id=" << destinationId << "."; this->logError(message.str()); failed = true; break; } else { fleet->setDestination(planets[destinationId]); } //This will force recalculation of the current position. fleet->setTurnsRemaining(fleet->getTurnsRemaining()); ++fleetIndex; } } if (failed) { //Clean up. for (int i = 0; i < numPlanets; ++i) delete planets[i]; for (FleetList::iterator it = fleets.begin(); it != fleets.end(); ++it) delete *it; return; } //Parsed the map successfully. Reset the game. //Stop any running processes. this->stop(); this->stopPlayers(); //If didn't fail, replace the old planets and fleets with the new. const int numOldPlanets = static_cast<int>(m_planets.size()); for (int i = 0; i < numOldPlanets; ++i) delete m_planets[i]; for (FleetList::iterator it = m_fleets.begin(); it != m_fleets.end(); ++it) delete (*it); m_planets = planets; m_fleets = fleets; m_newFleets.insert(m_newFleets.end(), fleets.begin(), fleets.end()); //Reset all flags and counters. m_state = RESET; m_turn = 0; //Notify everyone of the resetn this->logMessage("================= Game reset. =================="); emit wasReset(); }
int main ( int argc, char** argv ){ if ( SDL_Init( SDL_INIT_EVERYTHING ) < 0 ) { printf( "Unable to init SDL: %s\n", SDL_GetError() ); return 1; } // make sure SDL cleans up before exit atexit(SDL_Quit); // create a new window screen = SDL_SetVideoMode(900, 600, 8, SDL_HWSURFACE|SDL_DOUBLEBUF); if ( !screen ) { printf("Unable to set 640x480 video: %s\n", SDL_GetError()); return 1; } Fleet f; Bullet b3; f.asignBullet(&b3); Barrier bar1(000,98,1); /* Barrier bar2(000,200,1); Barrier bar3(000,300,1); Barrier bar4(000,400,0); Barrier bar5(000,500,0); Barrier bar6(000,599,0);*/ Ship s2; s2.position( (GAME_W /2) + 100 ,GAME_H-30); //s2.setMode(2); Bullet b2; b2.setDownOrientation(); s2.asignBullet(&b2); Ship s1; //s1.setMode(1); s1.position( (GAME_W / 2)- 100 , GAME_H-30); Bullet b1; s1.asignBullet(&b1); SideBar sb; actors.push_back(&b1); actors.push_back(&b2); // actors.push_back(&b3); // actors.push_back(&f); actors.push_back(&bar1); Bonus bonus; actors.push_back(&bonus); actors.push_back(&sb); Stairs stairs(160,98,1); actors.push_back(&stairs); actors.push_back(&s1); actors.push_back(&s2); Uint8 * keystate; bool done = false; while (!done) { //Start the frame timer fps.start(); keystate = SDL_GetKeyState(NULL); if(keystate[SDLK_LEFT]) { //if(!s1.climbing){ s1.moveLeft(); //} } if(keystate[SDLK_RIGHT]) { s1.moveRight(); } if(keystate[SDLK_UP]) { int collided = 0; if(s1.onGround){ for (int i=0; i<Stairs::SHIPS_QTY; i++) { if (check_collision(s1.rect,stairs.rect[i])) { s1.climbing = true; s1.moveUp(); collided = 1; //std::cout << "Climbing en true??" << s1.climbing << "\n"; } } if(!collided){ std::cout << "ELSEClimbing en true??" << s1.climbing << "\n"; s1.climbing= false; s1.onGround = false; /*std::cout << "stairs width " << stairs.rect[1].w << "\n"; std::cout << "stairs height " << stairs.rect[1].h << "\n";*/ } } } if(keystate[SDLK_DOWN]) { for (int i=0; i<Stairs::SHIPS_QTY; i++) { if (check_collision(s1.rect,stairs.rect[i])) { SDL_Rect * r; r = bar1.getNextBaseFloor(stairs.rect[i].y+stairs.rect[i].h); std::cout << "Recta a chequear <<<<<<< " << r->y << " \n"; if(s1.rect.y+s1.rect.h >= r->y){ std::cout << "Entra al if " << " \n"; s1.onGround = false; s1.climbing = false; } else{ s1.climbing = true; //S1.climbingDown = true; s1.moveDown(); } //std::cout << "Climbing en true??" << s1.climbing << "\n"; }else{ //std::cout << "Entra al else Climbing en true??" << s1.climbing << "\n"; //s1.climbing= false; //s1.onGround = false; } } } if(keystate[SDLK_a]) { s2.moveLeft(); } if(keystate[SDLK_d]) { s2.moveRight(); } SDL_Event event; while (SDL_PollEvent(&event)) { // check for messages switch (event.type) { // exit if the window is closed case SDL_QUIT: done = true; break; // check for keypresses case SDL_KEYDOWN: // exit if ESCAPE is pressed if (event.key.keysym.sym == SDLK_ESCAPE) { done = true; } if (event.key.keysym.sym == SDLK_w) { s2.jump(); } if (event.key.keysym.sym == SDLK_SPACE) { s1.jump(); } break; } // end switch } // clear screen SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 0, 0, 0)); for(std::vector<IActor*>::iterator it = actors.begin(); it != actors.end(); ++it) { (*it)->blit(); } if(!s1.climbing && !s1.onGround){ for (int i=0; i<Barrier::SHIPS_QTY; i++) { if (check_collision(s1.rect,bar1.rect[i])) { //s1.climbing = true; //S1.climbingDown = true; //std::cout << "Climbing en true??" << s1.climbing << "\n"; //s1.moveDown(); /* std::cout << "entra en collision con bar" << i << " \n"; std::cout << "climb" << s1.climbing << "\n"; std::cout << "onGround" << s1.onGround << "\n"; std::cout << "end col" << "\n";*/ s1.rect.y = bar1.rect[i].y-28; s1.speedY = 0.0; s1.onGround = true; } } } if(s1.climbing){ int collided = 0; for (int i=0; i<Stairs::SHIPS_QTY; i++) { if (check_collision(s1.rect,stairs.rect[i])) { //s1.climbing = true; //s1.moveUp(); collided = 1; //std::cout << "Climbing en true??" << s1.climbing << "\n"; } } if(!collided){ //std::cout << "ELSEClimbing en true??" << s1.climbing << "\n"; s1.climbing= false; s1.onGround = false; //std::cout << "stairs width " << stairs.rect[1].w << "\n"; //std::cout << "stairs height " << stairs.rect[1].h << "\n"; } } for (int i=0; i<Stairs::SHIPS_QTY; i++) { if (check_collision(bonus.rect,stairs.rect[i])) { SDL_Rect * r; r = bar1.getNextBaseFloor(stairs.rect[i].y+stairs.rect[i].h); //std::cout << "Recta a chequear <<<<<<< " << r->y << " \n"; if(bonus.rect.y+bonus.rect.h > r->y){ //std::cout << "Entra al if " << " \n"; //s1.onGround = false; bonus.climbing = false; } else{ bonus.climbing = true; //S1.climbingDown = true; //s1.moveDown(); } //std::cout << "Climbing en true??" << s1.climbing << "\n"; }else{ //std::cout << "Entra al else Climbing en true??" << s1.climbing << "\n"; //s1.climbing= false; //s1.onGround = false; } } SDL_Flip(screen); //Cap the frame rate if (fps.get_ticks() < 1000 / FRAMES_PER_SECOND) { SDL_Delay( (1000 / FRAMES_PER_SECOND) - fps.get_ticks() ); } }//end game loop for(std::vector<IActor*>::iterator it = actors.begin(); it != actors.end(); ++it) { (*it)->free(); } printf("Exited cleanly\n"); return 0; }
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; }
bool PlanetWarsGame::processOrders(const std::string &allOrders, Player *player) { std::vector<std::string> lines = Tokenize(allOrders, "\r\n"); const int numLines = static_cast<int>(lines.size()); //Indicator whether "go" message was encountered. bool foundGo = false; for (int i = 0; i < numLines; ++i) { std::string& line = lines[i]; if (line.size() == 0) { //Skip empty lines. continue; } else if (line.compare("go") == 0) { foundGo = true; break; } else if (line[0] == '#') { if (line.size() < 2 || line[1] != '-') continue; std::vector<std::string> tokens = Tokenize(line, " "); tokens.erase(tokens.begin()); if (tokens.size() == 4 && tokens[0] == "planet") { int planetId = atoi(tokens[1].c_str()); const std::string& name = tokens[2]; const std::string& value = tokens[3]; Planet* planet = m_planets[planetId]; planet->setProperty(name, value); } continue; } std::vector<std::string> tokens = Tokenize(line, " "); //Check whether the player bot output a bad thing. if (3 != tokens.size()) { std::stringstream message; message << "Error on line " << i << " of stdout output; expected 3 tokens on a move order line, have " << tokens.size() << "."; player->logError(message.str()); return false; } const int sourcePlanetId = atoi(tokens[0].c_str()); const int destinationPlanetId = atoi(tokens[1].c_str()); const int numShips = atoi(tokens[2].c_str()); //Check whether the player has made any illegal moves. const int numPlanets = static_cast<int>(m_planets.size()); if (sourcePlanetId < 0 || sourcePlanetId >= numPlanets) { std::stringstream message; message << "Error on line " << i << " of stdout output. Source planet " << sourcePlanetId << " does not exist."; player->logError(message.str()); return false; } if (destinationPlanetId < 0 || destinationPlanetId >= numPlanets) { std::stringstream message; message << "Error on line " << i << " of stdout output. Destination planet " << destinationPlanetId << " does not exist."; player->logError(message.str()); return false; } if (sourcePlanetId == destinationPlanetId) { std::stringstream message; message << "Error on line " << i << " of stdout output. Source planet and destination planet are the same. "; player->logError(message.str()); return false; } Planet* sourcePlanet = m_planets[sourcePlanetId]; Planet* destinationPlanet = m_planets[destinationPlanetId]; if (sourcePlanet->getOwner()->getId() != player->getId()) { std::stringstream message; message << "Error on line " << i << " of stdout output. Source planet " << destinationPlanetId << " does not belong to this player."; player->logError(message.str()); return false; } if (numShips > sourcePlanet->getNumShips() || numShips < 0) { std::stringstream message; message << "Error on line " << i << " of stdout output. Cannot send " << numShips << " ships from planet " << sourcePlanetId << ". Planet has " << sourcePlanet->getNumShips() << " ships."; player->logError(message.str()); return false; } sourcePlanet->setNumShips(sourcePlanet->getNumShips() - numShips); //Create a new fleet. Fleet* fleet = new Fleet(this); fleet->setOwner(player); fleet->setSource(sourcePlanet); fleet->setDestination(destinationPlanet); fleet->setNumShips(numShips); const int distance = sourcePlanet->getDistanceTo(destinationPlanet); fleet->setTotalTripLength(distance); fleet->setTurnsRemaining(distance); m_newFleets.push_back(fleet); m_fleets.push_back(fleet); } if (!foundGo) { std::stringstream message; message << "Error: player did not send \"go\" within allotted time."; player->logError(message.str()); return false; } return true; }
void PlanetWarsGame::completeStep() { //Proceed only if there's an unfinished step. if (STEPPING != m_state) { return; } m_state = PROCESSING; //Clear the old new fleets. m_newFleets.clear(); //Read and process the the responses from each of the players. std::string firstPlayerOutput(m_firstPlayer->readCommands()); std::string secondPlayerOutput(m_secondPlayer->readCommands()); bool isFirstPlayerRunning = this->processOrders(firstPlayerOutput, m_firstPlayer); bool isSecondPlayerRunning = this->processOrders(secondPlayerOutput, m_secondPlayer); //Check whether the players are still alive. if (!isFirstPlayerRunning || !isSecondPlayerRunning) { this->stop(); return; } this->advanceGame(); //Check each player's position. int firstPlayerShips = 0; int secondPlayerShips = 0; const int numPlanets = static_cast<int>(m_planets.size()); for (int i = 0; i < numPlanets; ++i) { Planet* planet = m_planets[i]; const int ownerId = planet->getOwner()->getId(); if (1 == ownerId) { firstPlayerShips += planet->getNumShips(); } else if (2 == ownerId) { secondPlayerShips += planet->getNumShips(); } } for (FleetList::iterator it = m_fleets.begin(); it != m_fleets.end(); ++it) { Fleet* fleet = *it; if (1 == fleet->getOwner()->getId()) { firstPlayerShips += fleet->getNumShips(); } else { secondPlayerShips += fleet->getNumShips(); } } emit turnEnded(); //Check for game end conditions. bool isGameOver = false; if (firstPlayerShips == 0 && secondPlayerShips == 0) { this->logMessage("Draw."); isGameOver = true; } else if (firstPlayerShips == 0) { this->logMessage("Player 2 wins."); isGameOver = true; } else if (secondPlayerShips == 0) { this->logMessage("Player 1 wins."); isGameOver = true; } else if (m_turn >= m_maxTurns) { if (firstPlayerShips > secondPlayerShips) { this->logMessage("Player 1 wins."); isGameOver = true; } else if (firstPlayerShips < secondPlayerShips) { this->logMessage("Player 2 wins."); isGameOver = true; } else { this->logMessage("Draw."); isGameOver = true; } } if (isGameOver) { this->stop(); return; } //Game is not over. m_state = READY; this->continueRunning(); }
void CargoHolder::ProcessLoad(CargoHolder * dest, CargoType ct, TransferType tt, long value, bool dunnage) // value usage depends on TransferType { assert(dest->IsWith(*this)); assert(dest != this); if (value < 0) { Message * mess = NCGetOwner()->AddMessage("Error: Transfer order is negative", this); mess->AddLong("Amount transferred", value); return; } if (value > Rules::GetConstant("MaxTransfer")) { Message * mess = NCGetOwner()->AddMessage("Error: Transfer order is over max", this); mess->AddLong("Amount transferred", value); return; } long destAmt = dest->GetContain(ct); if (GetOwner() != dest->GetOwner() && (ct == POPULATION || !dest->CanLoadBy(GetOwner()))) destAmt = 0; long amount = 0; // actual amount moved; switch (tt) { case TRANSFER_DROPNLOAD: case TRANSFER_LOADALL: if (dunnage) break; amount = TransferAmount(ct, dest, this, destAmt); break; case TRANSFER_UNLOADALL: break; case TRANSFER_LOADAMT: if (dunnage) break; amount = TransferAmount(ct, dest, this, value); break; case TRANSFER_UNLOADAMT: break; case TRANSFER_FILLPER: case TRANSFER_WAITPER: // affects movement too if (dunnage) break; if (value > 100) { Message * mess = NCGetOwner()->AddMessage("Error: Transfer percent over 100%", this); mess->AddLong("Amount transferred", value); return; } amount = TransferAmount(ct, dest, this, GetCargoCapacity() * value / 100); break; case TRANSFER_LOADDUNN: if (!dunnage) break; // order of loading is different, but this is basicly a loadall -- execpt fuel if (ct == FUEL) { Fleet * f = dynamic_cast<Fleet *>(this); int Need = f->GetFuelNeeded() - f->GetFuel(); if (Need > 0) amount = TransferAmount(ct, dest, this, Need); else amount = -TransferAmount(ct, this, dest, -Need); } else { amount = TransferAmount(ct, dest, this, destAmt); } break; case TRANSFER_SETTOPER: if (value > 100) { Message * mess = NCGetOwner()->AddMessage("Error: Transfer percent over 100%", this); mess->AddLong("Amount transferred", value); return; } value = GetCargoCapacity() * value / 100; // drop to a regualr transfer amount case TRANSFER_AMOUNTTO: if (dunnage) break; if (GetContain(ct) < value) amount = TransferAmount(ct, dest, this, value - GetContain(ct)); break; case TRANSFER_DESTTO: if (dunnage) break; if (destAmt > value) amount = TransferAmount(ct, dest, this, destAmt - value); break; default: Message * mess = NCGetOwner()->AddMessage("Error: Invalid transfer order", this); mess->AddLong("Transfer code", tt); return; } assert(amount >= 0 || tt == TRANSFER_LOADDUNN && ct == FUEL); if (amount > 0 && dest->GetOwner() != GetOwner()) { if (!dest->CanLoadBy(GetOwner())) { Message * mess = NCGetOwner()->AddMessage("Warning: No theiving component at location", this); mess->AddItem("", dest); return; } else if (!Rules::Stealable(ct)) { Message * mess = NCGetOwner()->AddMessage("Warning: Cargo cannot be stolen", this); mess->AddItem("", dest); mess->AddLong("Cargo type", ct); return; } } dest->AdjustAmounts(ct, -amount); // remove cargo from destination AdjustAmounts(ct, amount); // add it to the source }
void CargoHolder::TransferCargo(CargoHolder * dest, CargoType ct, long * amount, Player * player) { if (*amount == 0) return; assert(*amount > 0); if (GetContain(ct) < *amount) { Message * mess = player->AddMessage("Warning: Transfer more then carried", this); mess->AddLong("Attempted amount", *amount); *amount = GetContain(ct); mess->AddLong("Actual amount", *amount); } if (ct == POPULATION) { *amount -= *amount % Rules::PopEQ1kT; // only transfer full groups if (dest->GetCargoCapacity() >= 0 && dest->GetCargoCapacity() < dest->GetCargoMass() + (*amount / Rules::PopEQ1kT)) { Message * mess = player->AddMessage("Warning: Transfer more then capacity", this); mess->AddItem("", dest); mess->AddLong("Attempted amount", *amount); *amount = (dest->GetCargoCapacity() - dest->GetCargoMass()) * Rules::PopEQ1kT; mess->AddLong("Actual amount", *amount); } } else if (ct == FUEL) { Fleet * destf = dynamic_cast<Fleet *>(dest); if (destf->GetFuelCapacity() >= 0 && destf->GetFuelCapacity() < destf->GetFuel() + *amount) { Message * mess = player->AddMessage("Warning: Transfer more then capacity", this); mess->AddItem("", dest); mess->AddLong("Attempted amount", *amount); *amount = destf->GetFuelCapacity() - destf->GetFuel(); mess->AddLong("Actual amount", *amount); } } else { if (dest->GetCargoCapacity() >= 0 && dest->GetCargoCapacity() < dest->GetCargoMass() + *amount) { Message * mess = player->AddMessage("Warning: Transfer more then capacity", this); mess->AddItem("", dest); mess->AddLong("Attempted amount", *amount); *amount = dest->GetCargoCapacity() - dest->GetCargoMass(); mess->AddLong("Actual amount", *amount); } } if (ct == POPULATION && GetOwner() != dest->GetOwner()) { assert(false); // should never get here now Planet * destp = dynamic_cast<Planet *>(dest); if (destp) { if (destp->GetBaseNumber() >= 0) { player->AddMessage("Warning: Invading world with base", this); return; } else { AdjustAmounts(ct, -*amount); destp->Invade(NCGetOwner(), *amount); return; } } else { Message * mess = player->AddMessage("Warning: Transfer pop to unowned fleet", this); mess->AddItem("", dest); return; } } dest->AdjustAmounts(ct, *amount); AdjustAmounts(ct, -*amount); }