C++ Country类代码示例

//Add a new country to the list of adjacent countries
void Country::addConnection(Country &conn)
{
	connections.push_back(conn.getName());
	if (!conn.isAdjacent(name)) {
		conn.addConnection(*this);
	}
}

/**
 * @brief Reinforcement phase decision making. Places all reinforcements on the
 * country with the fewest armies.
 */
std::string Strategy::reinforcePhase() {
	RiskMap* map = this->driver->getRiskMap();
	std::string playerName = this->driver->getCurrentPlayerName();

	int minArmies = 10000;
	Country* minArmiesCountry = nullptr;

	// add the reinforcements to the player
	int numCardsSelected = map->getPlayer(playerName)->getCards();
	int armiesEarned = convertCardsToReinforcements(numCardsSelected);
	if (armiesEarned > 0) {
		this->driver->addCardsTradeReinforcements(armiesEarned);
		this->driver->updatePlayerCards(-numCardsSelected);
	}

	// Reinforce the weakest country
	for (const std::string countryName : map->getCountriesOwnedByPlayer(playerName)) {
		Country* country = map->getCountry(countryName);
		int armies = country->getArmies();
		if (armies < minArmies) {
			minArmies = armies;
			minArmiesCountry = country;
		}
	}
	if (minArmiesCountry == nullptr) {
		return "";
	}
	return minArmiesCountry->getName();
}

void HwFederateAmbassador::reflectAttributeValues (
        RTI::ObjectHandle                 theObject,     // supplied C1
  const RTI::AttributeHandleValuePairSet& theAttributes, // supplied C4
  const RTI::FedTime&                     theTime,       // supplied C1
  const char                             *theTag,        // supplied C4
        RTI::EventRetractionHandle        theHandle)     // supplied C1
throw (
  RTI::ObjectNotKnown,
  RTI::AttributeNotKnown,
  RTI::FederateOwnsAttributes,
  RTI::InvalidFederationTime,
  RTI::FederateInternalError)
{
   //-----------------------------------------------------------------
   // Find the Country instance this update is for.  If we can't find
   // it then I am getting data I didn't ask for.
   //-----------------------------------------------------------------
   Country *pCountry = Country::Find( theObject );

   if ( pCountry )
   {
      //-----------------------------------------------------------------
      // Set the new attribute values in this country instance.
      //-----------------------------------------------------------------
      pCountry->Update( theAttributes );
      pCountry->SetLastTime( theTime );
   }
   else
           throw RTI::ObjectNotKnown("received reflection for unknown OID");
}

/**
 * @brief Determines if the countries on the map are a connected graph.
 * @param limitTo Limits the search to the given continent (by string name)
 */
bool RiskMap::isConnectedGraph(const std::string& limitTo) {
	std::map<const Country*, bool> visited = std::map<const Country*, bool>();
	for (auto const &ent1 : this->countries) {
		const Country& country = ent1.second;

		if (limitTo.size() > 0 && this->getContinentOfCountry(country.getName())->getName().compare(limitTo) != 0) {
			continue;
		}

		visited.insert(std::pair<const Country*, bool>(&country, false));
	}

	Country* country = nullptr;
	if (limitTo.size() > 0) {
		country = this->getCountry(*this->getCountriesInContinent(limitTo).begin());
	}
	else {
		country = &this->countries.begin()->second;
	}
	this->isConnectedGraphHelper(visited, country, limitTo);

	for (auto const &ent1 : visited) {
		if (!ent1.second) {
			Country country = *ent1.first;
			debug("Country " + country.getName() + " is not connected.");
			return false;
		}
	}

	return true;
}

int main() {
    string name;
    string capitalcity;
    int population;
    int area;
    Country qveyana;
    vector <Country> v;
    while(ans1 == 'y') {
    cout << "Enter new information" << endl;
    cin >> name;
    cin >> capitalcity;
    cin >> population;
    cin >> area;
    qveyana.setInfo(name,capitalcity,population,area);
    v.push_back(qveyana);
    cout << "Continue? (y/n)" << endl;
    cin >> ans1;
}
        cout << "Enter country name to get information:" << endl;
        cin >> countryname;
        for(int i=0;i<v.size();i++){
                if (v[i].getName()==countryname)
                    cout<<v[i].splittedArea()<<endl;
            }
    return 0;
}

