AI tweaks and improvements (LoneGazebo#11683)

KungCheops · RecursiveVision · commit df63b2d58a09 · 2025-03-09T23:51:00.000-04:00
Improvement planning AI improvement:

Make improvement planning AI better at prioritizing improvements that buff nearby tiles. Will now prioritize building them next to tiles that are actively being worked by a city.

Fix bug causing AI to sometimes get stuck improving the same tile over and over (was miscounting for monopoly bonuses).

Unit Production AI tweaks:

Make unit production AI more focused on trade units and building military units up to their supply limit.

Add functionality to let the AI to include units currently being produced when considering how many units they currently have. This means they should no longer produce units way above their supply limit if they have many cities producing units at once.
diff --git a/CvGameCoreDLL_Expansion2/CvBuilderTaskingAI.cpp b/CvGameCoreDLL_Expansion2/CvBuilderTaskingAI.cpp
@@ -3355,14 +3355,20 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes
 				if (!pAdjacentOwningCity || pAdjacentOwningCity->IsRazing())
 					continue;
 
-				int iNewAdjacentYield = 0;
+				int iNewAdjacentWorkedYield = 0;
+				int iNewAdjacentUnworkedYield = 0;
+
+				bool bWorkingAdjacent = pAdjacentOwningCity->GetCityCitizens()->IsWorkingPlot(pAdjacentPlot);
 
 				// How much extra yield we give to adjacent tiles with a certain terrain
 				if (pAdjacentPlot->getTerrainType() != NO_TERRAIN)
 				{
 					int iAdjacentTerrainYieldChange = pkImprovementInfo ? pkImprovementInfo->GetAdjacentTerrainYieldChanges(pAdjacentPlot->getTerrainType(), eYield) : 0;
 					if (iAdjacentTerrainYieldChange != 0)
-						iNewAdjacentYield += iAdjacentTerrainYieldChange;
+						if (bWorkingAdjacent)
+							iNewAdjacentWorkedYield += iAdjacentTerrainYieldChange;
+						else
+							iNewAdjacentUnworkedYield += iAdjacentTerrainYieldChange;
 				}
 
 				ImprovementTypes eAdjacentImprovement = GetPlannedImprovementInPlot(pAdjacentPlot, sState);
@@ -3382,14 +3388,20 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes
 
 						int iDeltaTruncatedYield = (fCurrentAdjacentImprovementYield + fAdjacentImprovementYield).Truncate() - fCurrentAdjacentImprovementYield.Truncate();
 						if (iDeltaTruncatedYield != 0)
-							iNewAdjacentYield += iDeltaTruncatedYield;
+							if (bWorkingAdjacent)
+								iNewAdjacentWorkedYield += iDeltaTruncatedYield;
+							else
+								iNewAdjacentUnworkedYield += iDeltaTruncatedYield;
 
 						// How much extra yield an adjacent improvement will get if we create a resource
 						if (eResourceFromImprovement != NO_RESOURCE)
 						{
 							int iAdjacentResourceYieldChanges = pkAdjacentImprovementInfo->GetAdjacentResourceYieldChanges(eResourceFromImprovement, eYield);
 							if (iAdjacentResourceYieldChanges != 0)
-								iNewAdjacentYield += iAdjacentResourceYieldChanges;
+								if (bWorkingAdjacent)
+									iNewAdjacentWorkedYield += iAdjacentResourceYieldChanges;
+								else
+									iNewAdjacentUnworkedYield += iAdjacentResourceYieldChanges;
 						}
 
 						// How much extra yield an adjacent improvement will get if we create a feature (or keep the one that's here)
@@ -3398,15 +3410,19 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes
 							FeatureTypes eNewFeature = eFeatureFromImprovement != NO_FEATURE ? eFeatureFromImprovement : eFeature;
 							int iAdjacentFeatureYieldChanges = pkAdjacentImprovementInfo->GetAdjacentFeatureYieldChanges(eNewFeature, eYield);
 							if (iAdjacentFeatureYieldChanges != 0)
-								iNewAdjacentYield += iAdjacentFeatureYieldChanges;
+								if (bWorkingAdjacent)
+									iNewAdjacentWorkedYield += iAdjacentFeatureYieldChanges;
+								else
+									iNewAdjacentUnworkedYield += iAdjacentFeatureYieldChanges;
 						}
 					}
 				}
 
