/// Calculate military presences in each owned dominance zone
void CvTacticalAnalysisMap::CalculateMilitaryStrengths()
{
// Loop through the dominance zones
CvTacticalDominanceZone* pZone;
CvCity* pClosestCity = NULL;
int iDistance;
int iMultiplier;
int iLoop;
CvUnit* pLoopUnit;
TeamTypes eTeam;
eTeam = m_pPlayer->getTeam();
for(unsigned int iI = 0; iI < m_DominanceZones.size(); iI++)
{
pZone = &m_DominanceZones[iI];
if(pZone->GetTerritoryType() != TACTICAL_TERRITORY_NO_OWNER)
{
pClosestCity = pZone->GetClosestCity();
if(pClosestCity)
{
// Start with strength of the city itself
int iCityHitPoints = pClosestCity->GetMaxHitPoints() - pClosestCity->getDamage();
int iStrength = m_iTacticalRange * pClosestCity->getStrengthValue() * iCityHitPoints / GC.getMAX_CITY_HIT_POINTS();
if(pZone->GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
pZone->AddFriendlyStrength(iStrength);
#if defined(MOD_AI_SMART_V3)
pZone->AddFriendlyRangedStrength(pClosestCity->getStrengthValue(MOD_AI_SMART_V3));
#else
pZone->AddFriendlyRangedStrength(pClosestCity->getStrengthValue());
#endif
}
#if defined(MOD_AI_SMART_V3)
else if(!MOD_AI_SMART_V3 || pZone->GetTerritoryType() == TACTICAL_TERRITORY_ENEMY)
#else
else
#endif
{
pZone->AddEnemyStrength(iStrength);
#if defined(MOD_AI_SMART_V3)
pZone->AddEnemyRangedStrength(pClosestCity->getStrengthValue(MOD_AI_SMART_V3));
#else
pZone->AddEnemyRangedStrength(pClosestCity->getStrengthValue());
#endif
}
// Loop through all of OUR units first
for(pLoopUnit = m_pPlayer->firstUnit(&iLoop); pLoopUnit != NULL; pLoopUnit = m_pPlayer->nextUnit(&iLoop))
{
if(pLoopUnit->IsCombatUnit())
{
if(pLoopUnit->getDomainType() == DOMAIN_AIR ||
#if defined(MOD_AI_SMART_V3)
//ranged power is cross-domain!
(MOD_AI_SMART_V3 && pLoopUnit->isRanged()) ||
#endif
(pLoopUnit->getDomainType() == DOMAIN_LAND && !pZone->IsWater()) ||
(pLoopUnit->getDomainType() == DOMAIN_SEA && pZone->IsWater()))
{
iDistance = plotDistance(pLoopUnit->getX(), pLoopUnit->getY(), pClosestCity->getX(), pClosestCity->getY());
if (iDistance <= m_iTacticalRange)
{
#if defined(MOD_AI_SMART_V3)
int iRange = MOD_AI_SMART_V3 ? MIN(4 - iDistance, 0) : 4 - iDistance;
iMultiplier = m_iTacticalRange + iRange;
#else
iMultiplier = (m_iTacticalRange + 4 - iDistance); // "4" so unit strength isn't totally dominated by proximity to city
#endif
if(iMultiplier > 0)
{
int iUnitStrength = pLoopUnit->GetBaseCombatStrengthConsideringDamage();
if(iUnitStrength == 0 && pLoopUnit->isEmbarked() && !pZone->IsWater())
{
iUnitStrength = pLoopUnit->GetBaseCombatStrength(true);
}
pZone->AddFriendlyStrength(iUnitStrength * iMultiplier * m_iUnitStrengthMultiplier);
pZone->AddFriendlyRangedStrength(pLoopUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true));
if(pLoopUnit->GetRange() > GetBestFriendlyRange())
{
SetBestFriendlyRange(pLoopUnit->GetRange());
}
if(pLoopUnit->IsRangeAttackIgnoreLOS())
{
SetIgnoreLOS(true);
}
pZone->AddFriendlyUnitCount(1);
if(pLoopUnit->isRanged())
{
pZone->AddFriendlyRangedUnitCount(1);
}
}
}
}
}
}
// Repeat for all visible enemy units (or adjacent to visible)
for(int iPlayerLoop = 0; iPlayerLoop < MAX_CIV_PLAYERS; iPlayerLoop++)
{
CvPlayer& kPlayer = GET_PLAYER((PlayerTypes) iPlayerLoop);
if(GET_TEAM(eTeam).isAtWar(kPlayer.getTeam()))
{
for(pLoopUnit = kPlayer.firstUnit(&iLoop); pLoopUnit != NULL; pLoopUnit = kPlayer.nextUnit(&iLoop))
{
if(pLoopUnit->IsCombatUnit())
{
if(pLoopUnit->getDomainType() == DOMAIN_AIR ||
#if defined(MOD_AI_SMART_V3)
//ranged power is cross-domain!
(MOD_AI_SMART_V3 && pLoopUnit->isRanged()) ||
#endif
(pLoopUnit->getDomainType() == DOMAIN_LAND && !pZone->IsWater()) ||
(pLoopUnit->getDomainType() == DOMAIN_SEA && pZone->IsWater()))
{
CvPlot* pPlot;
pPlot = pLoopUnit->plot();
if(pPlot)
{
bool bVisible = true;
iDistance = plotDistance(pLoopUnit->getX(), pLoopUnit->getY(), pClosestCity->getX(), pClosestCity->getY());
if (iDistance <= m_iTacticalRange)
{
#if defined(MOD_AI_SMART_V3)
int iRange = MOD_AI_SMART_V3 ? MIN(4 - iDistance, 0) : 4 - iDistance;
iMultiplier = m_iTacticalRange + iRange; // 4 because action may still be spread out over the zone
#else
iMultiplier = (m_iTacticalRange + 4 - iDistance); // "4" so unit strength isn't totally dominated by proximity to city
#endif
if(!pPlot->isVisible(eTeam) && !pPlot->isAdjacentVisible(eTeam, false))
{
bVisible = false;
}
if(iMultiplier > 0)
{
int iUnitStrength = pLoopUnit->GetBaseCombatStrengthConsideringDamage();
if(iUnitStrength == 0 && pLoopUnit->isEmbarked() && !pZone->IsWater())
{
iUnitStrength = pLoopUnit->GetBaseCombatStrength(true);
}
if(!bVisible)
{
iUnitStrength /= 2;
}
pZone->AddEnemyStrength(iUnitStrength * iMultiplier * m_iUnitStrengthMultiplier);
int iRangedStrength = pLoopUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true);
if(!bVisible)
{
iRangedStrength /= 2;
}
pZone->AddEnemyRangedStrength(iRangedStrength);
if(bVisible)
{
pZone->AddEnemyUnitCount(1);
if(iDistance < pZone->GetRangeClosestEnemyUnit())
{
pZone->SetRangeClosestEnemyUnit(iDistance);
}
if(pLoopUnit->isRanged())
{
pZone->AddEnemyRangedUnitCount(1);
}
if(pLoopUnit->getDomainType() == DOMAIN_SEA)
{
pZone->AddEnemyNavalUnitCount(1);
}
}
}
}
}
}
}
}
}
}
}
}
}
/// Updates the danger plots values to reflect threats across the map
void CvDangerPlots::UpdateDanger (bool bPretendWarWithAllCivs, bool bIgnoreVisibility)
{
// danger plots have not been initialized yet, so no need to update
if (!m_bArrayAllocated)
{
return;
}
// wipe out values
int iGridSize = GC.getMap().numPlots();
CvAssertMsg(iGridSize == m_DangerPlots.size(), "iGridSize does not match number of DangerPlots");
for (int i = 0; i < iGridSize; i++)
{
m_DangerPlots[i] = 0;
}
CvPlayer& thisPlayer = GET_PLAYER(m_ePlayer);
TeamTypes thisTeam = thisPlayer.getTeam();
// for each opposing civ
for (int iPlayer = 0; iPlayer < MAX_PLAYERS; iPlayer++)
{
PlayerTypes ePlayer = (PlayerTypes)iPlayer;
CvPlayer& loopPlayer = GET_PLAYER(ePlayer);
TeamTypes eTeam = loopPlayer.getTeam();
if (!loopPlayer.isAlive())
{
continue;
}
if (eTeam == thisTeam)
{
continue;
}
if (ShouldIgnorePlayer(ePlayer) && !bPretendWarWithAllCivs)
{
continue;
}
//for each unit
int iLoop;
CvUnit* pLoopUnit = NULL;
for (pLoopUnit = loopPlayer.firstUnit(&iLoop); pLoopUnit != NULL; pLoopUnit = loopPlayer.nextUnit(&iLoop))
{
if (ShouldIgnoreUnit(pLoopUnit, bIgnoreVisibility))
{
continue;
}
int iRange = pLoopUnit->baseMoves();
if (pLoopUnit->canRangeStrike())
{
iRange += pLoopUnit->GetRange();
}
CvPlot* pUnitPlot = pLoopUnit->plot();
AssignUnitDangerValue(pLoopUnit, pUnitPlot);
CvPlot* pLoopPlot = NULL;
for (int iDX = -(iRange); iDX <= iRange; iDX++)
{
for (int iDY = -(iRange); iDY <= iRange; iDY++)
{
pLoopPlot = plotXYWithRangeCheck(pUnitPlot->getX(), pUnitPlot->getY(), iDX, iDY, iRange);
if (!pLoopPlot || pLoopPlot == pUnitPlot)
{
continue;
}
if (!pLoopUnit->canMoveOrAttackInto(*pLoopPlot) && !pLoopUnit->canRangeStrikeAt(pLoopPlot->getX(),pLoopPlot->getY()))
{
continue;
}
AssignUnitDangerValue(pLoopUnit, pLoopPlot);
}
}
}
// for each city
CvCity* pLoopCity;
for (pLoopCity = loopPlayer.firstCity(&iLoop); pLoopCity != NULL; pLoopCity = loopPlayer.nextCity(&iLoop))
{
if (ShouldIgnoreCity(pLoopCity, bIgnoreVisibility))
{
continue;
}
int iRange = GC.getCITY_ATTACK_RANGE();
CvPlot* pCityPlot = pLoopCity->plot();
AssignCityDangerValue(pLoopCity, pCityPlot);
CvPlot* pLoopPlot = NULL;
for (int iDX = -(iRange); iDX <= iRange; iDX++)
{
for (int iDY = -(iRange); iDY <= iRange; iDY++)
{
pLoopPlot = plotXYWithRangeCheck(pCityPlot->getX(), pCityPlot->getY(), iDX, iDY, iRange);
if (!pLoopPlot)
{
continue;
}
AssignCityDangerValue(pLoopCity, pLoopPlot);
}
}
}
}
// Citadels
int iCitadelValue = GetDangerValueOfCitadel();
int iPlotLoop;
CvPlot *pPlot, *pAdjacentPlot;
for (iPlotLoop = 0; iPlotLoop < GC.getMap().numPlots(); iPlotLoop++)
{
pPlot = GC.getMap().plotByIndexUnchecked(iPlotLoop);
if (pPlot->isRevealed(thisTeam))
{
ImprovementTypes eImprovement = pPlot->getRevealedImprovementType(thisTeam);
if (eImprovement != NO_IMPROVEMENT && GC.getImprovementInfo(eImprovement)->GetNearbyEnemyDamage() > 0)
{
if (!ShouldIgnoreCitadel(pPlot, bIgnoreVisibility))
{
for (int iI = 0; iI < NUM_DIRECTION_TYPES; iI++)
{
pAdjacentPlot = plotDirection(pPlot->getX(), pPlot->getY(), ((DirectionTypes)iI));
if (pAdjacentPlot != NULL)
{
AddDanger(pAdjacentPlot->getX(), pAdjacentPlot->getY(), iCitadelValue);
}
}
}
}
}
}
// testing city danger values
CvCity* pLoopCity;
int iLoopCity = 0;
for (pLoopCity = thisPlayer.firstCity(&iLoopCity); pLoopCity != NULL; pLoopCity = thisPlayer.nextCity(&iLoopCity))
{
int iThreatValue = GetCityDanger(pLoopCity);
pLoopCity->SetThreatValue(iThreatValue);
}
m_bDirty = false;
}
/// Add data for this cell into dominance zone information
void CvTacticalAnalysisMap::AddToDominanceZones(int iIndex, CvTacticalAnalysisCell* pCell)
{
CvPlot* pPlot = GC.getMap().plotByIndex(iIndex);
// Compute zone data for this cell
m_TempZone.SetAreaID(pPlot->getArea());
m_TempZone.SetOwner(pPlot->getOwner());
m_TempZone.SetWater(pPlot->isWater());
if(!pPlot->isOwned())
{
m_TempZone.SetTerritoryType(TACTICAL_TERRITORY_NO_OWNER);
}
else if(pPlot->getTeam() == m_pPlayer->getTeam())
{
m_TempZone.SetTerritoryType(TACTICAL_TERRITORY_FRIENDLY);
}
else if(GET_TEAM(m_pPlayer->getTeam()).isAtWar(pPlot->getTeam()))
{
m_TempZone.SetTerritoryType(TACTICAL_TERRITORY_ENEMY);
}
else
{
m_TempZone.SetTerritoryType(TACTICAL_TERRITORY_NEUTRAL);
}
m_TempZone.SetClosestCity(NULL);
if(m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_ENEMY ||
m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_NEUTRAL ||
m_TempZone.GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
int iLoop;
int iBestDistance = MAX_INT;
CvCity* pBestCity = NULL;
for(CvCity* pLoopCity = GET_PLAYER(m_TempZone.GetOwner()).firstCity(&iLoop); pLoopCity != NULL; pLoopCity = GET_PLAYER(m_TempZone.GetOwner()).nextCity(&iLoop))
{
int iDistance = plotDistance(pLoopCity->getX(), pLoopCity->getY(), pPlot->getX(), pPlot->getY());
if(iDistance < iBestDistance)
{
iBestDistance = iDistance;
pBestCity = pLoopCity;
}
}
if(pBestCity != NULL)
{
m_TempZone.SetClosestCity(pBestCity);
}
}
// Now see if we already have a matching zone
CvTacticalDominanceZone* pZone = FindExistingZone(pPlot);
if(!pZone)
{
// Data populated, now add to vector
m_TempZone.SetDominanceZoneID(m_DominanceZones.size());
m_DominanceZones.push_back(m_TempZone);
pZone = &m_DominanceZones[m_DominanceZones.size() - 1];
}
// If this isn't owned territory, update zone with military strength info
if(pZone->GetTerritoryType() == TACTICAL_TERRITORY_NO_OWNER ||
pZone->GetTerritoryType() == TACTICAL_TERRITORY_TEMP_ZONE)
{
CvUnit* pFriendlyUnit = pCell->GetFriendlyMilitaryUnit();
if(pFriendlyUnit)
{
if(pFriendlyUnit->getDomainType() == DOMAIN_AIR ||
(pFriendlyUnit->getDomainType() == DOMAIN_LAND && !pZone->IsWater()) ||
(pFriendlyUnit->getDomainType() == DOMAIN_SEA && pZone->IsWater()))
{
int iStrength = pFriendlyUnit->GetBaseCombatStrengthConsideringDamage();
if(iStrength == 0 && pFriendlyUnit->isEmbarked() && !pZone->IsWater())
{
iStrength = pFriendlyUnit->GetBaseCombatStrength(true);
}
pZone->AddFriendlyStrength(iStrength * m_iUnitStrengthMultiplier);
pZone->AddFriendlyRangedStrength(pFriendlyUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true));
if(pFriendlyUnit->GetRange() > GetBestFriendlyRange())
{
SetBestFriendlyRange(pFriendlyUnit->GetRange());
}
if(pFriendlyUnit->IsRangeAttackIgnoreLOS())
{
SetIgnoreLOS(true);
}
pZone->AddFriendlyUnitCount(1);
if(pFriendlyUnit->isRanged())
{
pZone->AddFriendlyRangedUnitCount(1);
}
}
}
CvUnit* pEnemyUnit = pCell->GetEnemyMilitaryUnit();
if(pEnemyUnit)
{
if(pEnemyUnit->getDomainType() == DOMAIN_AIR ||
(pEnemyUnit->getDomainType() == DOMAIN_LAND && !pZone->IsWater()) ||
(pEnemyUnit->getDomainType() == DOMAIN_SEA && pZone->IsWater()))
{
int iStrength = pEnemyUnit->GetBaseCombatStrengthConsideringDamage();
if(iStrength == 0 && pEnemyUnit->isEmbarked() && !pZone->IsWater())
{
iStrength = pEnemyUnit->GetBaseCombatStrength(true);
}
#if defined(MOD_AI_SMART_V3)
int iEnemyRangedStrength = pEnemyUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true);
if (MOD_AI_SMART_V3)
{
if (!pCell->IsVisible())
{
iStrength /= 2;
iEnemyRangedStrength /= 2;
}
iEnemyRangedStrength = iEnemyRangedStrength * m_iUnitStrengthMultiplier;
}
#endif
pZone->AddEnemyStrength(iStrength * m_iUnitStrengthMultiplier);
#if defined(MOD_AI_SMART_V3)
pZone->AddEnemyRangedStrength(iEnemyRangedStrength);
#else
pZone->AddEnemyRangedStrength(pEnemyUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true));
#endif
pZone->AddEnemyUnitCount(1);
if(pEnemyUnit->isRanged())
{
pZone->AddEnemyRangedUnitCount(1);
}
if (pEnemyUnit->getDomainType() == DOMAIN_SEA)
{
pZone->AddEnemyNavalUnitCount(1);
}
}
}
}
// Set zone for this cell
pCell->SetDominanceZone(pZone->GetDominanceZoneID());
}