C++ Country::getName方法代码示例

/**
 * @brief Attack phase decision making
 */
std::pair<std::string, std::string> Defensive::attackPhase() {
	RiskMap* map = this->driver->getRiskMap();
	std::string playerName = this->driver->getCurrentPlayerName();
	std::set<std::string> countriesOwnedByPlayer = map->getCountriesOwnedByPlayer(playerName);

	std::pair<std::string, std::string> maxDifferencePair;
	int maxDifference = 0;

	for (const std::string &countryName : countriesOwnedByPlayer) {
		Country* country = map->getCountry(countryName);

		// Check if we have more armies than all of the neighbours opponents own
		bool moreArmiesThanNeighbours = true;
		for (const std::string &neighnourName : map->getNeighbours(country->getName())) {
			Country* neighbour = map->getCountry(neighnourName);
			if (neighbour->getPlayer() != playerName && neighbour->getArmies() > country->getArmies()) {
				moreArmiesThanNeighbours = false;
				break;
			}
		}

		// If we do, find the pair of countries with the greatest chance for success
		for (const std::string &neighnourName : map->getNeighbours(country->getName())) {
			Country* neighbour = map->getCountry(neighnourName);
			if (neighbour->getPlayer() != playerName) {
				int difference = neighbour->getArmies() - country->getArmies();
				if (difference >= maxDifference) {
					maxDifference = difference;
					maxDifferencePair = std::pair<std::string, std::string>(country->getName(), neighbour->getName());
				}
			}
		}
	}
	return maxDifferencePair;
}

/**
 * @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();
}

//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();
}

/**
 * @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;
}

//Methods used to overwrite an existing object in the country or continent vectors.
void Map::editCountry(Country& coun) {
	for (Country& c : countries) {
		if (c.getName() == coun.getName())
			c = coun;
	}
	Notify();
}

/*
 * calculates the total reinforcements the player receives and stores that number 
 */
void Reinforcement::calculateReinforcement(){
    cout<< "Calculating Reinforcements for player \"" << currentplayer->getPlayerName() << "\"..." << endl;
    int countryreinforcements=0, continentreinforcements=0;
    for (int indexofcountries=0;indexofcountries<listofcountries.size();indexofcountries++)//checks ever
    {
    	Country countryC = listofcountries[indexofcountries];
        if (countryC.getOwner()->getPlayerName()==currentplayer->getPlayerName())
        {
            countryreinforcements++;
        }
    }
    
     for (int indexofcontinents=0;indexofcontinents<listofcontinents.size();indexofcontinents++)//for all continent
     {
         int check=0;
         for (int indexofcountriesincontinent=0;indexofcountriesincontinent<listofcontinents[indexofcontinents].getNumCountries();indexofcountriesincontinent++)//looks at each continent's countries
         {
          	Continent continentC = listofcontinents[indexofcontinents];
          	Country countriesInContient = continentC.getCountries()[indexofcountriesincontinent];
             string countryincontinent = countriesInContient.getName();
             for (int indexofcountries=0;indexofcountries<listofcountries.size();indexofcountries++)
             {
               	Country countryC = listofcountries[indexofcountries];
                 if (countryC.getName()==countryincontinent && countryC.getOwner()->getPlayerName()==currentplayer->getPlayerName())//checks to see if the player owns the country
                 {
                     check++;
                 }
             }
         }
         if (check==listofcontinents[indexofcontinents].getNumCountries())//if the player owns all the countries of the continent, he receives the army bonus
         {
             continentreinforcements+=listofcontinents[indexofcontinents].getArmyBonus();
         }
     }
    int actualcountryrein=max(3,countryreinforcements/3);//player receives reinforcements equal to his countries count/3 rounded down OR 3, whichever is higher
    
    
    cout << currentplayer->getPlayerName() << " has received " << actualcountryrein << " reinforcements from their countries." <<endl;
    
    cout << currentplayer->getPlayerName() << " has received " << continentreinforcements << " reinforcements from their continents." <<endl;
    
    int totalreinforcements= (actualcountryrein +continentreinforcements);
    this->reinforcements=totalreinforcements;
    currentplayer->setCurrentReinforcements(totalreinforcements);
}

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);
	}
	}
	}*/
}

	/**
	 * 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());
		}
	}

void drawCountry(Renderer* canvas, const Country &country, bool drawDescription) {
    /** Title area **/
    Font fontCountryName("resources/fonts/FreeSansBold.ttf", 30);
    fontCountryName.setColor(Color(0xf0, 0xff, 0xff));

    Text name(country.getName(), &fontCountryName);
    canvas->drawText(&name, Point(358, 105));
    
    /* Photo area */
    string photoPath = "data/countries/" + country.getIsoCode() + "/postal.png";
    FileUtils fileUtils;
    if (!fileUtils.fileExists(photoPath.c_str())) {
        photoPath = "data/countries/default-photo.jpg";
    }
    Surface photoSurface(photoPath);
    photoSurface.transform(4, 1, 1);
    Texture photoTexture(canvas->internal, photoSurface.toSDL());
    canvas->drawTexture(&photoTexture, Point(47, 115));

    Texture polaroidSurf(canvas->internal, "resources/images/game/polaroid.png");
    canvas->drawTexture(&polaroidSurf, Point(30, 108));

    string flagPath = "data/countries/" + country.getIsoCode() + "/flag.png";
    Surface flagSurface(flagPath);
    flagSurface.transform(0, .5, 1);
    Texture flagTexture(canvas->internal, flagSurface.toSDL());
    canvas->drawTexture(&flagTexture, Point(300, 110));

    if (drawDescription) {
        Font descFont("resources/fonts/FreeSansBold.ttf", 14);
        descFont.setColor(Color(0xd3, 0xba, 0xa4));

        Text description(country.getDescription(), &descFont);
        TextUtils textUtils;
        textUtils.drawLines(canvas, description, Point(358, 150), Dimension(360, 340));
    }
}