-				if (iNewAdjacentYield != 0)
+				if (iNewAdjacentWorkedYield != 0 || iNewAdjacentUnworkedYield != 0)
 				{
 					int iAdjacentCityYieldModifier = pAdjacentOwningCity ? GetYieldCityModifierTimes100(pAdjacentOwningCity, m_pPlayer, eYield) : 100;
-					iSecondaryScore += (iNewAdjacentYield * iYieldModifier * iAdjacentCityYieldModifier) / 100;
+					iSecondaryScore += (iNewAdjacentWorkedYield * iYieldModifier * iAdjacentCityYieldModifier) / 100;
+					iPotentialScore += (iNewAdjacentUnworkedYield * iYieldModifier * iAdjacentCityYieldModifier) / 100;
 				}
 			}
 		}
@@ -3519,7 +3535,7 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes
 			if (eOldImprovement != NO_IMPROVEMENT)
 			{
 				CvImprovementEntry* pkOldImprovementInfo = GC.getImprovementInfo(eOldImprovement);
-				if (pkOldImprovementInfo && (pkOldImprovementInfo->IsConnectsResource(eResource) || pkOldImprovementInfo->GetResourceFromImprovement() == eResourceFromImprovement))
+				if (pkOldImprovementInfo && (pkOldImprovementInfo->IsConnectsResource(eResource) || pkOldImprovementInfo->GetResourceFromImprovement() == eResource))
 					iExtraResource -= iResourceAmount;
 			
 			}
@@ -3562,7 +3578,7 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes
 				}
 				int iTotalNumResource = GC.getMap().getNumResources(eConnectedResource);
 				if (bCreatesResource)
-					iTotalNumResource += iExtraResource;
+					iTotalNumResource += iResourceAmount;
 
 				int iCurrentMonopolyPercent = 0;
 				int iFutureMonopolyPercent = 0;
@@ -3582,7 +3598,8 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes
 				if (pkConnectedResource->getResourceUsage() == RESOURCEUSAGE_STRATEGIC)
 					iStrategicThreshold = /*25*/ GD_INT_GET(STRATEGIC_RESOURCE_MONOPOLY_THRESHOLD);
 
-				bool bCanReachGlobalMonopoly = iFutureMonopolyPercent > 50 || m_pPlayer->GetPlayerTraits()->IsImportsCountTowardsMonopolies() || (2 * (m_pPlayer->getResourceInOwnedPlots(eConnectedResource) + iResourceFromMinors) > iTotalNumResource);
+				bool bCanReachGlobalMonopoly = iFutureMonopolyPercent > iGlobalThreshold || m_pPlayer->GetPlayerTraits()->IsImportsCountTowardsMonopolies() || (100 * (m_pPlayer->getResourceInOwnedPlots(eConnectedResource) + iResourceFromMinors) > iGlobalThreshold * iTotalNumResource);
+				bool bCanReachStrategicMonopoly = iStrategicThreshold != 0 && (iFutureMonopolyPercent > iStrategicThreshold || m_pPlayer->GetPlayerTraits()->IsImportsCountTowardsMonopolies() || (100 * (m_pPlayer->getResourceInOwnedPlots(eConnectedResource) + iResourceFromMinors) > iStrategicThreshold * iTotalNumResource));
 
 				if (iCurrentMonopolyPercent <= iGlobalThreshold)
 				{
@@ -3603,6 +3620,10 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes
 						// We can get a global monopoly eventually
 						iPotentialScore += 2000;
 					}
+					else if (bCanReachStrategicMonopoly)
+					{
+						iPotentialScore += 1000;
+					}
 				}
 			}
 		}
diff --git a/CvGameCoreDLL_Expansion2/CvPlayer.cpp b/CvGameCoreDLL_Expansion2/CvPlayer.cpp
@@ -9662,6 +9662,32 @@ int CvPlayer::GetNumUnitPromotions(PromotionTypes ePromotion)
 	return iNum;
 }
 
