vcmi/lib/rmg/CMapGenOptions.cpp

/*
 * CMapGenOptions.cpp, part of VCMI engine
 *
 * Authors: listed in file AUTHORS in main folder
 *
 * License: GNU General Public License v2.0 or later
 * Full text of license available in license.txt file, in main folder
 *
 */

#include "StdInc.h"
#include "CMapGenOptions.h"

#include "../mapping/CMapHeader.h"
#include "CRmgTemplateStorage.h"
#include "CRmgTemplate.h"
#include "CRandomGenerator.h"
#include "../VCMI_Lib.h"
#include "../CTownHandler.h"
#include "serializer/JsonSerializeFormat.h"

VCMI_LIB_NAMESPACE_BEGIN

CMapGenOptions::CMapGenOptions()
	: width(CMapHeader::MAP_SIZE_MIDDLE), height(CMapHeader::MAP_SIZE_MIDDLE), hasTwoLevels(true),
	humanOrCpuPlayerCount(RANDOM_SIZE), teamCount(RANDOM_SIZE), compOnlyPlayerCount(RANDOM_SIZE), compOnlyTeamCount(RANDOM_SIZE),
	waterContent(EWaterContent::RANDOM), monsterStrength(EMonsterStrength::RANDOM), mapTemplate(nullptr),
	customizedPlayers(false)
{
	initPlayersMap();
	setRoadEnabled(RoadId(Road::DIRT_ROAD), true);
	setRoadEnabled(RoadId(Road::GRAVEL_ROAD), true);
	setRoadEnabled(RoadId(Road::COBBLESTONE_ROAD), true);
}

si32 CMapGenOptions::getWidth() const
{
	return width;
}

void CMapGenOptions::setWidth(si32 value)
{
	assert(value >= 1);
	width = value;
}

si32 CMapGenOptions::getHeight() const
{
	return height;
}

void CMapGenOptions::setHeight(si32 value)
{
	assert(value >= 1);
	height = value;
}

bool CMapGenOptions::getHasTwoLevels() const
{
	return hasTwoLevels;
}

void CMapGenOptions::setHasTwoLevels(bool value)
{
	hasTwoLevels = value;
}

si8 CMapGenOptions::getHumanOrCpuPlayerCount() const
{
	return humanOrCpuPlayerCount;
}

void CMapGenOptions::setHumanOrCpuPlayerCount(si8 value)
{
	assert((value >= 1 && value <= PlayerColor::PLAYER_LIMIT_I) || value == RANDOM_SIZE);
	humanOrCpuPlayerCount = value;

	// Use template player limit, if any
	auto playerLimit = getPlayerLimit();
	auto possibleCompPlayersCount = playerLimit - std::max<si8>(0, humanOrCpuPlayerCount);
	if (compOnlyPlayerCount > possibleCompPlayersCount)
	{
		setCompOnlyPlayerCount(possibleCompPlayersCount);
	}

	resetPlayersMap();
}

si8 CMapGenOptions::getMinPlayersCount(bool withTemplateLimit) const
{
	auto totalPlayers = 0;
	si8 humans = getHumanOrCpuPlayerCount();
	si8 cpus = getCompOnlyPlayerCount();

	if (humans == RANDOM_SIZE && cpus == RANDOM_SIZE)
	{
		totalPlayers = 2;
	}
	else if (humans == RANDOM_SIZE)
	{
		totalPlayers = cpus + 1; // Must add at least 1 player
	}
	else if (cpus == RANDOM_SIZE)
	{
		totalPlayers = humans;
	}
	else
	{
		totalPlayers = humans + cpus;
	}

	if (withTemplateLimit && mapTemplate)
	{
		auto playersRange = mapTemplate->getPlayers();

		//New template can also impose higher limit than current settings
		vstd::amax(totalPlayers, playersRange.minValue());
	}

	// Can't play without at least 2 players
	vstd::amax(totalPlayers, 2);
	return totalPlayers;
}