bool World::addCountry(const char* _name, const char* _continent)
{
	lastOperationSuccess = true;
	//We cannot allow 2 times the same name.
	if (getCountryFromName(_name) != NULL)
	{
		lastOperationSuccess = false;
		lastErrorMessage = "The country already exists.";
		return false;
	}

	Continent* continent = getContinentFromName(_continent);

	if (continent == NULL)
	{
		lastOperationSuccess = false;
		lastErrorMessage = "The continent does not exists.";
		return false;
	}

	//Create the object.
	Country* countryObject = new Country(_name, (int)countriesVector->size());
	countryObject->setContinent(continent);

	//Once we have the infos of one, we add it to our vector.
	countriesVector->push_back(countryObject);
	return true;
}

void MainScreen::allocateArmiesByNumberOfPlayers(const std::string playerName){
	RiskMap* map = this->driver->getRiskMap();
	const int armiesByNumPlayers[] = {40, 35, 30, 25, 20};
	int totalArmies = armiesByNumPlayers[map->getPlayers().size()-2];

	// Create a vector of country pointers for countries the player owns
	std::vector<Country*> playerCountries;
	for (auto const &countryName : map->getCountriesOwnedByPlayer(playerName)) {
		playerCountries.push_back(map->getCountry(countryName));
	}

	// Randomize order of country pointer list
	auto engine = std::default_random_engine{};
	std::shuffle(std::begin(playerCountries), std::end(playerCountries), engine);

	auto playerCountriesIter = playerCountries.begin();
	while (totalArmies > 0) {
		Country* country = *playerCountriesIter;
		country->addArmies(1);
		totalArmies--;
		std::advance(playerCountriesIter, 1);
		if (playerCountriesIter == playerCountries.end()) {
			playerCountriesIter = playerCountries.begin();
		}
	}

	// Signal to update the info widgets.
	for (auto &ent1: map->getPlayers()){
		map->getPlayer(ent1.first)->notifyObservers();
	}
}

bool Countries::FindPlace(const char *country_val, const char *place_val,
						  DPoint2 &point)
{
	Country *country;

	int num = m_countries.GetSize();

	int i;
	for (i = 0; i < num; i++)
	{
		country = m_countries[i];

		if (country->m_full.CompareNoCase(country_val) != 0)
			continue;

		bool success = country->FindPlace(place_val, point, true);

		// try again with just the length of the initial sea
		if (!success)
			success = country->FindPlace(place_val, point, false);

		if (success)
			return true;
	}
	return false;
}

/**
 * @brief Removes a country from the map.
 */
void RiskMap::removeCountry(const Country& country){
	std::string continent = (this->getContinentOfCountry(country.getName()))->getName();
	countries.erase(country.getName());
	if (mapGraph.removeNode(country.getName())){
		continents.erase(continent);
	}
	this->notifyObservers();
}

bool World::pathFindCountry(Country* country1, Country* country2, Player* player)
{
	cout << "DEbug country 1+++++++++++++++++++++++" << country1->getName() << endl;
	cout << "DEbug country 2+++++++++++++++++++++++" << country2->getName() << endl;

	if (country1->getName() == country2->getName() || isCountryAdjacent(country1, country2))
	{
		return true;
	}
	queue<Country*> countryQueue;
	vector<Country*> boardersToCountry1 = country1->getBoarders();
	countryQueue.push(country1);
	while (countryQueue.empty() == false)
	{
		Country* c = countryQueue.front();
		countryQueue.pop();
		if (c->getName() == country2->getName())
		{
			//need to put marked back to false for every country
			//here but map iterator is my enemy
			for (std::map<string, Country*>::iterator it = _territories.begin(); it != _territories.end(); ++it)
			{
				it->second->marked = false;
			}
				
			return true;
		}
		for (int i = 0; i < c->getBoarders().size(); i++)
		{
			vector<Country*> allBoardersToC = c->getBoarders();
			for (int k = 0; k < allBoardersToC.size(); k++)
			{
				for (int j = 0; j < player->getListCountriesOwned().size(); j++)
				{

					if (allBoardersToC.at(k)->getName() == player->getListCountriesOwned().at(j)->getName() && allBoardersToC.at(k)->marked == false)
					{
						countryQueue.push(allBoardersToC.at(k));
					}
				}
			}
		}
	}
	/*for (int i = 0; i < boardersToCountry1.size(); i++)
	{
	for (int j = 0; j < player->getListCountriesOwned().size(); j++)
	{

	if (boardersToCountry1.at(i)->getName() == player->getListCountriesOwned().at(j)->getName())
	{
	return pathFindCountry(boardersToCountry1.at(i), country2, player);
	}
	}
	}*/
}

