/// Guess as to how much another Player is prioritizing the SS as his means of winning the game
int CvGrandStrategyAI::GetGuessOtherPlayerSpaceshipPriority(PlayerTypes ePlayer, int iWorldNumTechsAverage)
{
VictoryTypes eVictory = (VictoryTypes) GC.getInfoTypeForString("VICTORY_SPACE_RACE", true);
// If SS Victory isn't even available then don't bother with anything
if(eVictory == NO_VICTORY)
{
return -100;
}
TeamTypes eTeam = GET_PLAYER(ePlayer).getTeam();
// If the player has the Apollo Program we're pretty sure he's going for the SS
ProjectTypes eApolloProgram = (ProjectTypes) GC.getInfoTypeForString("PROJECT_APOLLO_PROGRAM", true);
if(eApolloProgram != NO_PROJECT)
{
if(GET_TEAM(eTeam).getProjectCount(eApolloProgram) > 0)
{
return /*150*/ GC.getAI_GS_SS_HAS_APOLLO_PROGRAM();
}
}
int iNumTechs = GET_TEAM(eTeam).GetTeamTechs()->GetNumTechsKnown();
// Don't divide by zero, okay?
if(iWorldNumTechsAverage == 0)
iWorldNumTechsAverage = 1;
int iSSPriority = (iNumTechs - iWorldNumTechsAverage) * /*300*/ GC.getAI_GS_SS_TECH_PROGRESS_MOD() / iWorldNumTechsAverage;
return iSSPriority;
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseResearch(PlayerTypes ePlayer, TechTypes eTech, int iDiscover, PlayerTypes ePlayerToStealFrom, bool bShift)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvTeam& kTeam = GET_TEAM(kPlayer.getTeam());
// Free tech
if(iDiscover > 0)
{
// Make sure we can research this tech for free
if(kPlayer.GetPlayerTechs()->CanResearchForFree(eTech))
{
kTeam.setHasTech(eTech, true, ePlayer, true, true);
if(iDiscover > 1)
{
if(ePlayer == GC.getGame().getActivePlayer())
{
kPlayer.chooseTech(iDiscover - 1);
}
}
kPlayer.SetNumFreeTechs(max(0, iDiscover - 1));
}
}
// Stealing tech
else if(ePlayerToStealFrom != NO_PLAYER)
{
// make sure we can still take a tech
CvAssertMsg(kPlayer.GetEspionage()->m_aiNumTechsToStealList[ePlayerToStealFrom] > 0, "No techs to steal from player");
CvAssertMsg(kPlayer.GetEspionage()->m_aaPlayerStealableTechList[ePlayerToStealFrom].size() > 0, "No techs to be stolen from this player");
CvAssertMsg(kPlayer.GetPlayerTechs()->CanResearch(eTech), "Player can't research this technology");
CvAssertMsg(GET_TEAM(GET_PLAYER(ePlayerToStealFrom).getTeam()).GetTeamTechs()->HasTech(eTech), "ePlayerToStealFrom does not have the requested tech");
if (kPlayer.GetEspionage()->m_aiNumTechsToStealList[ePlayerToStealFrom] > 0)
{
kTeam.setHasTech(eTech, true, ePlayer, true, true);
kPlayer.GetEspionage()->m_aiNumTechsToStealList[ePlayerToStealFrom]--;
}
}
// Normal tech
else
{
CvPlayerTechs* pPlayerTechs = kPlayer.GetPlayerTechs();
CvTeamTechs* pTeamTechs = kTeam.GetTeamTechs();
if(eTech == NO_TECH)
{
kPlayer.clearResearchQueue();
}
else if(pPlayerTechs->CanEverResearch(eTech))
{
if((pTeamTechs->HasTech(eTech) || pPlayerTechs->IsResearchingTech(eTech)) && !bShift)
{
kPlayer.clearResearchQueue();
}
kPlayer.pushResearch(eTech, !bShift);
}
}
}
bool atWar(TeamTypes eTeamA, TeamTypes eTeamB)
{
if((eTeamA == NO_TEAM) || (eTeamB == NO_TEAM))
{
return false;
}
CvAssert(GET_TEAM(eTeamA).isAtWar(eTeamB) == GET_TEAM(eTeamB).isAtWar(eTeamA));
CvAssert((eTeamA != eTeamB) || !(GET_TEAM(eTeamA).isAtWar(eTeamB)));
return GET_TEAM(eTeamA).isAtWar(eTeamB);
}
// Calculate how much we owe this turn due to taxes
void CvTreasury::CalculateExpensePerTurnFromVassalTaxes()
{
TeamTypes eMaster = GET_TEAM(m_pPlayer->getTeam()).GetMaster();
if(eMaster == NO_TEAM) {
if(GetExpensePerTurnFromVassalTaxes() != 0)
SetExpensePerTurnFromVassalTaxesTimes100(0);
return;
}
int iNet = CalculateGrossGoldTimes100();
int iTax = iNet * GET_TEAM(eMaster).GetVassalTax(m_pPlayer->GetID()) / 100;
SetExpensePerTurnFromVassalTaxesTimes100(iTax);
}
/// Should this player be ignored when creating the danger plots?
bool CvDangerPlots::ShouldIgnorePlayer(PlayerTypes ePlayer)
{
//if one is major and the other a minor (but no barbarian)
if(GET_PLAYER(m_ePlayer).isMinorCiv() != GET_PLAYER(ePlayer).isMinorCiv() && !GET_PLAYER(ePlayer).isBarbarian() && !GET_PLAYER(m_ePlayer).isBarbarian())
{
CvPlayer* pMinor = NULL;
CvPlayer* pMajor;
if(GET_PLAYER(m_ePlayer).isMinorCiv())
{
pMinor = &GET_PLAYER(m_ePlayer);
pMajor = &GET_PLAYER(ePlayer);
}
else
{
pMinor = &GET_PLAYER(ePlayer);
pMajor = &GET_PLAYER(m_ePlayer);
}
if(pMinor->GetMinorCivAI()->IsFriends(pMajor->GetID()))
{
return true;
}
// if we're a major, we should ignore minors that are not at war with us
if (!GET_PLAYER(m_ePlayer).isMinorCiv())
{
TeamTypes eMajorTeam = pMajor->getTeam();
TeamTypes eMinorTeam = pMinor->getTeam();
if (!GET_TEAM(eMajorTeam).isAtWar(eMinorTeam))
{
return true;
}
}
}
#if defined(MOD_DIPLOMACY_CIV4_FEATURES)
//ignore if one is vassal of the other
if ( GET_TEAM(GET_PLAYER(m_ePlayer).getTeam()).IsVassal(GET_PLAYER(ePlayer).getTeam()) ||
GET_TEAM(GET_PLAYER(ePlayer).getTeam()).IsVassal(GET_PLAYER(m_ePlayer).getTeam()) )
return true;
#endif
#if defined(MOD_BALANCE_CORE_MILITARY)
//ignore if at peace
if ( !GET_TEAM(GET_PLAYER(m_ePlayer).getTeam()).isAtWar(GET_PLAYER(ePlayer).getTeam()) )
return true;
#endif
return false;
}
void CvPlayerAI::AI_launch(VictoryTypes eVictory)
{
if(GET_TEAM(getTeam()).isHuman())
{
return;
}
if(!GET_TEAM(getTeam()).canLaunch(eVictory))
{
return;
}
launch(eVictory);
}
// How much is ePlayer contributing to my vassal tax revenue (note: this doesn't actually set anything, for pure UI purposes)
int CvTreasury::GetVassalTaxContributionTimes100(PlayerTypes ePlayer) const
{
int iNumTeamMembers = GET_TEAM(m_pPlayer->getTeam()).getAliveCount();
if(iNumTeamMembers == 0)
return 0;
int iAmount = 0;
if(GET_TEAM(GET_PLAYER(ePlayer).getTeam()).GetMaster() == m_pPlayer->getTeam())
{
iAmount += GET_PLAYER(ePlayer).GetTreasury()->GetExpensePerTurnFromVassalTaxesTimes100();
}
return iAmount / iNumTeamMembers;
}
//------------------------------------------------------------------------------
void CvAchievementUnlocker::AlexanderConquest(PlayerTypes ePlayer)
{
//Test For Alexander Conquest
CvGame& kGame = GC.getGame();
if (ePlayer == kGame.getActivePlayer())
{
CvString szLeaderName = (CvString)GET_PLAYER(ePlayer).getLeaderTypeKey();
if(szLeaderName == "LEADER_ALEXANDER")
{
if(kGame.getGameTurnYear() <= 350)
{
for(int iPlayerLoop = 0; iPlayerLoop < MAX_PLAYERS; iPlayerLoop++)
{
CvPlayer* pPlayer = &GET_PLAYER((PlayerTypes) iPlayerLoop);
//All known players must be dead and killed by us
if(GET_TEAM(pPlayer->getTeam()).isHasMet(GET_PLAYER(kGame.getActivePlayer()).getTeam()))
{
if(!pPlayer->isBarbarian() && !pPlayer->isMinorCiv())
{
if(pPlayer->isAlive() && pPlayer->GetID() != GET_PLAYER(kGame.getActivePlayer()).GetID())
{
return; // Nope.
}
}
}
}
// Yep.
gDLL->UnlockAchievement(ACHIEVEMENT_SPECIAL_CONQUEST_WORLD);
}
}
}
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseChangeWar(PlayerTypes ePlayer, TeamTypes eRivalTeam, bool bWar)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvTeam& kTeam = GET_TEAM(kPlayer.getTeam());
const TeamTypes eTeam = kPlayer.getTeam();
FAssert(eTeam != eRivalTeam);
if(bWar)
{
#if defined(MOD_EVENTS_WAR_AND_PEACE)
kTeam.declareWar(eRivalTeam, false, ePlayer);
#else
kTeam.declareWar(eRivalTeam);
#endif
}
else
{
#if defined(MOD_EVENTS_WAR_AND_PEACE)
kTeam.makePeace(eRivalTeam, true, false, ePlayer);
#else
kTeam.makePeace(eRivalTeam);
#endif
}
}
// 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;
}
// 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());
}
}
}
/// Returns Priority for Spaceship Grand Strategy
int CvGrandStrategyAI::GetSpaceshipPriority()
{
int iPriority = 0;
// If SS Victory isn't even available then don't bother with anything
VictoryTypes eVictory = (VictoryTypes) GC.getInfoTypeForString("VICTORY_SPACE_RACE", true);
if(eVictory == NO_VICTORY || !GC.getGame().isVictoryValid(eVictory))
{
return -100;
}
int iFlavorScience = m_pPlayer->GetFlavorManager()->GetPersonalityIndividualFlavor((FlavorTypes)GC.getInfoTypeForString("FLAVOR_SCIENCE"));
// the later the game the greater the chance
iPriority += m_pPlayer->GetCurrentEra() * iFlavorScience * 150 / 100;
// if I already built the Apollo Program I am very likely to follow through
ProjectTypes eApolloProgram = (ProjectTypes) GC.getInfoTypeForString("PROJECT_APOLLO_PROGRAM", true);
if(eApolloProgram != NO_PROJECT)
{
if(GET_TEAM(m_pPlayer->getTeam()).getProjectCount(eApolloProgram) > 0)
{
iPriority += /*150*/ GC.getAI_GS_SS_HAS_APOLLO_PROGRAM();
}
}
return iPriority;
}
void CvGameObjectUnit::foreach(GameObjectTypes eType, boost::function<void (CvGameObject*)> func)
{
switch(eType)
{
case GAMEOBJECT_GAME:
func(GC.getGameINLINE().getGameObject());
break;
case GAMEOBJECT_TEAM:
func(GET_TEAM(m_pUnit->getTeam()).getGameObject());
break;
case GAMEOBJECT_PLAYER:
func(GET_PLAYER(m_pUnit->getOwnerINLINE()).getGameObject());
break;
case GAMEOBJECT_CITY:
m_pUnit->plot()->getGameObject()->foreach(eType, func);
break;
case GAMEOBJECT_PLOT:
func(m_pUnit->plot()->getGameObject());
break;
case GAMEOBJECT_UNIT:
func(this);
break;
}
}
// Find all our enemies (combat units)
void CvTacticalAnalysisMap::BuildEnemyUnitList()
{
CvTacticalAnalysisEnemy enemy;
m_EnemyUnits.clear();
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(m_pPlayer->getTeam()))
{
int iLoop;
CvUnit* pLoopUnit = NULL;
for(pLoopUnit = kPlayer.firstUnit(&iLoop); pLoopUnit != NULL; pLoopUnit = kPlayer.nextUnit(&iLoop))
{
// Make sure this unit can attack
if(pLoopUnit->IsCanAttack())
{
m_EnemyUnits.push_back(pLoopUnit);
}
}
}
}
}
void CvNetChangeVassal::Execute()
{
if (m_ePlayer != NO_PLAYER)
{
FAssert(GET_PLAYER(m_ePlayer).getTeam() != m_eMasterTeam);
GET_TEAM(GET_PLAYER(m_ePlayer).getTeam()).setVassal(m_eMasterTeam, m_bVassal, m_bCapitulated);
}
}
void CvGameObjectGame::foreach(GameObjectTypes eType, boost::function<void (CvGameObject*)> func)
{
switch(eType)
{
case GAMEOBJECT_TEAM:
for (int iI = 0; iI < MAX_TEAMS; iI++)
{
if (GET_TEAM((TeamTypes)iI).isAlive())
{
func(GET_TEAM((TeamTypes)iI).getGameObject());
}
}
break;
case GAMEOBJECT_PLAYER:
for (int iPlayer = 0; iPlayer < MAX_CIV_PLAYERS; ++iPlayer)
{
CvPlayer& kLoopPlayer = GET_PLAYER((PlayerTypes)iPlayer);
if (kLoopPlayer.isAlive())
{
func(kLoopPlayer.getGameObject());
}
}
break;
case GAMEOBJECT_CITY:
foreach(GAMEOBJECT_PLAYER, boost::bind(callForeach, _1, GAMEOBJECT_CITY, func));
break;
case GAMEOBJECT_UNIT:
foreach(GAMEOBJECT_PLAYER, boost::bind(callForeach, _1, GAMEOBJECT_UNIT, func));
break;
case GAMEOBJECT_PLOT:
for (int iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
{
func(GC.getMapINLINE().plotByIndexINLINE(iI)->getGameObject());
}
break;
case GAMEOBJECT_GAME:
func(this);
break;
}
}
// --------------------------------------------------------------------------------
// For each of n teams, let the closeness score for that team be the average distance of an edge between two players on that team.
// This function calculates the closeness score for each team and returns the sum of those n scores.
// The lower the result, the better "clumped" the players' starting locations are.
//
// Note: for the purposes of this function, player i will be assumed to start in the location of player aiStartingLocs[i]
int CvGameQueries::GetTeamClosenessScore(int** aaiDistances, int* aiStartingLocs)
{
int iScore = 0;
for(int iTeam = 0; iTeam < MAX_CIV_TEAMS; iTeam++)
{
if(GET_TEAM((TeamTypes)iTeam).isAlive())
{
int iTeamTotalDist = 0;
int iNumEdges = 0;
for(int iPlayer = 0; iPlayer < MAX_CIV_PLAYERS; iPlayer++)
{
if(GET_PLAYER((PlayerTypes)iPlayer).isAlive())
{
if(GET_PLAYER((PlayerTypes)iPlayer).getTeam() == (TeamTypes)iTeam)
{
for(int iOtherPlayer = 0; iOtherPlayer < iPlayer; iOtherPlayer++)
{
if(GET_PLAYER((PlayerTypes)iOtherPlayer).getTeam() == (TeamTypes)iTeam)
{
// Add the edge between these two players that are on the same team
iNumEdges++;
int iPlayerStart = aiStartingLocs[iPlayer];
int iOtherPlayerStart = aiStartingLocs[iOtherPlayer];
if(iPlayerStart < iOtherPlayerStart) // Make sure that iPlayerStart > iOtherPlayerStart
{
int iTemp = iPlayerStart;
iPlayerStart = iOtherPlayerStart;
iOtherPlayerStart = iTemp;
}
else if(iPlayerStart == iOtherPlayerStart)
{
CvAssertMsg(false, "Two players are (hypothetically) assigned to the same starting location!");
}
iTeamTotalDist += aaiDistances[iPlayerStart][iOtherPlayerStart];
}
}
}
}
}
int iTeamScore;
if(iNumEdges == 0)
{
iTeamScore = 0;
}
else
{
iTeamScore = iTeamTotalDist/iNumEdges; // the avg distance between team edges is the team score
}
iScore += iTeamScore;
}
}
return iScore;
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseIgnoreWarning(PlayerTypes ePlayer, TeamTypes eRivalTeam)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvTeam& kTeam = GET_TEAM(kPlayer.getTeam());
const TeamTypes eTeam = kPlayer.getTeam();
FAssert(eTeam != eRivalTeam);
kTeam.PushIgnoreWarning(eRivalTeam);
}
CvPlot* CvPlayerAI::FindBestMerchantTargetPlot(CvUnit* pGreatMerchant, bool bOnlySafePaths)
{
CvAssertMsg(pGreatMerchant, "pGreatMerchant is null");
if(!pGreatMerchant)
{
return NULL;
}
int iBestTurnsToReach = MAX_INT;
CvPlot* pBestTargetPlot = NULL;
int iPathTurns;
UnitHandle pMerchant = UnitHandle(pGreatMerchant);
CvTeam& kTeam = GET_TEAM(getTeam());
// Loop through each city state
for(int iI = 0; iI < MAX_PLAYERS; iI++)
{
CvPlayer& kPlayer = GET_PLAYER((PlayerTypes)iI);
if(kPlayer.isMinorCiv())
{
CvPlot* pCSPlot = kPlayer.getStartingPlot();
if(pCSPlot)
{
if(pCSPlot->isRevealed(getTeam()))
{
// Is this a minor we are friendly with?
if(GetDiplomacyAI()->GetMinorCivApproach(kPlayer.GetID()) != MINOR_CIV_APPROACH_CONQUEST &&
!kTeam.isAtWar(kPlayer.getTeam()) && GetDiplomacyAI()->GetWarGoal(kPlayer.GetID()) == NO_WAR_GOAL_TYPE)
{
// Search all the plots adjacent to this city (since can't enter the minor city plot itself)
for(int jJ = 0; jJ < NUM_DIRECTION_TYPES; jJ++)
{
CvPlot* pAdjacentPlot = plotDirection(pCSPlot->getX(), pCSPlot->getY(), ((DirectionTypes)jJ));
if(pAdjacentPlot != NULL)
{
// Make sure this is still owned by the city state and is revealed to us and isn't a water tile
if(pAdjacentPlot->getOwner() == (PlayerTypes)iI && pAdjacentPlot->isRevealed(getTeam())
&& !pAdjacentPlot->isWater())
{
iPathTurns = TurnsToReachTarget(pMerchant, pAdjacentPlot, true /*bReusePaths*/, !bOnlySafePaths/*bIgnoreUnits*/);
if(iPathTurns < iBestTurnsToReach)
{
iBestTurnsToReach = iPathTurns;
pBestTargetPlot = pAdjacentPlot;
}
}
}
}
}
}
}
}
}
return pBestTargetPlot;
}
bool PUF_canDeclareWar(const CvUnit* pUnit, int iData1, int iData2)
{
CvAssertMsg(iData1 != -1, "Invalid data argument, should be >= 0");
CvAssertMsg(iData2 != -1, "Invalid data argument, should be >= 0");
TeamTypes eOtherTeam = GET_PLAYER((PlayerTypes)iData1).getTeam();
TeamTypes eOurTeam = GET_PLAYER(pUnit->getCombatOwner(eOtherTeam, *(pUnit->plot()))).getTeam();
if(pUnit->canCoexistWithEnemyUnit(eOtherTeam))
{
return false;
}
#if defined(MOD_EVENTS_WAR_AND_PEACE)
return (iData2 ? false : GET_TEAM(eOtherTeam).canDeclareWar(eOurTeam, (PlayerTypes)iData1));
#else
return (iData2 ? false : GET_TEAM(eOtherTeam).canDeclareWar(eOurTeam));
#endif
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseLaunchSpaceship(PlayerTypes ePlayer, VictoryTypes eVictory)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvTeam& kTeam = GET_TEAM(kPlayer.getTeam());
if(kTeam.canLaunch(eVictory))
{
kPlayer.launch(eVictory);
}
}
void CvNetPing::Execute()
{
if (GC.getGameINLINE().getActiveTeam() != NO_TEAM)
{
if (GET_PLAYER(m_ePlayer).getTeam() == GC.getGameINLINE().getActiveTeam() || GET_TEAM(GC.getGameINLINE().getActiveTeam()).isVassal(GET_PLAYER(m_ePlayer).getTeam()) || GET_TEAM(GET_PLAYER(m_ePlayer).getTeam()).isVassal(GC.getGameINLINE().getActiveTeam()))
{
gDLL->getInterfaceIFace()->doPing(m_iX, m_iY, m_ePlayer);
}
}
}
// What percent of vassal taxes am I owed?
int CvTreasury::GetMyShareOfVassalTaxes() const
{
int iNumTeamMembers = GET_TEAM(m_pPlayer->getTeam()).getAliveCount();
if(iNumTeamMembers == 0)
return 0;
int iTotalTaxes = 0;
PlayerTypes eLoopPlayer;
for(int iPlayerLoop = 0; iPlayerLoop < MAX_MAJOR_CIVS; iPlayerLoop++)
{
eLoopPlayer = (PlayerTypes) iPlayerLoop;
if(GET_TEAM(GET_PLAYER(eLoopPlayer).getTeam()).GetMaster() == m_pPlayer->getTeam())
{
iTotalTaxes += GET_PLAYER(eLoopPlayer).GetTreasury()->GetExpensePerTurnFromVassalTaxesTimes100();
}
}
// What is my share of these taxes?
return (iTotalTaxes / iNumTeamMembers);
}
void CvNetChangeWar::Execute()
{
if (m_ePlayer != NO_PLAYER)
{
FAssert(GET_PLAYER(m_ePlayer).getTeam() != m_eRivalTeam);
if (m_bWar)
{
GET_TEAM(GET_PLAYER(m_ePlayer).getTeam()).declareWar(m_eRivalTeam, false, NO_WARPLAN);
if (gDLL->isDiplomacy() && GET_PLAYER((PlayerTypes) gDLL->getDiplomacyPlayer()).getTeam() == m_eRivalTeam)
{
gDLL->endDiplomacy();
}
}
else
{
GET_TEAM(GET_PLAYER(m_ePlayer).getTeam()).makePeace(m_eRivalTeam);
}
}
}
void CvGameAI::AI_updateAssignWork()
{
int iI;
for (iI = 0; iI < MAX_PLAYERS; iI++)
{
CvPlayer& kLoopPlayer = GET_PLAYER((PlayerTypes)iI);
if (GET_TEAM(kLoopPlayer.getTeam()).isHuman() && kLoopPlayer.isAlive())
{
kLoopPlayer.AI_updateAssignWork();
}
}
}
void CvNetResearch::Execute()
{
if (m_ePlayer != NO_PLAYER)
{
CvPlayer& kPlayer = GET_PLAYER(m_ePlayer);
if (m_iDiscover > 0)
{
GET_TEAM(kPlayer.getTeam()).setHasTech(m_eTech, true, m_ePlayer, true, true);
if (m_iDiscover > 1)
{
if (m_ePlayer == GC.getGameINLINE().getActivePlayer())
{
kPlayer.chooseTech(m_iDiscover - 1);
}
}
}
else
{
if (m_eTech == NO_TECH)
{
kPlayer.clearResearchQueue();
}
else if (kPlayer.canEverResearch(m_eTech))
{
if ((GET_TEAM(kPlayer.getTeam()).isHasTech(m_eTech) || kPlayer.isResearchingTech(m_eTech)) && !m_bShift)
{
kPlayer.clearResearchQueue();
}
kPlayer.pushResearch(m_eTech, !m_bShift);
}
}
if (GC.getGameINLINE().getActivePlayer() == m_ePlayer)
{
gDLL->getInterfaceIFace()->updatePythonScreens();
}
}
}
/// Guess as to how much another Player is prioritizing the UN as his means of winning the game
int CvGrandStrategyAI::GetGuessOtherPlayerUnitedNationsPriority(PlayerTypes ePlayer)
{
VictoryTypes eVictory = (VictoryTypes) GC.getInfoTypeForString("VICTORY_DIPLOMATIC", true);
// If UN Victory isn't even available then don't bother with anything
if(eVictory == NO_VICTORY)
{
return -100;
}
TeamTypes eTeam = GET_PLAYER(ePlayer).getTeam();
int iVotesNeededToWin = GC.getGame().GetVotesNeededForDiploVictory();
int iSecuredVotes = 0;
// Loop through Players to see if they'll vote for this player
PlayerTypes eLoopPlayer;
TeamTypes eLoopTeam;
for(int iPlayerLoop = 0; iPlayerLoop < MAX_CIV_PLAYERS; iPlayerLoop++)
{
eLoopPlayer = (PlayerTypes) iPlayerLoop;
if(GET_PLAYER(eLoopPlayer).isAlive())
{
eLoopTeam = GET_PLAYER(eLoopPlayer).getTeam();
// Liberated?
if(GET_TEAM(eLoopTeam).GetLiberatedByTeam() == eTeam)
{
iSecuredVotes++;
}
// Minor civ?
else if(GET_PLAYER(eLoopPlayer).isMinorCiv())
{
// Best Relations?
if(GET_PLAYER(eLoopPlayer).GetMinorCivAI()->GetAlly() == ePlayer)
{
iSecuredVotes++;
}
}
}
}
int iUNPriority = iSecuredVotes* /*300*/ GC.getAI_GS_UN_SECURED_VOTE_MOD();
iUNPriority /= iVotesNeededToWin;
return iUNPriority;
}
// Returns ratio of strengths of stacks times 100
// (so 100 is even ratio, numbers over 100 mean this group is more powerful than the stack on a plot)
int CvSelectionGroupAI::AI_compareStacks(const CvPlot* pPlot, bool bCheckCanAttack) const
{
FAssert(pPlot != NULL);
int compareRatio;
DomainTypes eDomainType = getDomainType();
// if not aircraft, then choose based on the plot, not the head unit (mainly for transport carried units)
if (eDomainType != DOMAIN_AIR)
{
if (pPlot->isWater())
eDomainType = DOMAIN_SEA;
else
eDomainType = DOMAIN_LAND;
}
compareRatio = AI_sumStrength(pPlot, eDomainType, bCheckCanAttack);
compareRatio *= 100;
PlayerTypes eOwner = getOwnerINLINE();
if (eOwner == NO_PLAYER)
{
eOwner = getHeadOwner();
}
FAssert(eOwner != NO_PLAYER);
// K-Mod. Note. This function currently does not support bPotentialEnemy == false.
//FAssert(bPotentialEnemy);
int defenderSum = pPlot->isVisible(getHeadTeam(), false)
? GET_PLAYER(eOwner).AI_localDefenceStrength(pPlot, NO_TEAM, eDomainType, 0)
: GET_TEAM(getHeadTeam()).AI_getStrengthMemory(pPlot);
// K-Mod end
compareRatio /= std::max(1, defenderSum);
// K-Mod. If there are more defenders than we have attacks, but yet the ratio is still greater than 100,
// then inflate the ratio futher to account for the fact that we are going to do significantly more damage to them than they to us.
// The purpose of this is to give the AI extra encouragement to attack when its units are better than the defender's units.
/* if (compareRatio > 100)
{
FAssert(getHeadUnit() && getNumUnits() > 0);
int iDefenders = pPlot->getNumVisibleEnemyDefenders(getHeadUnit());
if (iDefenders > getNumUnits())
{
compareRatio += (compareRatio - 100) * (iDefenders - getNumUnits()) / getNumUnits();
}
} */ // (currently disabled)
// K-Mod end
return compareRatio;
}
CyTeam* CyGlobalContext::getCyTeam(int i)
{
static CyTeam cyTeams[MAX_TEAMS];
static bool bInit=false;
if (!bInit)
{
int j;
for(j=0;j<MAX_TEAMS;j++)
{
cyTeams[j]=CyTeam(&GET_TEAM((TeamTypes)j));
}
bInit = true;
}
return i<MAX_TEAMS ? &cyTeams[i] : NULL;
}
int team_winning(t_user *usr, t_team *team)
{
t_user *tmp;
tmp = usr;
while (tmp != NULL && tmp->prev != NULL)
tmp = tmp->prev;
while (tmp != NULL)
{
if (tmp->type == AI && GET_TEAM(tmp) == team && GET_LVL(tmp) == 8)
return (1);
tmp = tmp->next;
}
return (0);
}