+int CvPlayer::GetNumUnitsInProduction(DomainTypes eDomain, bool bMilitaryOnly)
+{
+	int iNumUnits = 0;
+
+	CvCity* pLoopCity = NULL;
+	int iLoop = 0;
+
+	for (pLoopCity = firstCity(&iLoop); pLoopCity != NULL; pLoopCity = nextCity(&iLoop))
+	{
+		UnitTypes eUnitType = pLoopCity->getProductionUnit();
+
+		if (eUnitType == NO_UNIT)
+			continue;
+
+		CvUnitEntry* pkUnitInfo = GC.getUnitInfo(eUnitType);
+
+		if (pkUnitInfo == NULL)
+			continue;
+
+		if (pkUnitInfo->GetDomainType() == eDomain && (!bMilitaryOnly || pkUnitInfo->GetCombat() > 0))
+			iNumUnits++;
+	}
+
+	return iNumUnits;
+}
+
 //	-----------------------------------------------------------------------------------------------
 void CvPlayer::UpdateDangerPlots()
 {
diff --git a/CvGameCoreDLL_Expansion2/CvPlayer.h b/CvGameCoreDLL_Expansion2/CvPlayer.h
@@ -197,6 +197,7 @@ class CvPlayer
 	int GetNumUnitsWithUnitCombat(UnitCombatTypes eUnitCombat);
 	int GetNumUnitsOfType(UnitTypes eUnit, bool bIncludeBeingTrained = false);
 	int GetNumUnitPromotions(PromotionTypes ePromotion);
+	int GetNumUnitsInProduction(DomainTypes eDomain, bool bMilitaryOnly);
 	void UpdateDangerPlots();
 	void SetDangerPlotsDirty();
 
diff --git a/CvGameCoreDLL_Expansion2/CvUnitProductionAI.cpp b/CvGameCoreDLL_Expansion2/CvUnitProductionAI.cpp
@@ -256,25 +256,29 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation
 			return SR_IMPOSSIBLE;
 	}
 