si8 CMapGenOptions::getMaxPlayersCount(bool withTemplateLimit) const
{
	// Max number of players possible with current settings
	auto totalPlayers = 0;
	si8 humans = getHumanOrCpuPlayerCount();
	si8 cpus = getCompOnlyPlayerCount();
	if (humans == RANDOM_SIZE || cpus == RANDOM_SIZE)
	{
		totalPlayers = PlayerColor::PLAYER_LIMIT_I;
	}
	else
	{
		totalPlayers = humans + cpus;
	}

	if (withTemplateLimit && mapTemplate)
	{
		auto playersRange = mapTemplate->getPlayers();

		//New template can also impose higher limit than current settings
		vstd::amin(totalPlayers, playersRange.maxValue());
	}

	assert (totalPlayers <= PlayerColor::PLAYER_LIMIT_I);
	assert (totalPlayers >= 2);
	return totalPlayers;
}

si8 CMapGenOptions::getTeamCount() const
{
	return teamCount;
}

void CMapGenOptions::setTeamCount(si8 value)
{
	assert(getHumanOrCpuPlayerCount() == RANDOM_SIZE || (value >= 0 && value < getHumanOrCpuPlayerCount()) || value == RANDOM_SIZE);
	teamCount = value;
}

si8 CMapGenOptions::getCompOnlyPlayerCount() const
{
	return compOnlyPlayerCount;
}

si8 CMapGenOptions::getPlayerLimit() const
{
	//How many players could we set with current template, ignoring other settings
	si8 playerLimit = PlayerColor::PLAYER_LIMIT_I;
	if (auto temp = getMapTemplate())
	{
		playerLimit = static_cast<si8>(temp->getPlayers().maxValue());
	}
	return playerLimit;
}

void CMapGenOptions::setCompOnlyPlayerCount(si8 value)
{
	assert(value == RANDOM_SIZE || (getHumanOrCpuPlayerCount() == RANDOM_SIZE || (value >= 0 && value <= getPlayerLimit() - getHumanOrCpuPlayerCount())));
	compOnlyPlayerCount = value;

	resetPlayersMap();
}

si8 CMapGenOptions::getCompOnlyTeamCount() const
{
	return compOnlyTeamCount;
}

void CMapGenOptions::setCompOnlyTeamCount(si8 value)
{
	assert(value == RANDOM_SIZE || compOnlyPlayerCount == RANDOM_SIZE || (value >= 0 && value <= std::max(compOnlyPlayerCount - 1, 0)));
	compOnlyTeamCount = value;
}

EWaterContent::EWaterContent CMapGenOptions::getWaterContent() const
{
	return waterContent;
}

void CMapGenOptions::setWaterContent(EWaterContent::EWaterContent value)
{
	waterContent = value;
}

EMonsterStrength::EMonsterStrength CMapGenOptions::getMonsterStrength() const
{
	return monsterStrength;
}

void CMapGenOptions::setMonsterStrength(EMonsterStrength::EMonsterStrength value)
{
 	monsterStrength = value;
}

void CMapGenOptions::initPlayersMap()
{

	std::map<PlayerColor, FactionID> rememberTownTypes;
	std::map<PlayerColor, TeamID> rememberTeam;

	for(const auto & p : players)
	{
		auto town = p.second.getStartingTown();
		if (town != FactionID::RANDOM)
			rememberTownTypes[p.first] = FactionID(town);
		rememberTeam[p.first] = p.second.getTeam();
	}


	players.clear();
	int realPlayersCnt = getHumanOrCpuPlayerCount();

	// Initialize settings for all color even if not present
	for(int color = 0; color < getPlayerLimit(); ++color)
	{
		CPlayerSettings player;
		auto pc = PlayerColor(color);
		player.setColor(pc);

		auto playerType = EPlayerType::AI;
		// Color doesn't have to be continuous. Player colors can later be changed manually
		if (getHumanOrCpuPlayerCount() != RANDOM_SIZE && color < realPlayersCnt)
		{
			playerType = EPlayerType::HUMAN;
		}
		else if((getHumanOrCpuPlayerCount() != RANDOM_SIZE && color >= realPlayersCnt)
		   || (compOnlyPlayerCount != RANDOM_SIZE && color >= (PlayerColor::PLAYER_LIMIT_I - compOnlyPlayerCount)))
		{
			playerType = EPlayerType::COMP_ONLY;
		}
		player.setPlayerType(playerType);

		players[pc] = player;
	}
	savePlayersMap();
}

