public void GetProductionProgressPerTurnOnProject_ChangedByProductionModifiersOfPolicyBonuses()
{
var productionLogic = Container.Resolve <ProductionLogic>();
var city = BuildCity();
var project = BuildProject();
var civ = BuildCiv(city);
var policyBonuses = new List <ISocialPolicyBonusesData>()
{
BuildBonusData(BuildModifier(2f, true)),
BuildBonusData(BuildModifier(3f, true)),
BuildBonusData(BuildModifier(4f, false)),
};
MockSocialPolicyCanon.Setup(canon => canon.GetPolicyBonusesForCiv(civ)).Returns(policyBonuses);
var totalYield = new YieldSummary(production: 10);
MockGenerationLogic.Setup(
logic => logic.GetTotalYieldForCity(city, It.Is <YieldSummary>(summary => summary[YieldType.Production] == 2f + 3f))
).Returns(totalYield);
Assert.AreEqual(10, productionLogic.GetProductionProgressPerTurnOnProject(city, project));
}
public void SubtractionOperator_SubtractsComponents()
{
var summaryOne = new YieldSummary(food: 3, production: 2, gold: 1);
var summaryTwo = new YieldSummary(production: 5, gold: 1, culture: 6);
var summaryThree = new YieldSummary(food: 9, gold: 17, culture: 12);
var copyOfOne = new YieldSummary(summaryOne);
var copyOfTwo = new YieldSummary(summaryTwo);
var copyOfThree = new YieldSummary(summaryThree);
var oneMinusTwo = summaryOne - summaryTwo;
var oneMinusThree = summaryOne - summaryThree;
var twoMinusThree = summaryTwo - summaryThree;
foreach (var resourceType in EnumUtil.GetValues <YieldType>())
{
Assert.AreEqual(summaryOne[resourceType] - summaryTwo[resourceType], oneMinusTwo[resourceType],
"OneMinusTwo has an incorrect value for resource type " + resourceType);
Assert.AreEqual(summaryOne[resourceType] - summaryThree[resourceType], oneMinusThree[resourceType],
"OneMinusThree has an incorrect value for resource type " + resourceType);
Assert.AreEqual(summaryTwo[resourceType] - summaryThree[resourceType], twoMinusThree[resourceType],
"TwoMinusThree has an incorrect value for resource type " + resourceType);
Assert.AreEqual(copyOfOne[resourceType], summaryOne[resourceType],
"SummaryOne's value was changed by the addition operations");
Assert.AreEqual(copyOfTwo[resourceType], summaryTwo[resourceType],
"SummaryTwo's value was changed by the addition operations");
Assert.AreEqual(copyOfThree[resourceType], summaryThree[resourceType],
"SummaryThree's value was changed by the addition operations");
}
}
public void DisplaySummary(YieldSummary summary)
{
if (IncludeNormalYield)
{
if (IncludeGreatPersonYield)
{
SummaryField.text = YieldFormatter.GetTMProFormattedYieldString(
summary, EnumUtil.GetValues <YieldType>(), DisplayEmptyResources,
PlusSignOnPositiveNumbers
);
}
else
{
SummaryField.text = YieldFormatter.GetTMProFormattedYieldString(
summary, CoreConfig.NormalYields, DisplayEmptyResources,
PlusSignOnPositiveNumbers
);
}
}
else if (IncludeGreatPersonYield)
{
SummaryField.text = YieldFormatter.GetTMProFormattedYieldString(
summary, CoreConfig.GreatPersonYields, DisplayEmptyResources,
PlusSignOnPositiveNumbers
);
}
}
public YieldSummary GetTotalYieldForCity(ICity city, YieldSummary additionalBonuses)
{
if (city == null)
{
throw new ArgumentNullException("city");
}
var retval = CityCenterYieldLogic.GetYieldOfCityCenter(city);
foreach (var cell in CellPossessionCanon.GetPossessionsOfOwner(city))
{
if (!cell.SuppressSlot && cell.WorkerSlot.IsOccupied)
{
retval += GetYieldOfCellForCity(cell, city);
}
}
foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(city))
{
retval += GetYieldOfBuildingForCity(building, city);
}
retval += GetYieldOfUnemployedPersonForCity(city) * UnemploymentLogic.GetUnemployedPeopleInCity(city);
return(retval * (YieldSummary.Ones + additionalBonuses));
}
public void GetYieldOfCell_CallsIntoBuildingYieldIfCellBelongsToCity()
{
var cell = BuildCell();
var buildings = new List <IBuilding>()
{
BuildBuilding(), BuildBuilding(), BuildBuilding()
};
var buildingTemplates = buildings.Select(building => building.Template);
BuildCity(cell, buildings);
var buildingYield = new YieldSummary(food: 1, production: 2, gold: 3);
MockBuildingYieldLogic.Setup(
logic => logic.GetBonusCellYieldFromBuildings(cell, It.IsAny <IEnumerable <IBuildingTemplate> >())
).Returns(buildingYield);
var yieldLogic = Container.Resolve <CellYieldLogic>();
Assert.AreEqual(buildingYield, yieldLogic.GetYieldOfCell(cell, null));
MockBuildingYieldLogic.Verify(
logic => logic.GetBonusCellYieldFromBuildings(
cell,
It.Is <IEnumerable <IBuildingTemplate> >(
templates => templates.SequenceEqual(buildingTemplates)
)
),
Times.Once
);
}
public bool TryIncreaseYield(
MapRegion region, RegionData regionData, YieldType type, out YieldSummary yieldAdded
)
{
yieldAdded = YieldSummary.Empty;
return(false);
}
public void BalanceHomelandYields(HomelandData homelandData)
{
YieldSummary currentYield = YieldSummary.Empty;
foreach (var cell in homelandData.Cells)
{
currentYield += YieldEstimator.GetYieldEstimateForCell(cell, TechCanon.AvailableTechs);
}
float weightedCellCount = homelandData.LandCells.Count() * homelandData.YieldAndResources.LandWeight
+ homelandData.WaterCells.Count() * homelandData.YieldAndResources.WaterWeight;
float minFood = homelandData.YieldAndResources.MinFoodPerCell * weightedCellCount;
float minProduction = homelandData.YieldAndResources.MinProductionPerCell * weightedCellCount;
BringYieldTypeToMin(
YieldType.Food, minFood, homelandData, ref currentYield
);
BringYieldTypeToMin(
YieldType.Production, minProduction, homelandData, ref currentYield
);
float minScore = homelandData.YieldAndResources.MinScorePerCell * weightedCellCount;
float maxScore = homelandData.YieldAndResources.MaxScorePerCell * weightedCellCount;
KeepScoreWithinBounds(homelandData, minScore, maxScore);
}
public bool TryIncreaseYield(
MapRegion region, RegionData regionData, YieldType type, out YieldSummary yieldAdded
)
{
if (type != YieldType.Production)
{
yieldAdded = YieldSummary.Empty;
return(false);
}
var candidates = region.Cells.Where(HillCandidateFilter_ProductionIncreasing);
if (candidates.Any())
{
var newHill = candidates.Random();
var oldYield = YieldEstimator.GetYieldEstimateForCell(newHill, TechCanon.AvailableTechs);
ModLogic.ChangeShapeOfCell(newHill, CellShape.Hills);
var newYield = YieldEstimator.GetYieldEstimateForCell(newHill, TechCanon.AvailableTechs);
yieldAdded = newYield - oldYield;
return(true);
}
else
{
yieldAdded = YieldSummary.Empty;
return(false);
}
}
private void DisplayGrowthData()
{
YieldSummary income = YieldGenerationLogic.GetTotalYieldForCity(ObjectToDisplay);
float currentFoodStockpile = ObjectToDisplay.FoodStockpile;
int foodUntilNextGrowth = GrowthLogic.GetFoodStockpileToGrow(ObjectToDisplay);
float netFoodIncome = income[YieldType.Food] - GrowthLogic.GetFoodConsumptionPerTurn(ObjectToDisplay);
float realFoodGain = GrowthLogic.GetFoodStockpileAdditionFromIncome(ObjectToDisplay, netFoodIncome);
int turnsToGrow = Mathf.CeilToInt((foodUntilNextGrowth - currentFoodStockpile) / realFoodGain);
if (realFoodGain > 0)
{
TurnsUntilGrowthField.text = turnsToGrow.ToString();
}
else
{
TurnsUntilGrowthField.text = "--";
}
TurnsUntilGrowthField.text = turnsToGrow.ToString();
PopulationField.text = ObjectToDisplay.Population.ToString();
GrowthSlider.minValue = 0;
GrowthSlider.maxValue = foodUntilNextGrowth;
GrowthSlider.value = Mathf.FloorToInt(currentFoodStockpile);
}
public YieldSummary GetYieldOfImprovementTemplate(
IImprovementTemplate template, IResourceNode nodeAtLocation,
IEnumerable <IResourceDefinition> visibleResources,
IEnumerable <IImprovementModificationData> improvementModifications,
bool hasFreshWater
)
{
YieldSummary retval = YieldSummary.Empty;
if (nodeAtLocation == null || nodeAtLocation.Resource.Extractor != template ||
!visibleResources.Contains(nodeAtLocation.Resource)
)
{
retval += template.BonusYieldNormal;
}
foreach (var mod in improvementModifications)
{
if (mod.Template == template && (!mod.RequiresFreshWater || hasFreshWater))
{
retval += mod.BonusYield;
}
}
return(retval);
}
private ISpecialistDefinition BuildSpecialist(YieldSummary yield)
{
var mockSpecialist = new Mock <ISpecialistDefinition>();
mockSpecialist.Setup(specialist => specialist.Yield).Returns(yield);
return(mockSpecialist.Object);
}
private IBuilding BuildBuilding(YieldSummary civilizationModifier, YieldSummary cityModifier)
{
var mockBuilding = new Mock <IBuilding>();
mockBuilding.Setup(building => building.CivilizationYieldModifier).Returns(civilizationModifier);
mockBuilding.Setup(building => building.CityYieldModifier).Returns(cityModifier);
return(mockBuilding.Object);
}
public CellYieldModificationData(CellVegetation featureRequired, YieldSummary bonusYield)
{
_propertyConsidered = CellPropertyType.Vegetation;
_vegetationRequired = featureRequired;
_bonusYield = bonusYield;
_terrainRequired = CellTerrain.Grassland;
_shapeRequired = CellShape.Flatlands;
_mustBeUnderwater = false;
}
public CellYieldModificationData(bool mustBeUnderwater, YieldSummary bonusYield)
{
_propertyConsidered = CellPropertyType.CellIsUnderwater;
_mustBeUnderwater = mustBeUnderwater;
_bonusYield = bonusYield;
_terrainRequired = CellTerrain.Grassland;
_shapeRequired = CellShape.Flatlands;
_vegetationRequired = CellVegetation.None;
}
public void MultiplicationOperatorSummaries_MultipliesComponents()
{
var firstSummary = new YieldSummary(food: 1, production: 2, gold: -1, culture: 0);
var secondSummary = new YieldSummary(food: 3, production: 4, gold: 2, culture: 10);
Assert.AreEqual(
new YieldSummary(food: 3, production: 8, gold: -2, culture: 0),
firstSummary * secondSummary,
"Operator *(ResourceSummary, ResourceSummary) did not return a pairwise multiplication of its operands"
);
}
private ICity BuildCity(YieldSummary yield)
{
var mockCity = new Mock <ICity>();
var newCity = mockCity.Object;
MockGenerationLogic.Setup(logic => logic.GetTotalYieldForCity(newCity)).Returns(yield);
AllCities.Add(newCity);
return(newCity);
}
public YieldSummary GetYieldOfCivilization(ICivilization civ)
{
YieldSummary retval = YieldSummary.Empty;
foreach (var city in CityPossessionCanon.GetPossessionsOfOwner(civ))
{
retval += ResourceYieldLogic.GetTotalYieldForCity(city);
}
retval -= new YieldSummary(gold: UnitMaintenanceLogic.GetMaintenanceOfUnitsForCiv(civ));
return(retval);
}
private IResourceDefinition BuildResourceDefinition(
IImprovementTemplate extractor, YieldSummary bonusYieldBase,
YieldSummary bonusYieldWhenImproved
)
{
var mockResource = new Mock <IResourceDefinition>();
mockResource.Setup(resource => resource.Extractor).Returns(extractor);
mockResource.Setup(resource => resource.BonusYieldBase).Returns(bonusYieldBase);
mockResource.Setup(resource => resource.BonusYieldWhenImproved).Returns(bonusYieldWhenImproved);
return(mockResource.Object);
}
public void GetYieldOfCell_AlwaysCallsIntoInherentYield()
{
var cell = BuildCell();
var cellYield = new YieldSummary(food: 1, production: 2, gold: 3);
MockInherentCellYieldLogic.Setup(logic => logic.GetInherentCellYield(cell, false)).Returns(cellYield);
var yieldLogic = Container.Resolve <CellYieldLogic>();
Assert.AreEqual(cellYield, yieldLogic.GetYieldOfCell(cell, null));
MockInherentCellYieldLogic.Verify(logic => logic.GetInherentCellYield(cell, false), Times.Once);
}
public YieldSummary GetYieldOfCell(IHexCell cell, ICivilization perspectiveCiv)
{
if (cell == null)
{
throw new ArgumentNullException("cell");
}
YieldSummary retval = YieldSummary.Empty;
ICity cityOwningCell = CellPossessionCanon.GetOwnerOfPossession(cell);
retval += InherentYieldLogic.GetInherentCellYield(cell, false);
var nodeAtLocation = NodePositionCanon.GetPossessionsOfOwner(cell).FirstOrDefault();
var visibleResources = TechCanon.GetResourcesVisibleToCiv(perspectiveCiv);
var improvementOnCell = ImprovementLocationCanon.GetPossessionsOfOwner(cell).FirstOrDefault();
var discoveredTechs = TechCanon.GetTechsDiscoveredByCiv(perspectiveCiv);
bool hasFreshWater = FreshWaterCanon.HasAccessToFreshWater(cell);
if (cityOwningCell != null)
{
var buildingsOnCell = BuildingPossessionCanon.GetPossessionsOfOwner(cityOwningCell)
.Select(building => building.Template);
retval += BuildingYieldLogic.GetBonusCellYieldFromBuildings(cell, buildingsOnCell);
}
if (nodeAtLocation != null)
{
retval += NodeYieldLogic.GetYieldFromNode(nodeAtLocation, visibleResources, improvementOnCell);
}
if (improvementOnCell != null)
{
retval += ImprovementYieldLogic.GetYieldOfImprovement(
improvementOnCell, nodeAtLocation, visibleResources, discoveredTechs, hasFreshWater
);
}
if (perspectiveCiv != null && GoldenAgeCanon.IsCivInGoldenAge(perspectiveCiv) && retval[YieldType.Gold] > 0f)
{
retval[YieldType.Gold] += CivConfig.GoldenAgeBonusGoldOnCells;
}
return(retval);
}
public void GetYieldOfCell_CallsIntoImprovementYieldIfCellHasImprovement()
{
var cell = BuildCell(true);
var visibleResources = new List <IResourceDefinition>()
{
BuildResourceDefinition(), BuildResourceDefinition()
};
var discoveredTechs = new List <ITechDefinition>()
{
BuildTechDefinition(), BuildTechDefinition(),
};
var civ = BuildCivilization(visibleResources, discoveredTechs);
var node = BuildResourceNode(cell);
var improvement = BuildImprovement(cell);
var improvementYield = new YieldSummary(food: 5, production: 4, gold: 3);
MockImprovementYieldLogic.Setup(
logic => logic.GetYieldOfImprovement(
improvement, node, It.IsAny <IEnumerable <IResourceDefinition> >(),
It.IsAny <IEnumerable <ITechDefinition> >(), It.IsAny <bool>()
)
).Returns(improvementYield);
var yieldLogic = Container.Resolve <CellYieldLogic>();
Assert.AreEqual(improvementYield, yieldLogic.GetYieldOfCell(cell, civ));
MockImprovementYieldLogic.Verify(
logic => logic.GetYieldOfImprovement(
improvement, node,
It.Is <IEnumerable <IResourceDefinition> >(
resources => resources.SequenceEqual(visibleResources)
),
It.Is <IEnumerable <ITechDefinition> >(
techs => techs.SequenceEqual(discoveredTechs)
),
true
),
Times.Once
);
}
private void BringYieldTypeToMin(
YieldType type, float minYield, HomelandData homelandData,
ref YieldSummary currentYield
)
{
float yieldDeficit = minYield - currentYield[type];
var strategyWeightsByRegion = new Dictionary <MapRegion, Dictionary <IBalanceStrategy, int> >();
foreach (var region in homelandData.AllRegions)
{
strategyWeightsByRegion[region] = homelandData.GetDataOfRegion(region).GetBalanceStrategyWeights();
}
int iterations = homelandData.AllRegions.Count() * 10;
List <MapRegion> regions = homelandData.AllRegions.ToList();
while (yieldDeficit > 0 && iterations-- > 0)
{
if (regions.Count == 0)
{
regions = homelandData.AllRegions.ToList();
}
var region = regions.Random();
regions.Remove(region);
var strategyWeights = strategyWeightsByRegion[region];
var strategy = GetStrategy(strategyWeights);
YieldSummary yieldAdded;
if (strategy.TryIncreaseYield(region, homelandData.GetDataOfRegion(region), type, out yieldAdded))
{
yieldDeficit -= yieldAdded[type];
currentYield += yieldAdded;
}
}
if (currentYield[type] < minYield)
{
Debug.LogWarningFormat("Failed to bring yield type {0} to min yield {1}", type, minYield);
}
}
public void GetYieldOfCell_IgnoresBonusGoldIfCellDoesntProduceGold()
{
var cell = BuildCell();
var cellYield = new YieldSummary(food: 1, production: 2);
MockInherentCellYieldLogic.Setup(logic => logic.GetInherentCellYield(cell, false)).Returns(cellYield);
MockCivConfig.Setup(config => config.GoldenAgeBonusGoldOnCells).Returns(3);
var civ = BuildCivilization(new List <IResourceDefinition>(), new List <ITechDefinition>(), true);
var yieldLogic = Container.Resolve <CellYieldLogic>();
Assert.AreEqual(
new YieldSummary(food: 1f, production: 2f), yieldLogic.GetYieldOfCell(cell, civ)
);
}
public void GetYieldOfCell_AddsConfiguredBonusGoldIfCellProducesGold_AndPerspectiveCivInAGoldenAge()
{
var cell = BuildCell();
var cellYield = new YieldSummary(food: 1, production: 2, gold: 3);
MockInherentCellYieldLogic.Setup(logic => logic.GetInherentCellYield(cell, false)).Returns(cellYield);
MockCivConfig.Setup(config => config.GoldenAgeBonusGoldOnCells).Returns(3);
var civ = BuildCivilization(new List <IResourceDefinition>(), new List <ITechDefinition>(), true);
var yieldLogic = Container.Resolve <CellYieldLogic>();
Assert.AreEqual(
new YieldSummary(food: 1f, production: 2f, gold: 6f), yieldLogic.GetYieldOfCell(cell, civ)
);
}
public string GetTMProFormattedYieldString(
YieldSummary summary, IEnumerable <YieldType> typesToDisplay,
bool includeEmptyValues = false, bool plusOnPositiveNumbers = true
)
{
if (includeEmptyValues)
{
return(GetTMProFormattedYieldString(
summary, typesToDisplay, plusOnPositiveNumbers
));
}
else
{
return(GetTMProFormattedYieldString(
summary, typesToDisplay.Where(type => summary[type] != 0f),
plusOnPositiveNumbers
));
}
}
public void DivisionOperatorFloat_DividesComponentsByCoefficientAndRounds()
{
var summary = new YieldSummary(food: 2, production: 2, gold: 2);
var copyOfSummary = new YieldSummary(summary);
var divOne = summary / 2f;
var divTwo = summary / 3.5f;
var divThree = summary / -4.2f;
foreach (var resourceType in EnumUtil.GetValues <YieldType>())
{
Assert.AreEqual(summary[resourceType] / 2f, divOne[resourceType], "DivOne has an incorrect value");
Assert.AreEqual(summary[resourceType] / 3.5f, divTwo[resourceType], "DivTwo has an incorrect value");
Assert.AreEqual(summary[resourceType] / -4.2f, divThree[resourceType], "DivThree has an incorrect value");
Assert.AreEqual(copyOfSummary[resourceType], summary[resourceType],
"Summary's value was changed by the addition operations");
}
}
public void MultiplicationOperatorFloat_MultipliesComponentsByCoefficientAndRounds()
{
var summary = new YieldSummary(food: 1, production: 1, gold: 1);
var copyOfSummary = new YieldSummary(summary);
var multOne = summary * 1f;
var multTwo = summary * 1.4f;
var multThree = summary * -1.7f;
foreach (var resourceType in EnumUtil.GetValues <YieldType>())
{
Assert.AreEqual(summary[resourceType] * 1f, multOne[resourceType], "MultOne has an incorrect value");
Assert.AreEqual(summary[resourceType] * 1.4f, multTwo[resourceType], "MultTwo has an incorrect value");
Assert.AreEqual(summary[resourceType] * -1.7f, multThree[resourceType], "MultThree has an incorrect value");
Assert.AreEqual(copyOfSummary[resourceType], summary[resourceType],
"Summary's value was changed by the addition operations");
}
}
public bool TryIncreaseYield(
MapRegion region, RegionData regionData, YieldType type, out YieldSummary yieldAdded
)
{
var availableResources = BonusResourcesWithYield[type].ToList();
while (availableResources.Count > 0)
{
var chosenResource = ResourceRandomSampler.SampleElementsFromSet(
availableResources, 1, GetResourceSelectionWeightFunction(region, regionData)
).FirstOrDefault();
if (chosenResource == null)
{
break;
}
var cell = CellRandomSampler.SampleElementsFromSet(
region.Cells, 1, GetCellPlacementWeightFunction(chosenResource)
).FirstOrDefault();
if (cell != null)
{
var oldYield = YieldEstimator.GetYieldEstimateForCell(cell, TechCanon.AvailableTechs);
int copies = chosenResource.Type == ResourceType.Strategic
? StrategicCopiesLogic.GetWeightedRandomCopies()
: 0;
ResourceNodeFactory.BuildNode(cell, chosenResource, copies);
yieldAdded = YieldEstimator.GetYieldEstimateForCell(cell, TechCanon.AvailableTechs) - oldYield;
return(true);
}
else
{
availableResources.Remove(chosenResource);
}
}
yieldAdded = YieldSummary.Empty;
return(false);
}
public YieldSummary GetYieldEstimateForCell(IHexCell cell, CachedTechData techData)
{
var retval = YieldSummary.Empty;
var nodeAtLocation = NodeLocationCanon.GetPossessionsOfOwner(cell).FirstOrDefault();
var validImprovements = GetImprovementsValidFor(
cell, nodeAtLocation, techData.VisibleResources, techData.AvailableImprovements
);
var yieldOfImprovements = validImprovements.Select(
improvement => GetYieldEstimateForCellWithImprovement(
cell, nodeAtLocation, techData.VisibleResources, techData.ImprovementModifications,
techData.AvailableBuildingMods, improvement
)
);
YieldSummary bestYield = YieldSummary.Empty;
float bestScore = int.MinValue;
if (yieldOfImprovements.Any())
{
foreach (var yield in yieldOfImprovements)
{
var score = MapScorer.GetScoreOfYield(yield);
if (score > bestScore)
{
bestYield = yield;
bestScore = score;
}
}
}
else
{
bestYield = GetYieldEstimateForCellWithImprovement(
cell, nodeAtLocation, techData.VisibleResources,
techData.ImprovementModifications, techData.AvailableBuildingMods, null
);
}
return(bestYield);
}
public void MultiplicationOperatorInt_MultipliesComponentsByCoefficient()
{
var summary = new YieldSummary(food: 3, production: 2, gold: 0);
var copyOfSummary = new YieldSummary(summary);
var multOne = summary * 6;
var multTwo = summary * 19;
var multThree = summary * -7;
foreach (var resourceType in EnumUtil.GetValues <YieldType>())
{
Assert.AreEqual(summary[resourceType] * 6, multOne[resourceType], "MultOne has an incorrect value");
Assert.AreEqual(summary[resourceType] * 19, multTwo[resourceType], "MultTwo has an incorrect value");
Assert.AreEqual(summary[resourceType] * -7, multThree[resourceType], "MultThree has an incorrect value");
Assert.AreEqual(copyOfSummary[resourceType], summary[resourceType],
"Summary's value was changed by the addition operations");
}
}