//.........这里部分代码省略.........
			while (std::getline(line_stream, item, '=')) {
				values.push_back(item);
			}
			debug_str = "  Adding continent: ";
			debug_str.append(values[0]);
			debug(debug_str);

			Continent continent(values[0]);
			continent.setReinforcementBonus(atoi(values[1].c_str()));
			this->addContinent(continent);
		}
		else if (mode == MAP_PARSE_MODE_COUNTRIES) {
			while (std::getline(line_stream, item, ',')) {
				values.push_back(item);
			}
			std::string continentName(values[3]);

			debug_str = "  Adding country: ";
			debug_str.append(values[0]);
			debug_str.append(" in continent ");
			debug_str.append(continentName);
			debug(debug_str);

			Country country(values[0]);
			country.setPositionX(atoi(values[1].c_str()));
			country.setPositionY(atoi(values[2].c_str()));
			country.setArmies(0);
			this->addCountry(country, continentName);
		}
		else {
			debug("Error parsing line: " + line);
			return;
		}
	}

	debug("Parsing file again to configure adjacencies");
	infile.clear();
	infile.seekg(0, std::ios_base::beg);
	while (std::getline(infile, line))
	{
		std::string debug_str("Read line: ");
		debug_str.append(line);
		debug(debug_str);
		// Windows prefers /r/n, but getline() breaks only on \n.
		if (line.size() > 0 && line[line.size() - 1] == '\r') {
			line.resize(line.size() - 1);
		}

		// Set the mode for how we should process lines based on section headers
		if (line.compare("[Map]") == 0) {
			mode = MAP_PARSE_MODE_MAP;
			debug("  Parsing map metadata");
			continue;
		}
		if (line.compare("[Continents]") == 0) {
			mode = MAP_PARSE_MODE_CONTINENTS;
			debug("  Parsing continents");
			continue;
		}
		if (line.compare("[Territories]") == 0) {
			mode = MAP_PARSE_MODE_COUNTRIES;
			debug("  Parsing countries");
			continue;
		}

		// Process lines per the current mode.
		std::string item;
		std::stringstream line_stream(line);
		std::vector<std::string> values;
		if (mode != MAP_PARSE_MODE_COUNTRIES || line.length() == 0) {
			debug_str = "  Skipping: ";
			debug_str.append(line);
			debug(debug_str);
			continue;
		}
		else if (mode == MAP_PARSE_MODE_COUNTRIES) {
			while (std::getline(line_stream, item, ',')) {
				values.push_back(item);
			}
			Country* country = this->getCountry(values[0]);
			std::vector<std::string>::iterator iter;
			for (iter = values.begin() + 4; iter < values.end(); iter++) {
				Country* neighbour = this->getCountry(*iter);
				this->addNeighbour(country->getName(), neighbour->getName());

				debug_str = "  ";
				debug_str.append(country->getName());
				debug_str.append(" touches ");
				debug_str.append(neighbour->getName());
				debug(debug_str);
			}
		}
		else {
			debug("Error parsing line: " + line);
			return;
		}
	}

	debug("Finished parsing: " + path);
}