void CMapGenOptions::resetPlayersMap()
{
	// Called when number of player changes
	// But do not update info about already made selections

	savePlayersMap();

	int realPlayersCnt = getMaxPlayersCount();

	//Trim the number of AI players, then CPU-only players, finally human players
	auto eraseLastPlayer = [this](EPlayerType playerType) -> bool
	{
		for (auto it = players.rbegin(); it != players.rend(); ++it)
		{
			if (it->second.getPlayerType() == playerType)
			{
				players.erase(it->first);
				return true;
			}
		}
		return false; //Can't earse any player of this type
	};

	while (players.size() > realPlayersCnt)
	{
		while (eraseLastPlayer(EPlayerType::AI));
		while (eraseLastPlayer(EPlayerType::COMP_ONLY));
		while (eraseLastPlayer(EPlayerType::HUMAN));
	}

	//First colors from the list are assigned to human players, then to CPU players
	std::vector<PlayerColor> availableColors;
	for (ui8 color = 0; color < PlayerColor::PLAYER_LIMIT_I; color++)
	{
		availableColors.push_back(PlayerColor(color));
	}

	auto removeUsedColors = [this, &availableColors](EPlayerType playerType)
	{
		for (auto& player : players)
		{
			if (player.second.getPlayerType() == playerType)
			{
				vstd::erase(availableColors, player.second.getColor());
			}
		}
	};
	removeUsedColors(EPlayerType::HUMAN);
	removeUsedColors(EPlayerType::COMP_ONLY);
	//removeUsedColors(EPlayerType::AI);

	//Assign unused colors to remaining AI players
	while (players.size() < realPlayersCnt && !availableColors.empty())
	{
		auto color = availableColors.front();
		players[color].setColor(color);
		setPlayerTypeForStandardPlayer(color, EPlayerType::AI);
		availableColors.erase(availableColors.begin());

		if (vstd::contains(savedPlayerSettings, color))
		{
			setPlayerTeam(color, savedPlayerSettings.at(color).getTeam());
			// TODO: setter
			players[color].setStartingTown(savedPlayerSettings.at(color).getStartingTown());
		}
		else
		{
			logGlobal->warn("Adding settings for player %s", color);
			// Usually, all players should be initialized in initPlayersMap()
			CPlayerSettings settings;
			players[color] = settings;
		}
	}

	std::set<TeamID> occupiedTeams;
	for(auto & player : players)
	{
		auto team = player.second.getTeam();
		if (team != TeamID::NO_TEAM)
		{
			occupiedTeams.insert(team);
		}
	}
	// TODO: Handle situation when we remove a player and remaining players belong to only one team

	for(auto & player : players)
	{
		if (player.second.getTeam() == TeamID::NO_TEAM)
		{
			//Find first unused team
			for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; ++i)
			{
				TeamID team(i);
				if(!occupiedTeams.count(team))
				{
					player.second.setTeam(team);
					occupiedTeams.insert(team);
					break;
				}
			}
		}
	}
}

void CMapGenOptions::savePlayersMap()
{
	//Only save already configured players
	for (const auto& player : players)
	{
		savedPlayerSettings[player.first] = player.second;
	}
}

