void CvTradeRoute::setSourceCity(const IDInfo& kCity)
{
if (getSourceCity() != kCity)
{
setActiveDirty();
const IDInfo& kOldCity = getSourceCity();
m_kSourceCity = kCity;
CvCity* pCity = ::getCity(getSourceCity());
FAssert(pCity != NULL);
if (pCity != NULL)
{
pCity->updateExport(getYield());
}
pCity = ::getCity(kOldCity);
FAssert(pCity != NULL);
if (pCity != NULL)
{
pCity->updateExport(getYield());
}
setActiveDirty();
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseSellBuilding(PlayerTypes ePlayer, int iCityID, BuildingTypes eBuilding)
{
CvCity* pCity = GET_PLAYER(ePlayer).getCity(iCityID);
if(pCity)
{
pCity->GetCityBuildings()->DoSellBuilding(eBuilding);
#if defined(MOD_EVENTS_CITY)
if (MOD_EVENTS_CITY) {
GAMEEVENTINVOKE_HOOK(GAMEEVENT_CitySoldBuilding, ePlayer, iCityID, eBuilding);
} else {
#endif
ICvEngineScriptSystem1* pkScriptSystem = gDLL->GetScriptSystem();
if (pkScriptSystem)
{
CvLuaArgsHandle args;
args->Push(ePlayer);
args->Push(iCityID);
args->Push(eBuilding);
bool bResult;
LuaSupport::CallHook(pkScriptSystem, "CitySoldBuilding", args.get(), bResult);
}
#if defined(MOD_EVENTS_CITY)
}
#endif
}
}
void CvTradeRoute::setYield(YieldTypes eYield)
{
if (getYield() != eYield)
{
YieldTypes eOldYield = getYield();
m_eYield = eYield;
CvCity* pCity = ::getCity(getDestinationCity());
FAssert(pCity != NULL);
if (pCity != NULL)
{
pCity->updateImport(getYield());
pCity->updateImport(eOldYield);
}
pCity = ::getCity(getSourceCity());
FAssert(pCity != NULL);
if (pCity != NULL)
{
pCity->updateExport(getYield());
pCity->updateExport(eOldYield);
}
setActiveDirty();
}
}
// Find all our enemies (combat units)
void CvTacticalAnalysisMap::BuildEnemyUnitList()
{
m_EnemyUnits.clear();
m_EnemyCities.clear();
TeamTypes ourTeam = GET_PLAYER(m_ePlayer).getTeam();
for(int iPlayer = 0; iPlayer < MAX_PLAYERS; iPlayer++)
{
const PlayerTypes ePlayer = (PlayerTypes)iPlayer;
CvPlayer& kPlayer = GET_PLAYER(ePlayer);
const TeamTypes eTeam = kPlayer.getTeam();
// for each opposing civ
if(kPlayer.isAlive() && GET_TEAM(eTeam).isAtWar(ourTeam))
{
int iLoop;
CvUnit* pLoopUnit = NULL;
CvCity* pLoopCity;
for(pLoopCity = kPlayer.firstCity(&iLoop); pLoopCity != NULL; pLoopCity = kPlayer.nextCity(&iLoop))
if (pLoopCity->plot()->isRevealed(ourTeam))
m_EnemyCities.push_back(pLoopCity->GetIDInfo());
for(pLoopUnit = kPlayer.firstUnit(&iLoop); pLoopUnit != NULL; pLoopUnit = kPlayer.nextUnit(&iLoop))
if(pLoopUnit->IsCanAttack() && pLoopUnit->plot()->isVisible(ourTeam))
m_EnemyUnits.push_back(pLoopUnit->GetIDInfo());
}
}
}
/// Get the amount of gold granted by connecting the city
int CvTreasury::GetCityConnectionRouteGoldTimes100(CvCity* pNonCapitalCity) const
{
CvCity* pCapitalCity = m_pPlayer->getCapitalCity();
if(!pNonCapitalCity || pNonCapitalCity == pCapitalCity || pCapitalCity == NULL)
{
return 0;
}
int iGold = 0;
int iTradeRouteBaseGold = /*100*/ GC.getTRADE_ROUTE_BASE_GOLD();
int iTradeRouteCapitalGoldMultiplier = /*0*/ GC.getTRADE_ROUTE_CAPITAL_POP_GOLD_MULTIPLIER();
int iTradeRouteCityGoldMultiplier = /*125*/ GC.getTRADE_ROUTE_CITY_POP_GOLD_MULTIPLIER();
iGold += iTradeRouteBaseGold; // Base Gold: 0
iGold += (pCapitalCity->getPopulation() * iTradeRouteCapitalGoldMultiplier); // Capital Multiplier
iGold += (pNonCapitalCity->getPopulation() * iTradeRouteCityGoldMultiplier); // City Multiplier
iGold += GetCityConnectionTradeRouteGoldChange() * 100;
if(GetCityConnectionTradeRouteGoldModifier() != 0)
{
iGold *= (100 + GetCityConnectionTradeRouteGoldModifier());
iGold /= 100;
}
return iGold;
}
// What are our gold maintenance costs because of Vassals?
int CvTreasury::GetVassalGoldMaintenance() const
{
int iRtnValue = 0;
// We have a vassal
for(int iI = 0; iI < MAX_MAJOR_CIVS; iI++)
{
if(!GET_PLAYER((PlayerTypes)iI).isMinorCiv()
&& !GET_PLAYER((PlayerTypes)iI).isBarbarian()
&& GET_PLAYER((PlayerTypes)iI).isAlive())
{
int iLoop, iCityPop;
// This player is our vassal
if(GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).IsVassal(m_pPlayer->getTeam()))
{
// Loop through our vassal's cities
for(CvCity* pLoopCity = GET_PLAYER((PlayerTypes)iI).firstCity(&iLoop); pLoopCity != NULL; pLoopCity = GET_PLAYER((PlayerTypes)iI).nextCity(&iLoop))
{
iCityPop = pLoopCity->getPopulation();
iRtnValue += std::max(0, (int)(pow((double)iCityPop, (double)/*0.6*/ GC.getVASSALAGE_VASSAL_CITY_POP_EXPONENT())));
}
iRtnValue += std::max(0, (GET_PLAYER((PlayerTypes)iI).GetTreasury()->GetExpensePerTurnUnitMaintenance() * /*10*/GC.getVASSALAGE_VASSAL_UNIT_MAINT_COST_PERCENT() / 100));
}
}
}
// Modifier for vassal maintenance?
iRtnValue *= (100 + m_pPlayer->GetVassalGoldMaintenanceMod());
iRtnValue /= 100;
return iRtnValue;
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseCityBuyPlot(PlayerTypes ePlayer, int iCityID, int iX, int iY)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvCity* pkCity = kPlayer.getCity(iCityID);
if(pkCity != NULL)
{
CvPlot* pkPlot = NULL;
// (-1,-1) means pick a random plot to buy
if(iX == -1 && iY == -1)
{
#if defined(MOD_BALANCE_CORE)
pkPlot = pkCity->GetNextBuyablePlot(false);
#else
pkPlot = pkCity->GetNextBuyablePlot();
#endif
}
else
{
pkPlot = GC.getMap().plot(iX, iY);
}
if(pkPlot != NULL)
{
if(pkCity->CanBuyPlot(pkPlot->getX(), pkPlot->getY()))
{
pkCity->BuyPlot(pkPlot->getX(), pkPlot->getY());
if(ePlayer == GC.getGame().getActivePlayer() && GC.GetEngineUserInterface()->isCityScreenUp())
{
GC.GetEngineUserInterface()->setDirty(CityScreen_DIRTY_BIT, true);
}
}
}
}
}
void CvPlotGroup::changeNumBonuses(BonusTypes eBonus, int iChange)
{
CLLNode<XYCoords>* pPlotNode;
CvCity* pCity;
int iOldNumBonuses;
FAssertMsg(eBonus >= 0, "eBonus is expected to be non-negative (invalid Index)");
FAssertMsg(eBonus < GC.getNumBonusInfos(), "eBonus is expected to be within maximum bounds (invalid Index)");
if (iChange != 0)
{
iOldNumBonuses = getNumBonuses(eBonus);
m_paiNumBonuses[eBonus] = (m_paiNumBonuses[eBonus] + iChange);
//FAssertMsg(m_paiNumBonuses[eBonus] >= 0, "m_paiNumBonuses[eBonus] is expected to be non-negative (invalid Index)"); XXX
pPlotNode = headPlotsNode();
while (pPlotNode != NULL)
{
pCity = GC.getMapINLINE().plotSorenINLINE(pPlotNode->m_data.iX, pPlotNode->m_data.iY)->getPlotCity();
if (pCity != NULL)
{
if (pCity->getOwnerINLINE() == getOwnerINLINE())
{
pCity->changeNumBonuses(eBonus, iChange);
}
}
pPlotNode = nextPlotsNode(pPlotNode);
}
}
}
void CvTradeRoute::setDestinationCity(const IDInfo& kCity)
{
if (getDestinationCity() != kCity)
{
setActiveDirty();
const IDInfo& kOldCity = getDestinationCity();
m_kDestinationCity = kCity;
CvCity* pCity = ::getCity(getDestinationCity());
FAssert(pCity != NULL || getDestinationCity().iID == EUROPE_CITY_ID);
if (pCity != NULL)
{
pCity->updateImport(getYield());
}
pCity = ::getCity(kOldCity);
FAssert(pCity != NULL || getDestinationCity().iID == EUROPE_CITY_ID);
if (pCity != NULL)
{
pCity->updateImport(getYield());
}
setActiveDirty();
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseSellBuilding(PlayerTypes ePlayer, int iCityID, BuildingTypes eBuilding)
{
CvCity* pCity = GET_PLAYER(ePlayer).getCity(iCityID);
if(pCity)
{
pCity->GetCityBuildings()->DoSellBuilding(eBuilding);
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseCityPushOrder(PlayerTypes ePlayer, int iCityID, OrderTypes eOrder, int iData, bool bAlt, bool bShift, bool bCtrl)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvCity* pkCity = kPlayer.getCity(iCityID);
if(pkCity != NULL)
{
pkCity->pushOrder(eOrder, iData, -1, bAlt, bShift, bCtrl);
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseCityPurchase(PlayerTypes ePlayer, int iCityID, UnitTypes eUnitType, BuildingTypes eBuildingType, ProjectTypes eProjectType, int ePurchaseYield)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvCity* pkCity = kPlayer.getCity(iCityID);
if(pkCity && ePurchaseYield >= -1 && ePurchaseYield < NUM_YIELD_TYPES)
{
pkCity->Purchase(eUnitType, eBuildingType, eProjectType, static_cast<YieldTypes>(ePurchaseYield));
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseCitySwapOrder(PlayerTypes ePlayer, int iCityID, int iNum)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvCity* pkCity = kPlayer.getCity(iCityID);
if(pkCity != NULL)
{
pkCity->swapOrder(iNum);
}
}
result_type operator() (const ResourceInfo::BaseNode& node)
{
info.rawHappy = node.baseHappy;
for (size_t i = 0, count = node.buildingNodes.size(); i < count; ++i)
{
(*this)(node.buildingNodes[i]);
}
CityIter iter(CvPlayerAI::getPlayer(playerType_));
CvCity* pLoopCity;
// how many citizens are made happy now if we had the resource, how many would be happy if we had the requisite buildings,
// and how many more could be made happy with the buildings we have.
// E.g. suppose we have 1 unhappy citizen in a city, with a forge - and we analyse gold - this would give:
// actualHappy = 1, potentialHappy = 0, unusedHappy = 1, but if the city had no forge, it should give:
// actualHappy = 1, potentialHappy = 1, unusedHappy = 0
int actualHappy = 0, potentialHappy = 0, unusedHappy = 0;
while (pLoopCity = iter())
{
int unhappyCitizens = std::max<int>(0, pLoopCity->unhappyLevel() - pLoopCity->happyLevel());
int baseHappy = std::min<int>(node.baseHappy, unhappyCitizens);
// have we got any left?
unhappyCitizens = std::max<int>(0, unhappyCitizens - baseHappy);
if (unhappyCitizens == 0)
{
unusedHappy += node.baseHappy - baseHappy;
}
actualHappy += baseHappy;
for (size_t i = 0, count = info.buildingHappy.size(); i < count; ++i)
{
int buildingCount = pLoopCity->getNumBuilding(info.buildingHappy[i].first);
if (buildingCount > 0)
{
int thisBuildingCount = std::min<int>(buildingCount * info.buildingHappy[i].second, unhappyCitizens);
unhappyCitizens = std::max<int>(0, unhappyCitizens - thisBuildingCount);
if (unhappyCitizens == 0)
{
unusedHappy += buildingCount * info.buildingHappy[i].second - thisBuildingCount;
}
actualHappy += thisBuildingCount;
}
else // just assumes one building allowed (should use getCITY_MAX_NUM_BUILDINGS(), but this would be wrong if building is limited in some other way, e.g. wonders)
{
potentialHappy += info.buildingHappy[i].second;
}
}
}
info.actualHappy = actualHappy;
info.potentialHappy = potentialHappy;
info.unusedHappy = unusedHappy;
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseCityDoTask(PlayerTypes ePlayer, int iCityID, TaskTypes eTask, int iData1, int iData2, bool bOption, bool bAlt, bool bShift, bool bCtrl)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvCity* pkCity = kPlayer.getCity(iCityID);
if(pkCity != NULL)
{
pkCity->doTask(eTask, iData1, iData2, bOption, bAlt, bShift, bCtrl);
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseRenameCity(PlayerTypes ePlayer, int iCityID, const char* szName)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvCity* pkCity = kPlayer.getCity(iCityID);
if(pkCity)
{
CvString strName = szName;
pkCity->setName(strName);
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseFaithGreatPersonChoice(PlayerTypes ePlayer, UnitTypes eGreatPersonUnit)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvCity* pCity = kPlayer.GetGreatPersonSpawnCity(eGreatPersonUnit);
if(pCity)
{
pCity->GetCityCitizens()->DoSpawnGreatPerson(eGreatPersonUnit, true, true);
}
kPlayer.ChangeNumFaithGreatPeople(-1);
}
void CvNetDoTask::Execute()
{
if (m_ePlayer != NO_PLAYER)
{
CvCity* pCity = GET_PLAYER(m_ePlayer).getCity(m_iCityID);
if (pCity != NULL)
{
pCity->doTask(m_eTask, m_iData1, m_iData2, m_bOption, m_bAlt, m_bShift, m_bCtrl);
}
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseMayaBonusChoice(PlayerTypes ePlayer, UnitTypes eGreatPersonUnit)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvCity* pCity = kPlayer.GetGreatPersonSpawnCity(eGreatPersonUnit);
if(pCity)
{
pCity->GetCityCitizens()->DoSpawnGreatPerson(eGreatPersonUnit, true, false);
}
kPlayer.ChangeNumMayaBoosts(-1);
kPlayer.GetPlayerTraits()->SetUnitBaktun(eGreatPersonUnit);
}
// Can this tile be attacked by an enemy unit or city next turn?
bool CvDangerPlotContents::IsUnderImmediateThreat(const CvUnit* pUnit)
{
if (!m_pPlot || !pUnit)
return false;
// Air units operate off of intercepts instead of units/cities that can attack them
if (pUnit->getDomainType() == DOMAIN_AIR)
{
if (pUnit->GetBestInterceptor(*m_pPlot))
{
return true;
}
}
else
{
// Cities in range
for (DangerCityVector::iterator it = m_apCities.begin(); it < m_apCities.end(); ++it)
{
CvCity* pCity = GET_PLAYER(it->first).getCity(it->second);
if (pCity && pCity->getTeam() != pUnit->getTeam())
{
return true;
}
}
// Units in range
for (DangerUnitVector::iterator it = m_apUnits.begin(); it < m_apUnits.end(); ++it)
{
CvUnit* pUnit = GET_PLAYER(it->first).getUnit(it->second);
if (pUnit && !pUnit->isDelayedDeath() && !pUnit->IsDead())
{
return true;
}
}
// Citadel etc in range
if (GetDamageFromFeatures(pUnit->getOwner()) > 0)
{
return true;
}
}
// Terrain damage is greater than heal rate
int iMinimumDamage = m_bFlatPlotDamage ? m_pPlot->getTurnDamage(pUnit->ignoreTerrainDamage(), pUnit->ignoreFeatureDamage(), pUnit->extraTerrainDamage(), pUnit->extraFeatureDamage()) : 0;
if (pUnit->canHeal(m_pPlot))
{
iMinimumDamage -= pUnit->healRate(m_pPlot);
}
return (iMinimumDamage > 0);
}
/// What are our gold maintenance costs because of Buildings?
int CvTreasury::GetBuildingGoldMaintenance() const
{
int iMaintenance = GetBaseBuildingGoldMaintenance();
// Player modifier
iMaintenance *= (100 + m_pPlayer->GetBuildingGoldMaintenanceMod());
iMaintenance /= 100;
#if defined(MOD_BALANCE_CORE)
iMaintenance *= (100 + m_pPlayer->GetBuildingMaintenanceMod());
iMaintenance /= 100;
#endif
// Modifier for difficulty level
CvHandicapInfo& playerHandicap = m_pPlayer->getHandicapInfo();
//iMaintenance *= playerHandicap->getBuildingCostPercent();
//iMaintenance /= 100;
// Human bonus for Building maintenance costs
if(m_pPlayer->isHuman())
{
iMaintenance *= playerHandicap.getBuildingCostPercent();
iMaintenance /= 100;
}
// AI bonus for Building maintenance costs
else if(!m_pPlayer->IsAITeammateOfHuman())
{
iMaintenance *= GC.getGame().getHandicapInfo().getAIBuildingCostPercent();
iMaintenance /= 100;
}
// Start Era mod
iMaintenance *= GC.getGame().getStartEraInfo().getBuildingMaintenancePercent();
iMaintenance /= 100;
#if defined(MOD_BALANCE_CORE)
if(MOD_BALANCE_CORE_BUILDING_RESOURCE_MAINTENANCE)
{
CvCity* pLoopCity;
int iLoop;
for(pLoopCity = m_pPlayer->firstCity(&iLoop); pLoopCity != NULL; pLoopCity = m_pPlayer->nextCity(&iLoop))
{
if(pLoopCity->GetExtraBuildingMaintenance() > 0)
{
iMaintenance *= (100 + pLoopCity->GetExtraBuildingMaintenance());
iMaintenance /= 100;
}
}
}
#endif
return iMaintenance;
}
//------------------------------------------------------------------------------
int CvDllGameContext::GetNUM_CITY_PLOTS() const
{
int iNumCityPlots = AVG_CITY_PLOTS;
auto_ptr<ICvCity1> pCity(GC.GetEngineUserInterface()->getHeadSelectedCity());
if (pCity.get() != NULL) {
CvCity* pkCity = GC.UnwrapCityPointer(pCity.get());
iNumCityPlots = pkCity->GetNumWorkablePlots();
}
return iNumCityPlots;
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseSetCityAvoidGrowth(PlayerTypes ePlayer, int iCityID, bool bAvoidGrowth)
{
CvCity* pCity = GET_PLAYER(ePlayer).getCity(iCityID);
if(pCity != NULL)
{
CvCityCitizens* pkCitizens = pCity->GetCityCitizens();
if(pkCitizens != NULL)
{
pkCitizens->SetForcedAvoidGrowth(bAvoidGrowth);
}
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseSetCityAIFocus(PlayerTypes ePlayer, int iCityID, CityAIFocusTypes eFocus)
{
CvCity* pCity = GET_PLAYER(ePlayer).getCity(iCityID);
if(pCity != NULL)
{
CvCityCitizens* pkCitizens = pCity->GetCityCitizens();
if(pkCitizens != NULL)
{
pkCitizens->SetFocusType(eFocus);
}
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseUpdateCityCitizens(PlayerTypes ePlayer, int iCityID)
{
CvCity* pCity = GET_PLAYER(ePlayer).getCity(iCityID);
if(NULL != pCity && pCity->GetCityCitizens())
{
CvCityCitizens* pkCitizens = pCity->GetCityCitizens();
if(pkCitizens != NULL)
{
pkCitizens->DoVerifyWorkingPlots();
pkCitizens->DoReallocateCitizens();
}
}
}
result_type operator() (const ResourceInfo::BaseNode& node)
{
info.rawHealth = node.baseHealth;
for (size_t i = 0, count = node.buildingNodes.size(); i < count; ++i)
{
(*this)(node.buildingNodes[i]);
}
CityIter iter(CvPlayerAI::getPlayer(playerType_));
CvCity* pLoopCity;
int actualHealth = 0, potentialHealth = 0, unusedHealth = 0;
while (pLoopCity = iter())
{
int unhealthyCitizens = pLoopCity->healthRate();
int baseHealth = std::min<int>(node.baseHealth, unhealthyCitizens);
// have we got any left?
unhealthyCitizens = std::max<int>(0, unhealthyCitizens - baseHealth);
if (unhealthyCitizens == 0)
{
unusedHealth += node.baseHealth - baseHealth;
}
actualHealth += baseHealth;
for (size_t i = 0, count = info.buildingHealth.size(); i < count; ++i)
{
int buildingCount = pLoopCity->getNumBuilding(info.buildingHealth[i].first);
if (buildingCount > 0)
{
int thisBuildingCount = std::min<int>(buildingCount * info.buildingHealth[i].second, unhealthyCitizens);
unhealthyCitizens = std::max<int>(0, unhealthyCitizens - thisBuildingCount);
if (unhealthyCitizens == 0)
{
unusedHealth += buildingCount * info.buildingHealth[i].second - thisBuildingCount;
}
actualHealth += thisBuildingCount;
}
else // just assumes one building allowed
{
potentialHealth += info.buildingHealth[i].second;
}
}
}
info.actualHealth = actualHealth;
info.potentialHealth = potentialHealth;
info.unusedHealth = unusedHealth;
}
// Gold from Cities times 100
int CvTreasury::GetGoldFromCitiesTimes100(bool bExcludeTradeRoutes) const
{
int iGold = 0;
CvCity* pLoopCity;
int iLoop;
for(pLoopCity = m_pPlayer->firstCity(&iLoop); pLoopCity != NULL; pLoopCity = m_pPlayer->nextCity(&iLoop))
{
iGold += pLoopCity->getYieldRateTimes100(YIELD_GOLD, bExcludeTradeRoutes);
}
return iGold;
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseSellBuilding(PlayerTypes ePlayer, int iCityID, BuildingTypes eBuilding)
{
CvCity* pCity = GET_PLAYER(ePlayer).getCity(iCityID);
if(pCity)
{
pCity->GetCityBuildings()->DoSellBuilding(eBuilding);
#if defined(MOD_EVENTS_CITY)
if (MOD_EVENTS_CITY) {
GAMEEVENTINVOKE_HOOK(GAMEEVENT_CitySoldBuilding, ePlayer, iCityID, eBuilding);
}
#endif
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseFaithGreatPersonChoice(PlayerTypes ePlayer, UnitTypes eGreatPersonUnit)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvCity* pCity = kPlayer.GetGreatPersonSpawnCity(eGreatPersonUnit);
if(pCity)
{
#if defined(MOD_GLOBAL_TRULY_FREE_GP)
pCity->GetCityCitizens()->DoSpawnGreatPerson(eGreatPersonUnit, true, true, false);
#else
pCity->GetCityCitizens()->DoSpawnGreatPerson(eGreatPersonUnit, true, true);
#endif
}
kPlayer.ChangeNumFaithGreatPeople(-1);
}
void CvPlayerAI::AI_chooseFreeGreatPerson()
{
while(GetNumFreeGreatPeople() > 0)
{
UnitTypes eDesiredGreatPerson = NO_UNIT;
// Highly wonder competitive and still early in game?
if(GetDiplomacyAI()->GetWonderCompetitiveness() >= 8 && GC.getGame().getGameTurn() <= (GC.getGame().getEstimateEndTurn() / 2))
{
eDesiredGreatPerson = (UnitTypes)GC.getInfoTypeForString("UNIT_ENGINEER");
}
else
{
// Pick the person based on our victory method
AIGrandStrategyTypes eVictoryStrategy = GetGrandStrategyAI()->GetActiveGrandStrategy();
if(eVictoryStrategy == (AIGrandStrategyTypes) GC.getInfoTypeForString("AIGRANDSTRATEGY_CONQUEST"))
{
eDesiredGreatPerson = (UnitTypes)GC.getInfoTypeForString("UNIT_GREAT_GENERAL");
}
else if(eVictoryStrategy == (AIGrandStrategyTypes) GC.getInfoTypeForString("AIGRANDSTRATEGY_CULTURE"))
{
eDesiredGreatPerson = (UnitTypes)GC.getInfoTypeForString("UNIT_ARTIST");
}
else if(eVictoryStrategy == (AIGrandStrategyTypes) GC.getInfoTypeForString("AIGRANDSTRATEGY_UNITED_NATIONS"))
{
eDesiredGreatPerson = (UnitTypes)GC.getInfoTypeForString("UNIT_MERCHANT");
}
else if(eVictoryStrategy == (AIGrandStrategyTypes) GC.getInfoTypeForString("AIGRANDSTRATEGY_SPACESHIP"))
{
eDesiredGreatPerson = (UnitTypes)GC.getInfoTypeForString("UNIT_SCIENTIST");
}
}
if(eDesiredGreatPerson != NO_UNIT)
{
CvCity* pCapital = getCapitalCity();
if(pCapital)
{
pCapital->GetCityCitizens()->DoSpawnGreatPerson(eDesiredGreatPerson, true, false);
}
ChangeNumFreeGreatPeople(-1);
}
else
{
break;
}
}
}