+	int iNumLandUnits = kPlayer.getNumMilitaryLandUnits() + kPlayer.GetNumUnitsInProduction(DOMAIN_LAND, true);
+	int iNumSeaUnits = kPlayer.getNumMilitarySeaUnits() + kPlayer.GetNumUnitsInProduction(DOMAIN_SEA, true);
+	int iNumTotalUnits = iNumLandUnits + iNumSeaUnits;
+	int iNumTotalUnitsToSupply = iNumTotalUnits - kPlayer.getNumUnitsSupplyFree();
+
 	//only war with majors count
 	bool bAtWar = (kPlayer.GetMilitaryAI()->GetNumberCivsAtWarWith(false) > 0);
 	if (!bFree && kPlayer.isMinorCiv())
 	{
 		if (bCombat)
 		{
-			if (kPlayer.getNumMilitaryUnits() > max(4, ((kPlayer.GetCurrentEra() + 3) * max(1, kPlayer.getNumCities()))))
+			if (iNumTotalUnits > max(4, ((kPlayer.GetCurrentEra() + 3) * max(1, kPlayer.getNumCities()))))
 				return SR_UNITSUPPLY;
 
 			if (pkUnitEntry->GetDomainType() == DOMAIN_SEA)
 			{
-				int iNumUnits = kPlayer.GetNumUnitsWithDomain(DOMAIN_SEA, true);
-				if (iNumUnits <= 2)
-					iBonus += max(0, 300 - (iNumUnits * 100));
+				if (iNumSeaUnits <= 2)
+					iBonus += max(0, 300 - (iNumSeaUnits * 100));
 
 				int iLimit = kPlayer.GetMilitaryAI()->GetRecommendNavySize();
-				if (iNumUnits <= iLimit)
+				if (iNumSeaUnits < iLimit)
 				{
-					iBonus += (iLimit - iNumUnits) * 100;
+					iBonus += (iLimit - iNumSeaUnits) * 100;
 					if (kPlayer.GetMinorCivAI()->IsRecentlyBulliedByAnyMajor())
 					{
 						iBonus += 100;
@@ -285,14 +289,13 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation
 			}
 			else if (pkUnitEntry->GetDomainType() == DOMAIN_LAND)
 			{
-				int iNumUnits = kPlayer.GetNumUnitsWithDomain(DOMAIN_LAND, true);
-				if (iNumUnits <= 2)
-					iBonus += max(0, 800 - (iNumUnits * 100));
+				if (iNumLandUnits <= 2)
+					iBonus += max(0, 800 - (iNumLandUnits * 100));
 
 				int iLimit = kPlayer.GetMilitaryAI()->GetRecommendLandArmySize();
-				if (iNumUnits <= iLimit)
+				if (iNumLandUnits < iLimit)
 				{
-					iBonus += (iLimit - iNumUnits) * 150;
+					iBonus += (iLimit - iNumLandUnits) * 150;
 					if (kPlayer.GetMinorCivAI()->IsRecentlyBulliedByAnyMajor())
 					{
 						iBonus += 250;
@@ -309,7 +312,7 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation
 	if (bCombat && !bFree)
 	{
 		int iSupply = max(1, kPlayer.GetNumUnitsSupplied());
-		int iDemand = kPlayer.GetNumUnitsToSupply();
+		int iDemand = iNumTotalUnitsToSupply;
 		if (bAtWar || bForOperation)
 		{
 			//hard limit, don't go too far into negative supply
@@ -923,21 +926,16 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation
 			{
 				return SR_USELESS;
 			}
-
+			
 			if (pkUnitEntry->GetDomainType() == DOMAIN_LAND)
 			{
-				iBonus += m_pCity->GetTradePriorityLand()*10;
+				iBonus += m_pCity->GetTradePriorityLand() * 10;
 			}
 			else
 			{
-				iBonus += m_pCity->GetTradePrioritySea()*10;
+				iBonus += m_pCity->GetTradePrioritySea() * 10;
 			}
 
-			int iUnhappyGold = m_pCity->GetPoverty(false);
-			if (iUnhappyGold > 0)
-			{
-				iBonus += (iUnhappyGold * 10);
-			}
 			//Less often if at war.
 			if (bAtWar)
 			{
@@ -946,13 +944,11 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation
 
 			if (kPlayer.GetPlayerTraits()->IsDiplomat())
 			{
-				int NumMissingTRs = kPlayer.GetTrade()->GetNumTradeRoutesPossible() - kPlayer.GetTrade()->GetNumTradeUnits(true);
-				iBonus += 100 * NumMissingTRs;
+				iBonus += 750;
 			}
 			else
 			{
-				int NumMissingTRs = kPlayer.GetTrade()->GetNumTradeRoutesPossible() - kPlayer.GetTrade()->GetNumTradeUnits(true);
-				iBonus += 50 * NumMissingTRs;
+				iBonus += 700;
 			}
 		}
 
@@ -1373,16 +1369,16 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation
 		}
 	}
 	//Tiny army? Eek!
-	if (kPlayer.getNumMilitaryUnits() <= (kPlayer.getNumCities() * 2) && pkUnitEntry->GetDomainType() == DOMAIN_LAND && pkUnitEntry->GetDefaultUnitAIType() != UNITAI_EXPLORE)
+	if (iNumLandUnits <= (kPlayer.getNumCities() * 2) && pkUnitEntry->GetDomainType() == DOMAIN_LAND && pkUnitEntry->GetDefaultUnitAIType() != UNITAI_EXPLORE)
 	{
 		if(bCombat)
 		{
-			iBonus += 100;
+			iBonus += 300;
 		}
 		//Fewer civilians til we rectify this!
 		else
 		{
-			iBonus -= 100;
+			iBonus -= 300;
 		}
 	}
 	
@@ -1394,18 +1390,18 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation
 			iBonus -= 500;
 	}
 
-	if (bCombat && pkUnitEntry->GetRangedCombat() <= 0 && pkUnitEntry->GetDomainType() == DOMAIN_LAND)
+	if (bCombat && pkUnitEntry->GetDomainType() == DOMAIN_LAND && pkUnitEntry->GetDefaultUnitAIType() != UNITAI_EXPLORE)
 	{
 		static MilitaryAIStrategyTypes eStrategyBarbs = (MilitaryAIStrategyTypes)GC.getInfoTypeForString("MILITARYAISTRATEGY_ERADICATE_BARBARIANS");
 		static MilitaryAIStrategyTypes eStrategyBarbsCritical = (MilitaryAIStrategyTypes)GC.getInfoTypeForString("MILITARYAISTRATEGY_ERADICATE_BARBARIANS_CRITICAL");
 		
 		if (kPlayer.GetMilitaryAI()->IsUsingStrategy(eStrategyBarbs))
 		{
-			iBonus += 25;
+			iBonus += 250;
 		}
 		else if (kPlayer.GetMilitaryAI()->IsUsingStrategy(eStrategyBarbsCritical))
 		{
-			iBonus += 50;
+			iBonus += 500;
 		}
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -3355,14 +3355,20 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes`
`3355`	`3355`	`if (!pAdjacentOwningCity \|\| pAdjacentOwningCity->IsRazing())`
`3356`	`3356`	`continue;`
`3357`	`3357`
`3358`		`- int iNewAdjacentYield = 0;`
	`3358`	`+ int iNewAdjacentWorkedYield = 0;`
	`3359`	`+ int iNewAdjacentUnworkedYield = 0;`
	`3360`	`+`
	`3361`	`+ bool bWorkingAdjacent = pAdjacentOwningCity->GetCityCitizens()->IsWorkingPlot(pAdjacentPlot);`
`3359`	`3362`
`3360`	`3363`	`// How much extra yield we give to adjacent tiles with a certain terrain`
`3361`	`3364`	`if (pAdjacentPlot->getTerrainType() != NO_TERRAIN)`
`3362`	`3365`	`{`
`3363`	`3366`	`int iAdjacentTerrainYieldChange = pkImprovementInfo ? pkImprovementInfo->GetAdjacentTerrainYieldChanges(pAdjacentPlot->getTerrainType(), eYield) : 0;`
`3364`	`3367`	`if (iAdjacentTerrainYieldChange != 0)`
`3365`		`- iNewAdjacentYield += iAdjacentTerrainYieldChange;`
	`3368`	`+ if (bWorkingAdjacent)`
	`3369`	`+ iNewAdjacentWorkedYield += iAdjacentTerrainYieldChange;`
	`3370`	`+ else`
	`3371`	`+ iNewAdjacentUnworkedYield += iAdjacentTerrainYieldChange;`
`3366`	`3372`	`}`
`3367`	`3373`
`3368`	`3374`	`ImprovementTypes eAdjacentImprovement = GetPlannedImprovementInPlot(pAdjacentPlot, sState);`
`@@ -3382,14 +3388,20 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes`
`3382`	`3388`
`3383`	`3389`	`int iDeltaTruncatedYield = (fCurrentAdjacentImprovementYield + fAdjacentImprovementYield).Truncate() - fCurrentAdjacentImprovementYield.Truncate();`
`3384`	`3390`	`if (iDeltaTruncatedYield != 0)`
`3385`		`- iNewAdjacentYield += iDeltaTruncatedYield;`
	`3391`	`+ if (bWorkingAdjacent)`
	`3392`	`+ iNewAdjacentWorkedYield += iDeltaTruncatedYield;`
	`3393`	`+ else`
	`3394`	`+ iNewAdjacentUnworkedYield += iDeltaTruncatedYield;`
`3386`	`3395`
`3387`	`3396`	`// How much extra yield an adjacent improvement will get if we create a resource`
`3388`	`3397`	`if (eResourceFromImprovement != NO_RESOURCE)`
`3389`	`3398`	`{`
`3390`	`3399`	`int iAdjacentResourceYieldChanges = pkAdjacentImprovementInfo->GetAdjacentResourceYieldChanges(eResourceFromImprovement, eYield);`
`3391`	`3400`	`if (iAdjacentResourceYieldChanges != 0)`
`3392`		`- iNewAdjacentYield += iAdjacentResourceYieldChanges;`
	`3401`	`+ if (bWorkingAdjacent)`
	`3402`	`+ iNewAdjacentWorkedYield += iAdjacentResourceYieldChanges;`
	`3403`	`+ else`
	`3404`	`+ iNewAdjacentUnworkedYield += iAdjacentResourceYieldChanges;`
`3393`	`3405`	`}`
`3394`	`3406`
`3395`	`3407`	`// How much extra yield an adjacent improvement will get if we create a feature (or keep the one that's here)`
`@@ -3398,15 +3410,19 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes`
`3398`	`3410`	`FeatureTypes eNewFeature = eFeatureFromImprovement != NO_FEATURE ? eFeatureFromImprovement : eFeature;`
`3399`	`3411`	`int iAdjacentFeatureYieldChanges = pkAdjacentImprovementInfo->GetAdjacentFeatureYieldChanges(eNewFeature, eYield);`
`3400`	`3412`	`if (iAdjacentFeatureYieldChanges != 0)`
`3401`		`- iNewAdjacentYield += iAdjacentFeatureYieldChanges;`
	`3413`	`+ if (bWorkingAdjacent)`
	`3414`	`+ iNewAdjacentWorkedYield += iAdjacentFeatureYieldChanges;`
	`3415`	`+ else`
	`3416`	`+ iNewAdjacentUnworkedYield += iAdjacentFeatureYieldChanges;`
`3402`	`3417`	`}`
`3403`	`3418`	`}`
`3404`	`3419`	`}`
`3405`	`3420`
`3406`		`- if (iNewAdjacentYield != 0)`
	`3421`	`+ if (iNewAdjacentWorkedYield != 0 \|\| iNewAdjacentUnworkedYield != 0)`
`3407`	`3422`	`{`
`3408`	`3423`	`int iAdjacentCityYieldModifier = pAdjacentOwningCity ? GetYieldCityModifierTimes100(pAdjacentOwningCity, m_pPlayer, eYield) : 100;`
`3409`		`- iSecondaryScore += (iNewAdjacentYield * iYieldModifier * iAdjacentCityYieldModifier) / 100;`
	`3424`	`+ iSecondaryScore += (iNewAdjacentWorkedYield * iYieldModifier * iAdjacentCityYieldModifier) / 100;`
	`3425`	`+ iPotentialScore += (iNewAdjacentUnworkedYield * iYieldModifier * iAdjacentCityYieldModifier) / 100;`
`3410`	`3426`	`}`
`3411`	`3427`	`}`
`3412`	`3428`	`}`
`@@ -3519,7 +3535,7 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes`
`3519`	`3535`	`if (eOldImprovement != NO_IMPROVEMENT)`
`3520`	`3536`	`{`
`3521`	`3537`	`CvImprovementEntry* pkOldImprovementInfo = GC.getImprovementInfo(eOldImprovement);`
`3522`		`- if (pkOldImprovementInfo && (pkOldImprovementInfo->IsConnectsResource(eResource) \|\| pkOldImprovementInfo->GetResourceFromImprovement() == eResourceFromImprovement))`
	`3538`	`+ if (pkOldImprovementInfo && (pkOldImprovementInfo->IsConnectsResource(eResource) \|\| pkOldImprovementInfo->GetResourceFromImprovement() == eResource))`
`3523`	`3539`	`iExtraResource -= iResourceAmount;`
`3524`	`3540`
`3525`	`3541`	`}`
`@@ -3562,7 +3578,7 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes`
`3562`	`3578`	`}`
`3563`	`3579`	`int iTotalNumResource = GC.getMap().getNumResources(eConnectedResource);`
`3564`	`3580`	`if (bCreatesResource)`
`3565`		`- iTotalNumResource += iExtraResource;`
	`3581`	`+ iTotalNumResource += iResourceAmount;`
`3566`	`3582`
`3567`	`3583`	`int iCurrentMonopolyPercent = 0;`
`3568`	`3584`	`int iFutureMonopolyPercent = 0;`
`@@ -3582,7 +3598,8 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes`
`3582`	`3598`	`if (pkConnectedResource->getResourceUsage() == RESOURCEUSAGE_STRATEGIC)`
`3583`	`3599`	`iStrategicThreshold = /25/ GD_INT_GET(STRATEGIC_RESOURCE_MONOPOLY_THRESHOLD);`
`3584`	`3600`
`3585`		`- bool bCanReachGlobalMonopoly = iFutureMonopolyPercent > 50 \|\| m_pPlayer->GetPlayerTraits()->IsImportsCountTowardsMonopolies() \|\| (2 * (m_pPlayer->getResourceInOwnedPlots(eConnectedResource) + iResourceFromMinors) > iTotalNumResource);`
	`3601`	`+ bool bCanReachGlobalMonopoly = iFutureMonopolyPercent > iGlobalThreshold \|\| m_pPlayer->GetPlayerTraits()->IsImportsCountTowardsMonopolies() \|\| (100 * (m_pPlayer->getResourceInOwnedPlots(eConnectedResource) + iResourceFromMinors) > iGlobalThreshold * iTotalNumResource);`
	`3602`	`+ bool bCanReachStrategicMonopoly = iStrategicThreshold != 0 && (iFutureMonopolyPercent > iStrategicThreshold \|\| m_pPlayer->GetPlayerTraits()->IsImportsCountTowardsMonopolies() \|\| (100 * (m_pPlayer->getResourceInOwnedPlots(eConnectedResource) + iResourceFromMinors) > iStrategicThreshold * iTotalNumResource));`
`3586`	`3603`
`3587`	`3604`	`if (iCurrentMonopolyPercent <= iGlobalThreshold)`
`3588`	`3605`	`{`
`@@ -3603,6 +3620,10 @@ pair<int,int> CvBuilderTaskingAI::ScorePlotBuild(CvPlot* pPlot, ImprovementTypes`
`3603`	`3620`	`// We can get a global monopoly eventually`
`3604`	`3621`	`iPotentialScore += 2000;`
`3605`	`3622`	`}`
	`3623`	`+ else if (bCanReachStrategicMonopoly)`
	`3624`	`+ {`
	`3625`	`+ iPotentialScore += 1000;`
	`3626`	`+ }`
`3606`	`3627`	`}`
`3607`	`3628`	`}`
`3608`	`3629`	`}`
Original file line number	Diff line number	Diff line change
`@@ -256,25 +256,29 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation`
`256`	`256`	`return SR_IMPOSSIBLE;`
`257`	`257`	`}`
`258`	`258`
	`259`	`+ int iNumLandUnits = kPlayer.getNumMilitaryLandUnits() + kPlayer.GetNumUnitsInProduction(DOMAIN_LAND, true);`
	`260`	`+ int iNumSeaUnits = kPlayer.getNumMilitarySeaUnits() + kPlayer.GetNumUnitsInProduction(DOMAIN_SEA, true);`
	`261`	`+ int iNumTotalUnits = iNumLandUnits + iNumSeaUnits;`
	`262`	`+ int iNumTotalUnitsToSupply = iNumTotalUnits - kPlayer.getNumUnitsSupplyFree();`
	`263`	`+`
`259`	`264`	`//only war with majors count`
`260`	`265`	`bool bAtWar = (kPlayer.GetMilitaryAI()->GetNumberCivsAtWarWith(false) > 0);`
`261`	`266`	`if (!bFree && kPlayer.isMinorCiv())`
`262`	`267`	`{`
`263`	`268`	`if (bCombat)`
`264`	`269`	`{`
`265`		`- if (kPlayer.getNumMilitaryUnits() > max(4, ((kPlayer.GetCurrentEra() + 3) * max(1, kPlayer.getNumCities()))))`
	`270`	`+ if (iNumTotalUnits > max(4, ((kPlayer.GetCurrentEra() + 3) * max(1, kPlayer.getNumCities()))))`
`266`	`271`	`return SR_UNITSUPPLY;`
`267`	`272`
`268`	`273`	`if (pkUnitEntry->GetDomainType() == DOMAIN_SEA)`
`269`	`274`	`{`
`270`		`- int iNumUnits = kPlayer.GetNumUnitsWithDomain(DOMAIN_SEA, true);`
`271`		`- if (iNumUnits <= 2)`
`272`		`- iBonus += max(0, 300 - (iNumUnits * 100));`
	`275`	`+ if (iNumSeaUnits <= 2)`
	`276`	`+ iBonus += max(0, 300 - (iNumSeaUnits * 100));`
`273`	`277`
`274`	`278`	`int iLimit = kPlayer.GetMilitaryAI()->GetRecommendNavySize();`
`275`		`- if (iNumUnits <= iLimit)`
	`279`	`+ if (iNumSeaUnits < iLimit)`
`276`	`280`	`{`
`277`		`- iBonus += (iLimit - iNumUnits) * 100;`
	`281`	`+ iBonus += (iLimit - iNumSeaUnits) * 100;`
`278`	`282`	`if (kPlayer.GetMinorCivAI()->IsRecentlyBulliedByAnyMajor())`
`279`	`283`	`{`
`280`	`284`	`iBonus += 100;`
`@@ -285,14 +289,13 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation`
`285`	`289`	`}`
`286`	`290`	`else if (pkUnitEntry->GetDomainType() == DOMAIN_LAND)`
`287`	`291`	`{`
`288`		`- int iNumUnits = kPlayer.GetNumUnitsWithDomain(DOMAIN_LAND, true);`
`289`		`- if (iNumUnits <= 2)`
`290`		`- iBonus += max(0, 800 - (iNumUnits * 100));`
	`292`	`+ if (iNumLandUnits <= 2)`
	`293`	`+ iBonus += max(0, 800 - (iNumLandUnits * 100));`
`291`	`294`
`292`	`295`	`int iLimit = kPlayer.GetMilitaryAI()->GetRecommendLandArmySize();`
`293`		`- if (iNumUnits <= iLimit)`
	`296`	`+ if (iNumLandUnits < iLimit)`
`294`	`297`	`{`
`295`		`- iBonus += (iLimit - iNumUnits) * 150;`
	`298`	`+ iBonus += (iLimit - iNumLandUnits) * 150;`
`296`	`299`	`if (kPlayer.GetMinorCivAI()->IsRecentlyBulliedByAnyMajor())`
`297`	`300`	`{`
`298`	`301`	`iBonus += 250;`
`@@ -309,7 +312,7 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation`
`309`	`312`	`if (bCombat && !bFree)`
`310`	`313`	`{`
`311`	`314`	`int iSupply = max(1, kPlayer.GetNumUnitsSupplied());`
`312`		`- int iDemand = kPlayer.GetNumUnitsToSupply();`
	`315`	`+ int iDemand = iNumTotalUnitsToSupply;`
`313`	`316`	`if (bAtWar \|\| bForOperation)`
`314`	`317`	`{`
`315`	`318`	`//hard limit, don't go too far into negative supply`
`@@ -923,21 +926,16 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation`
`923`	`926`	`{`
`924`	`927`	`return SR_USELESS;`
`925`	`928`	`}`
`926`		`-`
	`929`	`+`
`927`	`930`	`if (pkUnitEntry->GetDomainType() == DOMAIN_LAND)`
`928`	`931`	`{`
`929`		`- iBonus += m_pCity->GetTradePriorityLand()*10;`
	`932`	`+ iBonus += m_pCity->GetTradePriorityLand() * 10;`
`930`	`933`	`}`
`931`	`934`	`else`
`932`	`935`	`{`
`933`		`- iBonus += m_pCity->GetTradePrioritySea()*10;`
	`936`	`+ iBonus += m_pCity->GetTradePrioritySea() * 10;`
`934`	`937`	`}`
`935`	`938`
`936`		`- int iUnhappyGold = m_pCity->GetPoverty(false);`
`937`		`- if (iUnhappyGold > 0)`
`938`		`- {`
`939`		`- iBonus += (iUnhappyGold * 10);`
`940`		`- }`
`941`	`939`	`//Less often if at war.`
`942`	`940`	`if (bAtWar)`
`943`	`941`	`{`
`@@ -946,13 +944,11 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation`
`946`	`944`
`947`	`945`	`if (kPlayer.GetPlayerTraits()->IsDiplomat())`
`948`	`946`	`{`
`949`		`- int NumMissingTRs = kPlayer.GetTrade()->GetNumTradeRoutesPossible() - kPlayer.GetTrade()->GetNumTradeUnits(true);`
`950`		`- iBonus += 100 * NumMissingTRs;`
	`947`	`+ iBonus += 750;`
`951`	`948`	`}`
`952`	`949`	`else`
`953`	`950`	`{`
`954`		`- int NumMissingTRs = kPlayer.GetTrade()->GetNumTradeRoutesPossible() - kPlayer.GetTrade()->GetNumTradeUnits(true);`
`955`		`- iBonus += 50 * NumMissingTRs;`
	`951`	`+ iBonus += 700;`
`956`	`952`	`}`
`957`	`953`	`}`
`958`	`954`
`@@ -1373,16 +1369,16 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation`
`1373`	`1369`	`}`
`1374`	`1370`	`}`
`1375`	`1371`	`//Tiny army? Eek!`
`1376`		`- if (kPlayer.getNumMilitaryUnits() <= (kPlayer.getNumCities() * 2) && pkUnitEntry->GetDomainType() == DOMAIN_LAND && pkUnitEntry->GetDefaultUnitAIType() != UNITAI_EXPLORE)`
	`1372`	`+ if (iNumLandUnits <= (kPlayer.getNumCities() * 2) && pkUnitEntry->GetDomainType() == DOMAIN_LAND && pkUnitEntry->GetDefaultUnitAIType() != UNITAI_EXPLORE)`
`1377`	`1373`	`{`
`1378`	`1374`	`if(bCombat)`
`1379`	`1375`	`{`
`1380`		`- iBonus += 100;`
	`1376`	`+ iBonus += 300;`
`1381`	`1377`	`}`
`1382`	`1378`	`//Fewer civilians til we rectify this!`
`1383`	`1379`	`else`
`1384`	`1380`	`{`
`1385`		`- iBonus -= 100;`
	`1381`	`+ iBonus -= 300;`
`1386`	`1382`	`}`
`1387`	`1383`	`}`
`1388`	`1384`
`@@ -1394,18 +1390,18 @@ int CvUnitProductionAI::CheckUnitBuildSanity(UnitTypes eUnit, bool bForOperation`
`1394`	`1390`	`iBonus -= 500;`
`1395`	`1391`	`}`
`1396`	`1392`
`1397`		`- if (bCombat && pkUnitEntry->GetRangedCombat() <= 0 && pkUnitEntry->GetDomainType() == DOMAIN_LAND)`
	`1393`	`+ if (bCombat && pkUnitEntry->GetDomainType() == DOMAIN_LAND && pkUnitEntry->GetDefaultUnitAIType() != UNITAI_EXPLORE)`
`1398`	`1394`	`{`
`1399`	`1395`	`static MilitaryAIStrategyTypes eStrategyBarbs = (MilitaryAIStrategyTypes)GC.getInfoTypeForString("MILITARYAISTRATEGY_ERADICATE_BARBARIANS");`
`1400`	`1396`	`static MilitaryAIStrategyTypes eStrategyBarbsCritical = (MilitaryAIStrategyTypes)GC.getInfoTypeForString("MILITARYAISTRATEGY_ERADICATE_BARBARIANS_CRITICAL");`
`1401`	`1397`
`1402`	`1398`	`if (kPlayer.GetMilitaryAI()->IsUsingStrategy(eStrategyBarbs))`
`1403`	`1399`	`{`
`1404`		`- iBonus += 25;`
	`1400`	`+ iBonus += 250;`
`1405`	`1401`	`}`
`1406`	`1402`	`else if (kPlayer.GetMilitaryAI()->IsUsingStrategy(eStrategyBarbsCritical))`
`1407`	`1403`	`{`
`1408`		`- iBonus += 50;`
	`1404`	`+ iBonus += 500;`
`1409`	`1405`	`}`
`1410`	`1406`	`}`
`1411`	`1407`