const std::map<PlayerColor, CMapGenOptions::CPlayerSettings> & CMapGenOptions::getSavedPlayersMap() const
{
	return savedPlayerSettings;
}

const std::map<PlayerColor, CMapGenOptions::CPlayerSettings> & CMapGenOptions::getPlayersSettings() const
{
	return players;
}

void CMapGenOptions::setStartingTownForPlayer(const PlayerColor & color, FactionID town)
{
	auto it = players.find(color);
	assert(it != players.end());
	it->second.setStartingTown(town);
}

void CMapGenOptions::setStartingHeroForPlayer(const PlayerColor & color, HeroTypeID hero)
{
	auto it = players.find(color);
	assert(it != players.end());
	it->second.setStartingHero(hero);
}

void CMapGenOptions::setPlayerTypeForStandardPlayer(const PlayerColor & color, EPlayerType playerType)
{
	// FIXME: Why actually not set it to COMP_ONLY? Ie. when swapping human to another color?
	assert(playerType != EPlayerType::COMP_ONLY);
	auto it = players.find(color);
	assert(it != players.end());
	it->second.setPlayerType(playerType);
	customizedPlayers = true;
}

const CRmgTemplate * CMapGenOptions::getMapTemplate() const
{
	return mapTemplate;
}

void CMapGenOptions::setMapTemplate(const CRmgTemplate * value)
{
	if (mapTemplate == value)
	{
		//Does not trigger during deserialization
		return;
	}

	mapTemplate = value;
	//validate & adapt options according to template
	if(mapTemplate)
	{
		if(!mapTemplate->matchesSize(int3(getWidth(), getHeight(), 1 + getHasTwoLevels())))
		{
			auto sizes = mapTemplate->getMapSizes();
			setWidth(sizes.first.x);
			setHeight(sizes.first.y);
			setHasTwoLevels(sizes.first.z - 1);
		}

		si8 maxPlayerCount = getMaxPlayersCount(false);
		si8 minPlayerCount = getMinPlayersCount(false);

		// Neither setting can fit within the template range
		if(!mapTemplate->getPlayers().isInRange(minPlayerCount) &&
			!mapTemplate->getPlayers().isInRange(maxPlayerCount))
		{
			setHumanOrCpuPlayerCount(RANDOM_SIZE);
			setCompOnlyPlayerCount(RANDOM_SIZE);
		}
		if(!mapTemplate->getWaterContentAllowed().count(getWaterContent()))
			setWaterContent(EWaterContent::RANDOM);

		resetPlayersMap(); // Update teams and player count
	}
}

void CMapGenOptions::setMapTemplate(const std::string & name)
{
	if(!name.empty())
		setMapTemplate(VLC->tplh->getTemplate(name));
}

void CMapGenOptions::setRoadEnabled(const RoadId & roadType, bool enable)
{
	if (enable)
	{
		enabledRoads.insert(roadType);
	}
	else
	{
		enabledRoads.erase(roadType);
	}	
}

bool CMapGenOptions::isRoadEnabled(const RoadId & roadType) const
{
	return enabledRoads.count(roadType);
}

bool CMapGenOptions::isRoadEnabled() const
{
	return !enabledRoads.empty();
}

void CMapGenOptions::setPlayerTeam(const PlayerColor & color, const TeamID & team)
{
	auto it = players.find(color);
	assert(it != players.end());
	it->second.setTeam(team);
	customizedPlayers = true;
}

