// --------------------------------------------------------------------------------
bool CvUnitMovement::IsSlowedByZOC(const CvUnit* pUnit, const CvPlot* pFromPlot, const CvPlot* pToPlot)
{
if (pUnit->IsIgnoreZOC())
return false;
// Zone of Control
if(GC.getZONE_OF_CONTROL_ENABLED() <= 0)
return false;
TeamTypes eUnitTeam = pUnit->getTeam();
DomainTypes eUnitDomain = pUnit->getDomainType();
CvTeam& kUnitTeam = GET_TEAM(eUnitTeam);
//there are only two plots we need to check
DirectionTypes moveDir = directionXY(pFromPlot,pToPlot);
int eRight = (int(moveDir) + 1) % 6;
int eLeft = (int(moveDir) + 5) % 6;
CvPlot* aPlotsToCheck[2];
aPlotsToCheck[0] = plotDirection(pFromPlot->getX(),pFromPlot->getY(),(DirectionTypes)eRight);
aPlotsToCheck[1] = plotDirection(pFromPlot->getX(),pFromPlot->getY(),(DirectionTypes)eLeft);
for (int iCount=0; iCount<2; iCount++)
{
CvPlot* pAdjPlot = aPlotsToCheck[iCount];
if(!pAdjPlot)
continue;
// check city zone of control
if(pAdjPlot->isEnemyCity(*pUnit))
return true;
// Loop through all units to see if there's an enemy unit here
IDInfo* pAdjUnitNode = pAdjPlot->headUnitNode();
while(pAdjUnitNode != NULL)
{
CvUnit* pLoopUnit = NULL;
if((pAdjUnitNode->eOwner >= 0) && pAdjUnitNode->eOwner < MAX_PLAYERS)
pLoopUnit = (GET_PLAYER(pAdjUnitNode->eOwner).getUnit(pAdjUnitNode->iID));
pAdjUnitNode = pAdjPlot->nextUnitNode(pAdjUnitNode);
if(!pLoopUnit)
continue;
if(pLoopUnit->isInvisible(eUnitTeam,false))
continue;
// Combat unit?
if(!pLoopUnit->IsCombatUnit())
continue;
// Embarked units don't have ZOC
if(pLoopUnit->isEmbarked())
continue;
// At war with this unit's team?
TeamTypes eLoopUnitTeam = pLoopUnit->getTeam();
if(eLoopUnitTeam == BARBARIAN_TEAM || kUnitTeam.isAtWar(eLoopUnitTeam) || pLoopUnit->isAlwaysHostile(*pAdjPlot) )
{
// Same Domain?
DomainTypes eLoopUnitDomain = pLoopUnit->getDomainType();
if(eLoopUnitDomain != eUnitDomain)
{
// hovering units always exert a ZOC
if (pLoopUnit->IsHoveringUnit() || eLoopUnitDomain==DOMAIN_HOVER)
{
// continue on
}
// water unit can ZoC embarked land unit
else if(eLoopUnitDomain == DOMAIN_SEA && (pToPlot->needsEmbarkation(pUnit) || pFromPlot->needsEmbarkation(pUnit)) )
{
// continue on
}
else
{
// ignore this unit
continue;
}
}
else
{
//land units don't ZoC embarked units (if they stay embarked)
if(eLoopUnitDomain == DOMAIN_LAND && pToPlot->needsEmbarkation(pUnit) && pFromPlot->needsEmbarkation(pUnit))
{
continue;
}
}
//ok, all conditions fulfilled
return true;
}
}
}
return false;
}
/// Calculate military presences in each owned dominance zone
void CvTacticalAnalysisMap::CalculateMilitaryStrengths()
{
TeamTypes eTeam = GET_PLAYER(m_ePlayer).getTeam();
// Loop through the dominance zones
for(unsigned int iI = 0; iI < m_DominanceZones.size(); iI++)
{
CvTacticalDominanceZone* pZone = &m_DominanceZones[iI];
CvCity *pClosestCity = pZone->GetZoneCity();
if(pClosestCity)
{
// Start with strength of the city itself
int iCityHitPoints = pClosestCity->GetMaxHitPoints() - pClosestCity->getDamage();
int iStrength = pClosestCity->getStrengthValue() * iCityHitPoints / GC.getMAX_CITY_HIT_POINTS();
if(pZone->GetTerritoryType() == TACTICAL_TERRITORY_FRIENDLY)
{
pZone->AddFriendlyMeleeStrength(iStrength);
pZone->AddFriendlyRangedStrength(pClosestCity->getStrengthValue(true));
}
else if(pZone->GetTerritoryType() == TACTICAL_TERRITORY_ENEMY)
{
pZone->AddEnemyMeleeStrength(iStrength);
pZone->AddEnemyRangedStrength(pClosestCity->getStrengthValue(true));
}
else
{
pZone->AddNeutralStrength(iStrength);
}
}
// check all units in the world
for(int iPlayerLoop = 0; iPlayerLoop < MAX_PLAYERS; iPlayerLoop++)
{
CvPlayer& kPlayer = GET_PLAYER((PlayerTypes) iPlayerLoop);
bool bEnemy = GET_TEAM(eTeam).isAtWar(kPlayer.getTeam());
bool bFriendly = (eTeam==kPlayer.getTeam());
int iLoop;
for(CvUnit* pLoopUnit = kPlayer.firstUnit(&iLoop); pLoopUnit != NULL; pLoopUnit = kPlayer.nextUnit(&iLoop))
{
if(!pLoopUnit->IsCombatUnit())
continue;
bool bUnitMayBeRelevant = (pLoopUnit->getDomainType() == DOMAIN_AIR ||
pLoopUnit->isRanged() || //ranged power is cross-domain!
(pLoopUnit->getDomainType() == DOMAIN_LAND && !pZone->IsWater()) ||
((pLoopUnit->getDomainType() == DOMAIN_SEA || (pLoopUnit->isEmbarked() && pClosestCity) && pZone->IsWater())));
//embarked melee still count in water zone if there's a city to attack/defend
if (!bUnitMayBeRelevant)
continue;
CvPlot* pPlot = pLoopUnit->plot();
if(!pPlot)
continue;
//a little cheating for AI - invisible units still count with reduced strength
bool bVisible = pPlot->isVisible(eTeam) || pPlot->isAdjacentVisible(eTeam, false);
bool bZoneTypeMismatch = (pLoopUnit->getDomainType() == DOMAIN_LAND && pZone->IsWater()) || (pLoopUnit->getDomainType() == DOMAIN_SEA && !pZone->IsWater());
//embarked units and crossdomain count only partially
bool bReducedStrength = pLoopUnit->isEmbarked() || bZoneTypeMismatch;
//if there is a city, units in adjacent zones can also count
int iDistance = 0;
if (pClosestCity)
{
iDistance = plotDistance(pLoopUnit->getX(), pLoopUnit->getY(), pClosestCity->getX(), pClosestCity->getY());
if (iDistance > m_iTacticalRange)
continue;
else if (iDistance > (m_iTacticalRange / 2))
{
if (bZoneTypeMismatch)
continue;
else
bReducedStrength = true;
}
else
{
//if on another continent, they can't easily take part in the fight
if (!pClosestCity->isMatchingArea(pLoopUnit->plot()))
bReducedStrength = true;
}
}
else
{
//if there is no city, the unit must be in the zone itself
if ( GetCell(pLoopUnit->plot()->GetPlotIndex())->GetDominanceZone() != pZone->GetDominanceZoneID() )
continue;
}
int iMultiplier = m_iTacticalRange + MIN(3 - iDistance, 0); // 3 because action may still be spread out over the zone
if(iMultiplier > 0)
{
int iUnitStrength = pLoopUnit->GetBaseCombatStrengthConsideringDamage();
//unit might disembark ... so don't count it for water zone, but for adjacent land
if(iUnitStrength == 0 && pLoopUnit->isEmbarked() && !pZone->IsWater())
iUnitStrength = pLoopUnit->GetBaseCombatStrength();
int iRangedStrength = pLoopUnit->GetMaxRangedCombatStrength(NULL, /*pCity*/ NULL, true, true) / 100;
if(!bVisible || bReducedStrength)
{
iUnitStrength /= 2;
iRangedStrength /= 2;
}
if (bEnemy)
{
#if defined(MOD_BALANCE_CORE_MILITARY_LOGGING)
//CvString msg;
//msg.Format("Zone %d, Enemy %s %d with %d hp at %d,%d - distance %d, strength %d, ranged strength %d (total %d)",
// pZone->GetDominanceZoneID(), pLoopUnit->getName().c_str(), pLoopUnit->GetID(), pLoopUnit->GetCurrHitPoints(),
// pLoopUnit->getX(), pLoopUnit->getY(), iDistance, iUnitStrength, iRangedStrength, pZone->GetOverallEnemyStrength());
//GET_PLAYER(m_ePlayer).GetTacticalAI()->LogTacticalMessage(msg, true /*bSkipLogDominanceZone*/);
#endif
if (pLoopUnit->getDomainType() == DOMAIN_SEA)
{
pZone->AddEnemyNavalStrength(iUnitStrength*iMultiplier*m_iUnitStrengthMultiplier);
pZone->AddEnemyNavalRangedStrength(iRangedStrength*iMultiplier*m_iUnitStrengthMultiplier);
pZone->AddEnemyNavalUnitCount(1);
}
else
{
pZone->AddEnemyMeleeStrength(iUnitStrength*iMultiplier*m_iUnitStrengthMultiplier);
pZone->AddEnemyRangedStrength(iRangedStrength*iMultiplier*m_iUnitStrengthMultiplier);
pZone->AddEnemyUnitCount(1);
}
//again only for enemies
if(pZone->GetRangeClosestEnemyUnit()<0 || iDistance<pZone->GetRangeClosestEnemyUnit())
pZone->SetRangeClosestEnemyUnit(iDistance);
}
else if (bFriendly)
{
#if defined(MOD_BALANCE_CORE_MILITARY_LOGGING)
//CvString msg;
//msg.Format("Zone %d, Friendly %s %d with %d hp at %d,%d - distance %d, strength %d, ranged strength %d (total %d)",
// pZone->GetDominanceZoneID(), pLoopUnit->getName().c_str(), pLoopUnit->GetID(), pLoopUnit->GetCurrHitPoints(),
// pLoopUnit->getX(), pLoopUnit->getY(), iDistance, iUnitStrength, iRangedStrength, pZone->GetOverallFriendlyStrength());
//GET_PLAYER(m_ePlayer).GetTacticalAI()->LogTacticalMessage(msg, true /*bSkipLogDominanceZone*/);
#endif
if (pLoopUnit->getDomainType() == DOMAIN_SEA)
{
pZone->AddFriendlyNavalStrength(iUnitStrength*iMultiplier*m_iUnitStrengthMultiplier);
pZone->AddFriendlyNavalRangedStrength(iRangedStrength*iMultiplier*m_iUnitStrengthMultiplier);
pZone->AddFriendlyNavalUnitCount(1);
}
else
{
pZone->AddFriendlyMeleeStrength(iUnitStrength*iMultiplier*m_iUnitStrengthMultiplier);
pZone->AddFriendlyRangedStrength(iRangedStrength*iMultiplier*m_iUnitStrengthMultiplier);
pZone->AddFriendlyUnitCount(1);
}
}
else
{
//neutral has only very few stats
pZone->AddNeutralStrength(iUnitStrength*iMultiplier*m_iUnitStrengthMultiplier);
pZone->AddNeutralUnitCount(1);
}
}
}
}
}
}
/// 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);
}
}
}
}
}
}
}
}
}
}
}
}
}
// --------------------------------------------------------------------------------
bool CvUnitMovement::IsSlowedByZOC(const CvUnit* pUnit, const CvPlot* pFromPlot, const CvPlot* pToPlot)
{
if (pUnit->IsIgnoreZOC() || CostsOnlyOne(pUnit, pFromPlot, pToPlot))
{
return false;
}
// Zone of Control
if(GC.getZONE_OF_CONTROL_ENABLED() > 0)
{
IDInfo* pAdjUnitNode;
CvUnit* pLoopUnit;
int iFromPlotX = pFromPlot->getX();
int iFromPlotY = pFromPlot->getY();
int iToPlotX = pToPlot->getX();
int iToPlotY = pToPlot->getY();
TeamTypes unit_team_type = pUnit->getTeam();
DomainTypes unit_domain_type = pUnit->getDomainType();
bool bIsVisibleEnemyUnit = pToPlot->isVisibleEnemyUnit(pUnit);
CvTeam& kUnitTeam = GET_TEAM(unit_team_type);
for(int iDirection0 = 0; iDirection0 < NUM_DIRECTION_TYPES; iDirection0++)
{
CvPlot* pAdjPlot = plotDirection(iFromPlotX, iFromPlotY, ((DirectionTypes)iDirection0));
if(NULL != pAdjPlot)
{
// check city zone of control
if(pAdjPlot->isEnemyCity(*pUnit))
{
// Loop through plots adjacent to the enemy city and see if it's the same as our unit's Destination Plot
for(int iDirection = 0; iDirection < NUM_DIRECTION_TYPES; iDirection++)
{
CvPlot* pEnemyAdjPlot = plotDirection(pAdjPlot->getX(), pAdjPlot->getY(), ((DirectionTypes)iDirection));
if(NULL != pEnemyAdjPlot)
{
// Destination adjacent to enemy city?
if(pEnemyAdjPlot->getX() == iToPlotX && pEnemyAdjPlot->getY() == iToPlotY)
{
return true;
}
}
}
}
pAdjUnitNode = pAdjPlot->headUnitNode();
// Loop through all units to see if there's an enemy unit here
while(pAdjUnitNode != NULL)
{
if((pAdjUnitNode->eOwner >= 0) && pAdjUnitNode->eOwner < MAX_PLAYERS)
{
pLoopUnit = (GET_PLAYER(pAdjUnitNode->eOwner).getUnit(pAdjUnitNode->iID));
}
else
{
pLoopUnit = NULL;
}
pAdjUnitNode = pAdjPlot->nextUnitNode(pAdjUnitNode);
if(!pLoopUnit) continue;
TeamTypes unit_loop_team_type = pLoopUnit->getTeam();
if(pLoopUnit->isInvisible(unit_team_type,false)) continue;
// Combat unit?
if(!pLoopUnit->IsCombatUnit())
{
continue;
}
// At war with this unit's team?
if(unit_loop_team_type == BARBARIAN_TEAM || kUnitTeam.isAtWar(unit_loop_team_type))
{
// Same Domain?
DomainTypes loop_unit_domain_type = pLoopUnit->getDomainType();
if(loop_unit_domain_type != unit_domain_type)
{
// this is valid
if(loop_unit_domain_type == DOMAIN_SEA && unit_domain_type)
{
// continue on
}
else
{
continue;
}
}
// Embarked?
if(unit_domain_type == DOMAIN_LAND && pLoopUnit->isEmbarked())
{
continue;
}
// Loop through plots adjacent to the enemy unit and see if it's the same as our unit's Destination Plot
for(int iDirection2 = 0; iDirection2 < NUM_DIRECTION_TYPES; iDirection2++)
{
CvPlot* pEnemyAdjPlot = plotDirection(pAdjPlot->getX(), pAdjPlot->getY(), ((DirectionTypes)iDirection2));
if(!pEnemyAdjPlot)
{
continue;
}
// Don't check Enemy Unit's plot
if(!bIsVisibleEnemyUnit)
{
// Destination adjacent to enemy unit?
if(pEnemyAdjPlot->getX() == iToPlotX && pEnemyAdjPlot->getY() == iToPlotY)
{
return true;
}
}
}
}
}
}
}
}
return false;
}
/// Update data for a cell: returns whether or not to add to dominance zones
bool CvTacticalAnalysisMap::PopulateCell(int iIndex, CvPlot* pPlot)
{
CvUnit* pLoopUnit;
int iUnitLoop;
CvTacticalAnalysisCell& cell = m_pPlots[iIndex];
cell.Clear();
cell.SetRevealed(pPlot->isRevealed(m_pPlayer->getTeam()));
cell.SetVisible(pPlot->isVisible(m_pPlayer->getTeam()));
cell.SetImpassableTerrain(pPlot->isImpassable() || pPlot->isMountain());
cell.SetWater(pPlot->isWater());
cell.SetOcean(pPlot->isWater() && !pPlot->isShallowWater());
bool bImpassableTerritory = false;
if(pPlot->isOwned())
{
TeamTypes eMyTeam = m_pPlayer->getTeam();
TeamTypes ePlotTeam = pPlot->getTeam();
if(eMyTeam != ePlotTeam && !GET_TEAM(eMyTeam).isAtWar(ePlotTeam) && !GET_TEAM(ePlotTeam).IsAllowsOpenBordersToTeam(eMyTeam))
{
bImpassableTerritory = true;
}
else if(pPlot->isCity())
{
if(pPlot->getOwner() == m_pPlayer->GetID())
{
cell.SetFriendlyCity(true);
}
else if(GET_TEAM(eMyTeam).isAtWar(ePlotTeam))
{
cell.SetEnemyCity(true);
}
else
{
cell.SetNeutralCity(true);
}
}
if(m_pPlayer->GetID() == pPlot->getOwner())
{
cell.SetOwnTerritory(true);
}
if(GET_TEAM(eMyTeam).isFriendlyTerritory(ePlotTeam))
{
cell.SetFriendlyTerritory(true);
}
if(GET_TEAM(ePlotTeam).isAtWar(ePlotTeam))
{
cell.SetEnemyTerritory(true);
}
}
else
{
cell.SetUnclaimedTerritory(true);
}
cell.SetImpassableTerritory(bImpassableTerritory);
cell.SetDefenseModifier(pPlot->defenseModifier(NO_TEAM, true));
if(pPlot->getNumUnits() > 0)
{
for(iUnitLoop = 0; iUnitLoop < pPlot->getNumUnits(); iUnitLoop++)
{
pLoopUnit = pPlot->getUnitByIndex(iUnitLoop);
if(!pLoopUnit) continue;
if(pLoopUnit->getOwner() == m_pPlayer->GetID())
{
if(pLoopUnit->IsCombatUnit())
{
// CvAssertMsg(!cell.GetFriendlyMilitaryUnit(), "Two friendly military units in a hex, please show Ed and send save.");
cell.SetFriendlyMilitaryUnit(pLoopUnit);
}
else
{
// CvAssertMsg(!cell.GetFriendlyCivilianUnit(), "Two friendly civilian units in a hex, please show Ed and send save.");
cell.SetFriendlyCivilianUnit(pLoopUnit);
}
}
else if(pLoopUnit->isEnemy(m_pPlayer->getTeam()))
{
if(pLoopUnit->IsCombatUnit())
{
// CvAssertMsg(!cell.GetEnemyMilitaryUnit(), "Two enemy military units in a hex, please show Ed and send save.");
cell.SetEnemyMilitaryUnit(pLoopUnit);
}
else
{
// CvAssertMsg(!cell.GetEnemyCivilianUnit(), "Two enemy civilian units in a hex, please show Ed and send save.");
cell.SetEnemyCivilianUnit(pLoopUnit);
}
}
else
{
if(pLoopUnit->IsCombatUnit())
{
// CvAssertMsg(!cell.GetNeutralMilitaryUnit(), "Two neutral military units in a hex, please show Ed and send save.");
cell.SetNeutralMilitaryUnit(pLoopUnit);
}
else
{
// CvAssertMsg(!cell.GetNeutralCivilianUnit(), "Two neutral civilian units in a hex, please show Ed and send save.");
cell.SetNeutralCivilianUnit(pLoopUnit);
}
}
}
}
// Figure out whether or not to add this to a dominance zone
bool bAdd = true;
if(cell.IsImpassableTerrain() || cell.IsImpassableTerritory() || !cell.IsRevealed())
{
bAdd = false;
}
return bAdd;
}