// Get the maximum damage unit could receive at this plot in the next turn (update this with CvUnitCombat changes!)
int CvDangerPlotContents::GetDanger(const CvUnit* pUnit, AirActionType iAirAction)
{
if (!m_pPlot || !pUnit)
return 0;
// Air units only take damage from interceptions
if (pUnit->getDomainType() == DOMAIN_AIR)
return GetAirUnitDamage(pUnit, iAirAction);
//simple caching for speedup
SUnitStats unitStats(pUnit);
if (unitStats==m_lastUnit)
return m_lastResult;
//otherwise calculate from scratch
int iPlotDamage = 0;
CvCity* pFriendlyCity = NULL;
if ( m_pPlot->isFriendlyCity(*pUnit,true) )
pFriendlyCity = m_pPlot->getPlotCity();
// Civilians can be captured - unless they would need to be embarked on this plot
if (!pUnit->IsCombatUnit() && pUnit->isNativeDomain(m_pPlot))
{
// If plot contains an enemy unit, mark it as max danger
if (m_pPlot->getBestDefender(NO_PLAYER, pUnit->getOwner(), NULL, true))
{
return MAX_INT;
}
for (DangerUnitVector::iterator it = m_apUnits.begin(); it < m_apUnits.end(); ++it)
{
CvUnit* pAttacker = GET_PLAYER(it->first).getUnit(it->second);
if ( pAttacker && !pAttacker->isDelayedDeath() && !pAttacker->IsDead())
{
// If in a city and the city can be captured, we are in highest danger
if (pFriendlyCity)
{
if (GetDanger(pFriendlyCity) + pFriendlyCity->getDamage() > pFriendlyCity->GetMaxHitPoints())
{
return MAX_INT;
}
}
// Look for a possible plot defender
else
{
IDInfo* pUnitNode = m_pPlot->headUnitNode();
CvUnit* pBestDefender = NULL;
while (pUnitNode != NULL)
{
pBestDefender = ::getUnit(*pUnitNode);
pUnitNode = m_pPlot->nextUnitNode(pUnitNode);
if (pBestDefender && pBestDefender->getOwner() == pUnit->getOwner())
{
//fix endless recursion with stacked embarked civilians: defender must also be able to attack
if (pBestDefender->IsCanDefend() && pBestDefender->IsCanAttack())
{
if (pBestDefender != pUnit)
{
if (pBestDefender->isWaiting() || !(pBestDefender->canMove()))
{
break;
}
}
}
}
pBestDefender = NULL;
}
// If there is a defender and it might be killed, high danger
if (pBestDefender && (pBestDefender->isWaiting() || !pBestDefender->canMove()))
{
if (GetDanger(pBestDefender) > pBestDefender->GetCurrHitPoints())
{
return INT_MAX;
}
}
else if (pBestDefender==NULL)
{
//Civilian could be captured on this tile
return MAX_INT;
}
}
}
}
// Damage from features (citadel)
iPlotDamage += GetDamageFromFeatures(pUnit->getOwner());
iPlotDamage += m_bFlatPlotDamage ? m_pPlot->getTurnDamage(pUnit->ignoreTerrainDamage(), pUnit->ignoreFeatureDamage(), pUnit->extraTerrainDamage(), pUnit->extraFeatureDamage()) : 0;
// Damage from cities
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())
continue;
iPlotDamage += pCity->rangeCombatDamage(pUnit, NULL, false, m_pPlot);
}
//update cache
m_lastUnit = unitStats;
m_lastResult = iPlotDamage;
return iPlotDamage;
}
// Capturing a city with a garrisoned unit destroys the garrisoned unit
if (pFriendlyCity)
{
int iCityDanger = GetDanger(pFriendlyCity, (pUnit->getDomainType() == DOMAIN_LAND ? pUnit : NULL));
if (iCityDanger + pFriendlyCity->getDamage() < pFriendlyCity->GetMaxHitPoints())
{
if (pUnit->CanGarrison())
{
// Reconstruct the amount of damage the garrison would absorb for the city
int iUnitShare = (iCityDanger*2*pUnit->GetMaxHitPoints()) / pFriendlyCity->GetMaxHitPoints();
// Damage from features
return iUnitShare + GetDamageFromFeatures(pUnit->getOwner());
}
else
return 0;
}
else
{
return MAX_INT;
}
}
CvPlot* pAttackerPlot = NULL;
CvUnit* pInterceptor = NULL;
// Damage from units
// EXTREMELY IMPORTANT THAT NO RNG IS USED FOR PREDICTION!
// Otherwise a tooltip or similar can change the game state
for (DangerUnitVector::iterator it = m_apUnits.begin(); it < m_apUnits.end(); ++it)
{
CvUnit* pAttacker = GET_PLAYER(it->first).getUnit(it->second);
if (!pAttacker || pAttacker->isDelayedDeath() || pAttacker->IsDead())
continue;
pAttackerPlot = NULL;
if (pAttacker->plot() != m_pPlot)
{
if (pAttacker->IsCanAttackRanged())
{
if (pAttacker->getDomainType() == DOMAIN_AIR)
{
pInterceptor = pAttacker->GetBestInterceptor(*m_pPlot, pUnit);
int iInterceptDamage = 0;
if (pInterceptor)
{
// Always assume interception is successful
iInterceptDamage = pInterceptor->GetInterceptionDamage(pUnit, false);
}
iPlotDamage += pAttacker->GetAirCombatDamage(pUnit, NULL, false, iInterceptDamage, m_pPlot);
}
else
{
iPlotDamage += pAttacker->GetRangeCombatDamage(pUnit, NULL, false, 0, m_pPlot);
}
}
else
{
if (plotDistance(m_iX, m_iY, pUnit->getX(), pUnit->getY()) == 1)
{
pAttackerPlot = pAttacker->plot();
}
iPlotDamage += pAttacker->getCombatDamage(
pAttacker->GetMaxAttackStrength(pAttackerPlot, m_pPlot, pUnit),
pUnit->GetMaxDefenseStrength(m_pPlot, pAttacker), pAttacker->getDamage(), false, false, false);
if (pAttacker->isRangedSupportFire())
{
iPlotDamage += pAttacker->GetRangeCombatDamage(pUnit, NULL, false, 0, m_pPlot, pAttackerPlot);
}
}
}
}
// Damage from cities
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())
continue;
iPlotDamage += pCity->rangeCombatDamage(pUnit, NULL, false, m_pPlot);
}
// Damage from surrounding features (citadel) and the plot itself
iPlotDamage += GetDamageFromFeatures(pUnit->getOwner());
iPlotDamage += m_bFlatPlotDamage ? m_pPlot->getTurnDamage(pUnit->ignoreTerrainDamage(), pUnit->ignoreFeatureDamage(), pUnit->extraTerrainDamage(), pUnit->extraFeatureDamage()) : 0;
//update cache
m_lastUnit = unitStats;
m_lastResult = iPlotDamage;
//done
return iPlotDamage;
}
/// Recalculate when each unit will arrive at the current army position, whatever that is
void CvArmyAI::UpdateCheckpointTurnsAndRemoveBadUnits()
{
CvAIOperation* pOperation = GET_PLAYER(GetOwner()).getAIOperation(GetOperationID());
//should be updated before calling this ...
CvPlot* pCurrentArmyPlot = GC.getMap().plot(GetX(), GetY());
//kick out damaged units, but if we're defending or escorting, no point in running away
if (pOperation->IsOffensive())
{
for (unsigned int iI = 0; iI < m_FormationEntries.size(); iI++)
{
if (!m_FormationEntries[iI].IsUsed())
continue;
CvUnit* pUnit = GET_PLAYER(m_eOwner).getUnit(m_FormationEntries[iI].m_iUnitID);
if (pUnit == NULL)
continue;
//failsafe - make sure the army ID is set
if (pUnit->getArmyID() != GetID())
pUnit->setArmyID(GetID());
//let tactical AI handle those
if (pUnit->GetCurrHitPoints() < pUnit->GetMaxHitPoints() / 3)
RemoveUnit(m_FormationEntries[iI].GetUnitID());
}
}
//update for all units in this army. ignore the ones still being built
int iGatherTolerance = pOperation->GetGatherTolerance(this, pCurrentArmyPlot);
for(unsigned int iI = 0; iI < m_FormationEntries.size(); iI++)
{
if (!m_FormationEntries[iI].IsUsed())
continue;
CvUnit* pUnit = GET_PLAYER(m_eOwner).getUnit(m_FormationEntries[iI].GetUnitID());
if(pUnit && pCurrentArmyPlot)
{
if(plotDistance(*pUnit->plot(),*pCurrentArmyPlot)<iGatherTolerance)
{
m_FormationEntries[iI].SetTurnsToCheckpoint(0);
}
else
{
//be generous with the flags here, for some ops the muster point may be far away and intermittendly occupied by foreign units ...
int iFlags = CvUnit::MOVEFLAG_APPROX_TARGET_RING2 | CvUnit::MOVEFLAG_IGNORE_STACKING | CvUnit::MOVEFLAG_IGNORE_ZOC;
int iTurnsToReachCheckpoint = pUnit->TurnsToReachTarget(pCurrentArmyPlot, iFlags, pOperation->GetMaximumRecruitTurns());
//if we're already moving to target, the current army plot is moving, so we cannot check progress against ...
if ( iTurnsToReachCheckpoint==INT_MAX ||
(GetArmyAIState()==ARMYAISTATE_WAITING_FOR_UNITS_TO_CATCH_UP && !m_FormationEntries[iI].IsMakingProgressTowardsCheckpoint(iTurnsToReachCheckpoint)) )
{
CvString strMsg;
strMsg.Format("Removing %s %d from army %d because no progress to checkpoint (%d:%d). ETA %d, previously %d.",
pUnit->getName().c_str(), m_FormationEntries[iI].GetUnitID(), GetID(), pCurrentArmyPlot->getX(), pCurrentArmyPlot->getY(),
iTurnsToReachCheckpoint, m_FormationEntries[iI].m_iPrevEstimatedTurnsToCheckpoint);
pOperation->LogOperationSpecialMessage(strMsg);
RemoveUnit(m_FormationEntries[iI].GetUnitID());
}
else
m_FormationEntries[iI].SetTurnsToCheckpoint(iTurnsToReachCheckpoint);
}
}
}
}
int CvDangerPlotContents::GetAirUnitDamage(const CvUnit* pUnit, AirActionType iAirAction)
{
if (pUnit->getDomainType() != DOMAIN_AIR)
return 0;
if (iAirAction == AIR_ACTION_INTERCEPT) // Max damage from a potential air sweep against our intercept
{
int iBestAirSweepDamage = 0;
int iCurrentAirSweepDamage = 0;
for (DangerUnitVector::iterator it = m_apUnits.begin(); it < m_apUnits.end(); ++it)
{
CvUnit* pAttacker = GET_PLAYER(it->first).getUnit(it->second);
if (!pAttacker || !pAttacker->canAirSweep() || pAttacker->isDelayedDeath() || pAttacker->IsDead())
{
continue;
}
int iAttackerStrength = pAttacker->GetMaxRangedCombatStrength(pUnit, /*pCity*/ NULL, true, false);
iAttackerStrength *= (100 + pAttacker->GetAirSweepCombatModifier());
iAttackerStrength /= 100;
int iDefenderStrength = pUnit->GetMaxRangedCombatStrength(pUnit, /*pCity*/ NULL, false, false);
iCurrentAirSweepDamage = pUnit->getCombatDamage(iDefenderStrength, iAttackerStrength,
pUnit->getDamage(), /*bIncludeRand*/ false, /*bAttackerIsCity*/ false, /*bDefenderIsCity*/ false);
// It's a slower to have this in the unit loop instead of after the best damage has been calculated, but it's also more accurate
if (iCurrentAirSweepDamage >= pAttacker->GetCurrHitPoints())
{
int iReceiverDamage = pAttacker->getCombatDamage(iAttackerStrength, iDefenderStrength,
pAttacker->getDamage(), /*bIncludeRand*/ false, /*bAttackerIsCity*/ false, /*bDefenderIsCity*/ false);
if (iReceiverDamage >= pUnit->GetCurrHitPoints())
{
if (iReceiverDamage + pUnit->getDamage() > iCurrentAirSweepDamage + pAttacker->getDamage())
{
iCurrentAirSweepDamage = pUnit->GetCurrHitPoints() - 1;
}
}
}
if (iCurrentAirSweepDamage > iBestAirSweepDamage)
{
iBestAirSweepDamage = iCurrentAirSweepDamage;
}
}
return iBestAirSweepDamage;
}
else
{
CvUnit* pInterceptor = pUnit->GetBestInterceptor(*m_pPlot);
if (pInterceptor)
{
// Air sweeps take modified damage from interceptors
if (iAirAction == AIR_ACTION_SWEEP)
{
if (pInterceptor->getDomainType() != DOMAIN_AIR)
{
return (pInterceptor->GetInterceptionDamage(pUnit, false) * (100+GC.getAIR_SWEEP_INTERCEPTION_DAMAGE_MOD()))/100;
}
else
{
int iAttackerStrength = pUnit->GetMaxRangedCombatStrength(pInterceptor, /*pCity*/ NULL, true, false);
iAttackerStrength *= (100 + pUnit->GetAirSweepCombatModifier());
iAttackerStrength /= 100;
int iDefenderStrength = pInterceptor->GetMaxRangedCombatStrength(pUnit, /*pCity*/ NULL, false, false);
int iReceiveDamage = pInterceptor->getCombatDamage(iDefenderStrength, iAttackerStrength,
pInterceptor->getDamage(), /*bIncludeRand*/ false, /*bAttackerIsCity*/ false, /*bDefenderIsCity*/ false);
if (iReceiveDamage >= pUnit->GetCurrHitPoints())
{
int iDamageDealt = pUnit->getCombatDamage(iAttackerStrength, iDefenderStrength,
pUnit->getDamage(), /*bIncludeRand*/ false, /*bAttackerIsCity*/ false, /*bDefenderIsCity*/ false);
if (iDamageDealt >= pInterceptor->GetCurrHitPoints())
{
if (iDamageDealt + pInterceptor->getDamage() > iReceiveDamage + pUnit->getDamage())
{
iReceiveDamage = pUnit->GetCurrHitPoints() - 1;
}
}
}
return iReceiveDamage;
}
}
else
{
// Always assume interception is successful
return pInterceptor->GetInterceptionDamage(pUnit, false);
}
}
}
return 0;
}