void CMapGenOptions::finalize(CRandomGenerator & rand)
{
	logGlobal->info("RMG map: %dx%d, %s underground", getWidth(), getHeight(), getHasTwoLevels() ? "WITH" : "NO");
	logGlobal->info("RMG settings: players %d, teams %d, computer players %d, computer teams %d, water %d, monsters %d",
		static_cast<int>(getHumanOrCpuPlayerCount()), static_cast<int>(getTeamCount()), static_cast<int>(getCompOnlyPlayerCount()),
		static_cast<int>(getCompOnlyTeamCount()), static_cast<int>(getWaterContent()), static_cast<int>(getMonsterStrength()));

	if(!mapTemplate)
	{
		mapTemplate = getPossibleTemplate(rand);
	}
	assert(mapTemplate);
	
	logGlobal->info("RMG template name: %s", mapTemplate->getName());

	auto maxPlayers = getMaxPlayersCount();
	if (getHumanOrCpuPlayerCount() == RANDOM_SIZE)
	{
		auto possiblePlayers = mapTemplate->getPlayers().getNumbers();
		//ignore all non-randomized players, make sure these players will not be missing after roll
		possiblePlayers.erase(possiblePlayers.begin(), possiblePlayers.lower_bound(countHumanPlayers() + countCompOnlyPlayers()));

		vstd::erase_if(possiblePlayers, [maxPlayers](int i)
		{
			return i > maxPlayers;
		});
		assert(!possiblePlayers.empty());
		setHumanOrCpuPlayerCount (*RandomGeneratorUtil::nextItem(possiblePlayers, rand));
		updatePlayers();
	}
	if(teamCount == RANDOM_SIZE)
	{
		teamCount = rand.nextInt(getHumanOrCpuPlayerCount() - 1);
		if (teamCount == 1)
			teamCount = 0;
	}
	if(compOnlyPlayerCount == RANDOM_SIZE)
	{
		// Use remaining range
		auto presentPlayers = getHumanOrCpuPlayerCount();
		auto possiblePlayers = mapTemplate->getPlayers().getNumbers();
		vstd::erase_if(possiblePlayers, [maxPlayers, presentPlayers](int i)
		{
			return i > (maxPlayers - presentPlayers);
		});
		if (possiblePlayers.empty())
		{
			compOnlyPlayerCount = 0;
		}
		else
		{
			compOnlyPlayerCount = *RandomGeneratorUtil::nextItem(possiblePlayers, rand);
		}
		updateCompOnlyPlayers();
	}
	if(compOnlyTeamCount == RANDOM_SIZE)
	{
		compOnlyTeamCount = rand.nextInt(std::max(compOnlyPlayerCount - 1, 0));
	}

	if(waterContent == EWaterContent::RANDOM)
	{
		auto allowedContent = mapTemplate->getWaterContentAllowed();

		if(!allowedContent.empty())
		{
			waterContent = *RandomGeneratorUtil::nextItem(mapTemplate->getWaterContentAllowed(), rand);
		}
		else
		{
			waterContent = EWaterContent::NONE;
		}
	}

	if(monsterStrength == EMonsterStrength::RANDOM)
	{
		monsterStrength = static_cast<EMonsterStrength::EMonsterStrength>(rand.nextInt(EMonsterStrength::GLOBAL_WEAK, EMonsterStrength::GLOBAL_STRONG));
	}

	assert (vstd::iswithin(waterContent, EWaterContent::NONE, EWaterContent::ISLANDS));
	assert (vstd::iswithin(monsterStrength, EMonsterStrength::GLOBAL_WEAK, EMonsterStrength::GLOBAL_STRONG));

	logGlobal->trace("Player config:");
	int cpuOnlyPlayers = 0;
	for(const auto & player : players)
	{
		std::string playerType;
		switch (player.second.getPlayerType())
		{
		case EPlayerType::AI:
			playerType = "AI";
			break;
		case EPlayerType::COMP_ONLY:
			playerType = "computer only";
			cpuOnlyPlayers++;
			break;
		case EPlayerType::HUMAN:
			playerType = "human only";
			break;
			default:
				assert(false);
		}
		logGlobal->trace("Player %d: %s", player.second.getColor(), playerType);
	}
	logGlobal->info("Final player config: %d total, %d cpu-only", players.size(), cpuOnlyPlayers);
}