QStringList Country::getCountryNames() {
    if (sCountryNames.isEmpty()) {
        Country cc;
        QMetaProperty mp(cc.metaProperty("val"));
        QMetaEnum qmen = mp.enumerator();
        for (int i=0; i<qmen.keyCount(); ++i) {
            sCountryNames += qmen.valueToKey(i);
        }
    }
    return sCountryNames;
}

void Evaluation::computeConnectedComponents()
{
    // Do not use 42 here as it might change from outside this file
    // Rather obtain the number of countries from Global Settings
    int nb_countries = gs->get_global_settings()->get_countries().size();
    //bool markedCountries[42]; Must be allocated dinamically
    bool* markedCountries = (bool*) malloc (nb_countries * sizeof(bool));

    for(int i=0; i<nb_countries; i++)
    {
        markedCountries[i]=0;
    }

    stack<Country*> pile;
    list<Country*> countries = gs->countries_owned_by(gs->get_current_player());
    for (list<Country*>::iterator it = countries.begin(); it!=countries.end(); ++it)
    {
        markedCountries[(*it)->get_id()]=1;
        pile.push(*it);
    }



    while(!pile.empty()){
        Country* elem = pile.top();
        pile.pop(); // void
        if (markedCountries[elem->get_id()]==0){continue;}
        else{
            stack<Country*> parcours;
            Connected_component* connected_comp = new Connected_component(world_map, gs, probabilities);
            parcours.push(elem);
            while(!parcours.empty()){
                Country* father = parcours.top();
                parcours.pop(); // void
                if(markedCountries[father->get_id()]==0){continue;}
                else{
                    markedCountries[father->get_id()]=0;
                    connected_comp->add(father);

                    set<Country*> sons = (world_map->find(father))->second;

                    for(set<Country*>::iterator son = sons.begin(); son!=sons.end(); ++son)
                    {
                        if(gs->owner(*son) == gs->get_current_player()){
                            parcours.push(*son);
                        }
                    }
                }
            }
            connected_components.push_back(connected_comp);
        }
    }
}

	void undoAction(AbstractAction::EnvType env)
	{
		int index = env->getCountryIndex();

		Country* country = (*env->getCountries())[index];



		country->setColor(Country::GREY);

		env->setCountryIndex(env->getCountryIndex() - 1);
	}

void MapManager::populateCountryVector() {

	vector<string> adjacents;
	Country newCountry;
	for (int i = 0; i < getMapTerritories().size(); i++) {
		newCountry = Country(getMapTerritories().at(i)[0], getMapTerritories().at(i)[3]);
		adjacents = getAdjacents(i);
		newCountry.setConnections(adjacents);
		countries.push_back(newCountry);
	}


}

	/**
	 * Add data from database into list view.
	 */
	void CountriesListScreen::addDataToListView()
	{
		// Clear data from map.
		mCountryMap.clear();

		// Create first section.
		NativeUI::ListViewSection* section = NULL;
		MAUtil::String sectionTitle("A");

		// For each country read create and add an ListViewItem widget.
		int countCountries = mDatabase.countCountries();
		for (int index = 0; index < countCountries; index++)
		{
			// If index is invalid skip this country.
			Country* country = mDatabase.getCountryByIndex(index);
			if (!country)
			{
				continue;
			}

			// If country's name is an empty string skip this country.
			MAUtil::String countryName = country->getName();
			if (countryName.length() == 0)
			{
				continue;
			}

			// Check if current country can go into current section.
			if (!section || countryName[0] != sectionTitle[0])
			{
				// Create new section.
				sectionTitle[0] = countryName[0];
				section = new NativeUI::ListViewSection(
					NativeUI::LIST_VIEW_SECTION_TYPE_ALPHABETICAL);
				section->setTitle(sectionTitle);
				section->setHeaderText(sectionTitle);
				mListView->addChild(section);
			}

			// Create and add list item for this country.
			NativeUI::ListViewItem* item = new NativeUI::ListViewItem();
			item->setText(countryName);
			item->setFontColor(COLOR_WHITE);
			item->setSelectionStyle(NativeUI::LIST_VIEW_ITEM_SELECTION_STYLE_GRAY);
			item->setIcon(country->getFlagID());
			section->addItem(item);

			mCountryMap.insert(item->getWidgetHandle(), country->getID());
		}
	}