void CMapGenOptions::updatePlayers()
{
	// Remove non-human players only from the end of the players map if necessary
	for(auto itrev = players.end(); itrev != players.begin();)
	{
		auto it = itrev;
		--it;
		if (players.size() == getHumanOrCpuPlayerCount()) break;
		if(it->second.getPlayerType() != EPlayerType::HUMAN)
		{
			players.erase(it);
		}
		else
		{
			--itrev;
		}
	}
}

void CMapGenOptions::updateCompOnlyPlayers()
{
	// Remove comp only players only from the end of the players map if necessary
	for(auto itrev = players.end(); itrev != players.begin();)
	{
		auto it = itrev;
		--it;
		if (players.size() <= getHumanOrCpuPlayerCount()) break;
		if(it->second.getPlayerType() == EPlayerType::COMP_ONLY)
		{
			players.erase(it);
		}
		else
		{
			--itrev;
		}
	}

	// Add some comp only players if necessary
	int compOnlyPlayersToAdd = static_cast<int>(getHumanOrCpuPlayerCount() - players.size());

	if (compOnlyPlayersToAdd < 0)
	{
		logGlobal->error("Incorrect number of players to add. Requested players %d, current players %d", humanOrCpuPlayerCount, players.size());
		assert (compOnlyPlayersToAdd < 0);
	}
	for(int i = 0; i < compOnlyPlayersToAdd; ++i)
	{
		CPlayerSettings pSettings;
		pSettings.setPlayerType(EPlayerType::COMP_ONLY);
		pSettings.setColor(getNextPlayerColor());
		players[pSettings.getColor()] = pSettings;
	}
}

int CMapGenOptions::countHumanPlayers() const
{
	return static_cast<int>(boost::count_if(players, [](const std::pair<PlayerColor, CPlayerSettings> & pair)
	{
		return pair.second.getPlayerType() == EPlayerType::HUMAN;
	}));
}

int CMapGenOptions::countCompOnlyPlayers() const
{
	return static_cast<int>(boost::count_if(players, [](const std::pair<PlayerColor, CPlayerSettings> & pair)
	{
		return pair.second.getPlayerType() == EPlayerType::COMP_ONLY;
	}));
}


PlayerColor CMapGenOptions::getNextPlayerColor() const
{
	for(PlayerColor i = PlayerColor(0); i < PlayerColor::PLAYER_LIMIT; i.advance(1))
	{
		if(!players.count(i))
		{
			return i;
		}
	}
	logGlobal->error("Failed to get next player color");
	assert(false);
	return PlayerColor(0);
}

bool CMapGenOptions::checkOptions() const
{
	if(mapTemplate)
	{
		return true;
	}
	else
	{
		CRandomGenerator gen;
		return getPossibleTemplate(gen) != nullptr;
	}
}

bool CMapGenOptions::arePlayersCustomized() const
{
	return customizedPlayers;
}

std::vector<const CRmgTemplate *> CMapGenOptions::getPossibleTemplates() const
{
	int3 tplSize(width, height, (hasTwoLevels ? 2 : 1));
	auto humanPlayers = countHumanPlayers();

	auto templates = VLC->tplh->getTemplates();

	vstd::erase_if(templates, [this, &tplSize, humanPlayers](const CRmgTemplate * tmpl)
	{
		if(!tmpl->matchesSize(tplSize))
			return true;

		if(!tmpl->isWaterContentAllowed(getWaterContent()))
			return true;

		auto humanOrCpuPlayerCount = getHumanOrCpuPlayerCount();
		auto compOnlyPlayerCount =  getCompOnlyPlayerCount();
		// Check if total number of players fall inside given range

		if(humanOrCpuPlayerCount != CMapGenOptions::RANDOM_SIZE && compOnlyPlayerCount != CMapGenOptions::RANDOM_SIZE)
		{
			if (!tmpl->getPlayers().isInRange(humanOrCpuPlayerCount + compOnlyPlayerCount))
				return true;

		}
		else if(humanOrCpuPlayerCount != CMapGenOptions::RANDOM_SIZE)
		{
			// We can always add any number CPU players, but not subtract
			if (!(humanOrCpuPlayerCount <= tmpl->getPlayers().maxValue()))
				return true;
		}
		else if(compOnlyPlayerCount != CMapGenOptions::RANDOM_SIZE)
		{
			//We must fit at least one more human player, but can add any number
			if (!(compOnlyPlayerCount < tmpl->getPlayers().maxValue()))
				return true;
		}
		else
		{
			// Human players shouldn't be banned when playing with random player count
			if(humanPlayers > tmpl->getPlayers().minValue())
				return true;
		}

		return false;
	});

	return templates;
}

const CRmgTemplate * CMapGenOptions::getPossibleTemplate(CRandomGenerator & rand) const
{
	auto templates = getPossibleTemplates();

	if(templates.empty())
		return nullptr;
	
	return *RandomGeneratorUtil::nextItem(templates, rand);
}

CMapGenOptions::CPlayerSettings::CPlayerSettings() : color(0), startingTown(FactionID::RANDOM), startingHero(HeroTypeID::RANDOM), playerType(EPlayerType::AI), team(TeamID::NO_TEAM)
{

}

PlayerColor CMapGenOptions::CPlayerSettings::getColor() const
{
	return color;
}

void CMapGenOptions::CPlayerSettings::setColor(const PlayerColor & value)
{
	assert(value >= PlayerColor(0) && value < PlayerColor::PLAYER_LIMIT);
	color = value;
}

FactionID CMapGenOptions::CPlayerSettings::getStartingTown() const
{
	return startingTown;
}

void CMapGenOptions::CPlayerSettings::setStartingTown(FactionID value)
{
	assert(value >= FactionID::RANDOM);
	if(value != FactionID::RANDOM)
	{
		assert(value < FactionID(VLC->townh->size()));
		assert((*VLC->townh)[value]->town != nullptr);
	}
	startingTown = value;
}

HeroTypeID CMapGenOptions::CPlayerSettings::getStartingHero() const
{
	return startingHero;
}

void CMapGenOptions::CPlayerSettings::setStartingHero(HeroTypeID value)
{
	assert(value == HeroTypeID::RANDOM || value.toEntity(VLC) != nullptr);
	startingHero = value;
}

EPlayerType CMapGenOptions::CPlayerSettings::getPlayerType() const
{
	return playerType;
}

void CMapGenOptions::CPlayerSettings::setPlayerType(EPlayerType value)
{
	playerType = value;
}

TeamID CMapGenOptions::CPlayerSettings::getTeam() const
{
	return team;
}

void CMapGenOptions::CPlayerSettings::setTeam(const TeamID & value)
{
	team = value;
}

void CMapGenOptions::serializeJson(JsonSerializeFormat & handler)
{
	handler.serializeInt("width", width);
	handler.serializeInt("height", height);
	handler.serializeBool("haswoLevels", hasTwoLevels);
	handler.serializeInt("humanOrCpuPlayerCount", humanOrCpuPlayerCount);
	handler.serializeInt("teamCount", teamCount);
	handler.serializeInt("compOnlyPlayerCount", compOnlyPlayerCount);
	handler.serializeInt("compOnlyTeamCount", compOnlyTeamCount);
	handler.serializeInt("waterContent", waterContent);
	handler.serializeInt("monsterStrength", monsterStrength);

	std::string templateName;
	if(mapTemplate && handler.saving)
	{
		templateName = mapTemplate->getId();
	}
	handler.serializeString("templateName", templateName);
	if(!handler.saving)
	{
		setMapTemplate(templateName);
	}

	handler.serializeIdArray("roads", enabledRoads);
	if (!handler.saving)
	{
		// Player settings won't be saved
		resetPlayersMap();
	}
}

VCMI_LIB_NAMESPACE_END