public float GetBorderExpansionModifierForCity(ICity city)
{
float localBuildingModifiers = BuildingPossessionCanon.GetPossessionsOfOwner(city).Sum(
building => building.Template.LocalBorderExpansionModifier
);
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(city);
var citiesOfOwner = CityPossessionCanon.GetPossessionsOfOwner(cityOwner).ToArray();
var buildingsOfOwner = new List <IBuilding>();
foreach (var ownedCity in citiesOfOwner)
{
buildingsOfOwner.AddRange(BuildingPossessionCanon.GetPossessionsOfOwner(ownedCity));
}
float globalBuildingModifiers = buildingsOfOwner.Sum(building => building.Template.GlobalBorderExpansionModifier);
var policyBonuses = SocialPolicyCanon.GetPolicyBonusesForCiv(cityOwner);
float policyModifiers = policyBonuses.Sum(bonuses => bonuses.CityBorderExpansionModifier);
if (CapitalCityCanon.GetCapitalOfCiv(cityOwner) == city)
{
policyModifiers += policyBonuses.Sum(bonuses => bonuses.CapitalBorderExpansionModifier);
}
return(1f + localBuildingModifiers + globalBuildingModifiers + policyModifiers);
}
public T GetValueForCity(ICity city)
{
T retval = default(T);
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(city);
var ownerCapital = CapitalCityCanon.GetCapitalOfCiv(cityOwner);
if (city == ownerCapital)
{
IEnumerable <T> capitalValues = SocialPolicyCanon
.GetPolicyBonusesForCiv(cityOwner)
.Select(bonuses => DataForExtraction.PolicyCapitalBonusesExtractor(bonuses));
if (capitalValues.Any())
{
retval = DataForExtraction.Aggregator(
retval, capitalValues.Aggregate(DataForExtraction.Aggregator)
);
}
}
IEnumerable <T> cityValues = SocialPolicyCanon
.GetPolicyBonusesForCiv(cityOwner)
.Select(bonuses => DataForExtraction.PolicyCityBonusesExtractor(bonuses));
if (cityValues.Any())
{
retval = DataForExtraction.Aggregator(
retval, cityValues.Aggregate(DataForExtraction.Aggregator)
);
}
if (DataForExtraction.BuildingLocalBonusesExtractor != null)
{
foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(city))
{
retval = DataForExtraction.Aggregator(
retval, DataForExtraction.BuildingLocalBonusesExtractor(building.Template)
);
}
}
if (DataForExtraction.BuildingGlobalBonusesExtractor != null)
{
foreach (var building in GetGlobalBuildings(cityOwner))
{
retval = DataForExtraction.Aggregator(
retval, DataForExtraction.BuildingGlobalBonusesExtractor(building.Template)
);
}
}
return(DataForExtraction.Aggregator(DataForExtraction.UnitaryValue, retval));
}
public int GetCombatStrengthOfCity(ICity city)
{
int retval = Config.BaseCombatStrength + Mathf.RoundToInt(Config.CombatStrengthPerPopulation * city.Population);
foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(city))
{
retval += building.Template.CityCombatStrengthBonus;
}
return(retval);
}
private bool HillCandidateFilter_ScoreIncreasing(IHexCell cell)
{
if (NodeLocationCanon.GetPossessionsOfOwner(cell).Any())
{
return(false);
}
return(cell.Shape == CellShape.Flatlands && cell.Vegetation == CellVegetation.None && (
cell.Terrain == CellTerrain.Desert || cell.Terrain == CellTerrain.Tundra ||
cell.Terrain == CellTerrain.Snow
));
}
public bool CanHandleCommandOnUnit(AbilityCommandRequest command, IUnit unit)
{
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
bool hasRightType = command.Type == AbilityCommandType.AnnexAdjacentTerritory;
bool unitInOwnerTerritory = CivTerritoryLogic.GetCivClaimingCell(unitLocation) == unitOwner;
bool hasAnyCities = CityPossessionCanon.GetPossessionsOfOwner(unitOwner).Any();
return(hasRightType && unitInOwnerTerritory && hasAnyCities);
}
public void ReturnFocusToPlayer(IPlayer player)
{
var civOfPlayer = player.ControlledCiv;
var capital = CapitalCityCanon.GetCapitalOfCiv(civOfPlayer);
if (capital != null)
{
var capitalLocation = CityLocationCanon.GetOwnerOfPossession(capital);
GameCamera.SnapToCell(capitalLocation);
}
else
{
var unitsOf = UnitPossessionCanon.GetPossessionsOfOwner(civOfPlayer);
var cityBuilder = unitsOf.Where(unit => CanBuildCityLogic.CanUnitBuildCity(unit)).FirstOrDefault();
if (cityBuilder != null)
{
GameCamera.SnapToCell(UnitPositionCanon.GetOwnerOfPossession(cityBuilder));
}
else if (unitsOf.Any())
{
GameCamera.SnapToCell(UnitPositionCanon.GetOwnerOfPossession(unitsOf.FirstOrDefault()));
}
}
}
public T GetValueForCiv(ICivilization civ)
{
var retval = DataForExtraction.UnitaryValue;
var policyBonuses = SocialPolicyCanon.GetPolicyBonusesForCiv(civ);
var policyValues = policyBonuses.Select(bonuses => DataForExtraction.PolicyExtractor(bonuses));
if (policyValues.Any())
{
retval = DataForExtraction.Aggregator(retval, policyValues.Aggregate(DataForExtraction.Aggregator));
}
if (DataForExtraction.GlobalBuildingExtractor != null)
{
var citiesOf = CityPossessionCanon.GetPossessionsOfOwner(civ);
var buildingsOf = citiesOf.SelectMany(
city => BuildingPossessionCanon.GetPossessionsOfOwner(city)
).ToList();
foreach (var building in buildingsOf)
{
retval = DataForExtraction.Aggregator(
retval, DataForExtraction.GlobalBuildingExtractor(building.Template)
);
}
}
return(retval);
}
private Func <IHexCell, bool> GetLakeCandidateFilter(MapRegion region)
{
return(delegate(IHexCell cell) {
if (cell.Terrain != CellTerrain.Snow && cell.Terrain != CellTerrain.Desert &&
!cell.Terrain.IsWater() && ModLogic.CanChangeTerrainOfCell(cell, CellTerrain.FreshWater)
)
{
bool surroundedByLandOrLakes = Grid.GetNeighbors(cell).All(
neighbor => neighbor.Terrain != CellTerrain.ShallowWater &&
neighbor.Terrain != CellTerrain.DeepWater
);
bool hasResourceNode = NodePositionCanon.GetPossessionsOfOwner(cell).Any();
bool fewNearbylakes = Grid.GetCellsInRadius(cell, 2).Count(
nearby => nearby.Terrain == CellTerrain.FreshWater
) < MaxNearbyLakes;
bool noAdjacentDesert = !Grid.GetNeighbors(cell).Any(neighbor => neighbor.Terrain == CellTerrain.Desert);
return surroundedByLandOrLakes && !hasResourceNode && fewNearbylakes && noAdjacentDesert;
}
else
{
return false;
}
});
}
public IEnumerable <IPromotion> GetGlobalPromotionsOfCiv(ICivilization civ)
{
if (civ == null)
{
throw new ArgumentNullException("civ");
}
var retval = new List <IPromotion>();
foreach (var city in CityPossessionCanon.GetPossessionsOfOwner(civ))
{
foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(city))
{
retval.AddRange(building.Template.GlobalPromotions);
}
}
foreach (var policy in SocialPolicyCanon.GetPoliciesUnlockedFor(civ))
{
retval.AddRange(policy.Bonuses.GlobalPromotions);
}
foreach (var policyTree in SocialPolicyCanon.GetTreesUnlockedFor(civ))
{
retval.AddRange(policyTree.UnlockingBonuses.GlobalPromotions);
if (SocialPolicyCanon.IsTreeCompletedByCiv(policyTree, civ))
{
retval.AddRange(policyTree.CompletionBonuses.GlobalPromotions);
}
}
return(retval);
}
public bool IsTemplateValidForCity(IBuildingTemplate template, ICity city, ICivilization cityOwner)
{
if (template.Type != BuildingType.NationalWonder && template.Type != BuildingType.WorldWonder)
{
return(true);
}
var citiesOfOwner = CityPossessionCanon.GetPossessionsOfOwner(cityOwner);
foreach (var otherCity in citiesOfOwner)
{
if (otherCity != city && otherCity.ActiveProject != null && otherCity.ActiveProject.BuildingToConstruct == template)
{
return(false);
}
}
IEnumerable <ICity> citiesToCheck = template.Type == BuildingType.NationalWonder ? citiesOfOwner : CityFactory.AllCities;
foreach (var otherCity in citiesToCheck)
{
var buildingsOf = BuildingPossessionCanon.GetPossessionsOfOwner(otherCity);
if (buildingsOf.Any(building => building.Template == template))
{
return(false);
}
}
return(true);
}
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 override void Refresh()
{
if (ObjectToDisplay == null)
{
return;
}
foreach (var display in InstantiatedDisplays)
{
Destroy(display.gameObject);
}
InstantiatedDisplays.Clear();
foreach (var tile in PossessionCanon.GetPossessionsOfOwner(ObjectToDisplay))
{
if (tile.SuppressSlot)
{
continue;
}
var newSlot = Container.InstantiatePrefabForComponent <WorkerSlotDisplay>(SlotDisplayPrefab);
newSlot.Owner = ObjectToDisplay;
newSlot.SlotToDisplay = tile.WorkerSlot;
newSlot.transform.SetParent(SlotDisplayContainer, false);
newSlot.gameObject.transform.position = Camera.main.WorldToScreenPoint(tile.AbsolutePosition);
newSlot.gameObject.SetActive(true);
InstantiatedDisplays.Add(newSlot);
}
}
/// <inheritdoc/>
public YieldSummary GetYieldMultipliersForCity(ICity city)
{
if (city == null)
{
throw new ArgumentNullException("city");
}
var baseModifier = YieldSummary.Empty;
foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(city))
{
baseModifier += building.CityYieldModifier;
}
return(baseModifier);
}
/// <inheritdoc/>
public YieldSummary GetYieldMultipliersForCivilization(ICivilization civ)
{
if (civ == null)
{
throw new ArgumentNullException("civilization");
}
var retval = YieldSummary.Empty;
foreach (var city in CityPossessionCanon.GetPossessionsOfOwner(civ))
{
foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(city))
{
retval += building.CivilizationYieldModifier;
}
}
int civHappiness = CivHappinessLogic.GetNetHappinessOfCiv(civ);
if (civHappiness < 0)
{
var goldAndProductionLoss = civHappiness * CivConfig.YieldLossPerUnhappiness;
retval[YieldType.Gold] += goldAndProductionLoss;
retval[YieldType.Production] += goldAndProductionLoss;
}
if (GoldenAgeCanon.IsCivInGoldenAge(civ))
{
retval += CivConfig.GoldenAgeProductionModifiers;
}
return(retval);
}
public bool ShouldCivBeDefeated(ICivilization civ)
{
if (!IsActive || !CivsToCheck.Contains(civ))
{
return(false);
}
var citiesOfCiv = CityPossessionCanon.GetPossessionsOfOwner(civ);
var unitsOfCiv = UnitPossessionCanon.GetPossessionsOfOwner(civ);
if (CivConfig.DefeatMode == CivilizationDefeatMode.NoMoreCities)
{
var settlers = unitsOfCiv.Where(unit => CanBuildCityLogic.CanUnitBuildCity(unit));
return(!citiesOfCiv.Any() && !settlers.Any());
}
else if (CivConfig.DefeatMode == CivilizationDefeatMode.NoMoreCitiesOrUnits)
{
return(!citiesOfCiv.Any() && !unitsOfCiv.Any());
}
else
{
throw new NotImplementedException();
}
}
private bool IsUnitInCity(IUnit unit)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
var cityAtLocation = CityLocationCanon.GetPossessionsOfOwner(unitLocation).FirstOrDefault();
return(cityAtLocation != null);
}
private void OnCityBeingDestroyed(ICity city)
{
foreach (var building in PossessionCanon.GetPossessionsOfOwner(city).ToArray())
{
DestroyBuilding(building);
}
}
private bool CandidateFilter(IHexCell cell)
{
return(!RiverCanon.HasRiver(cell) &&
!NodeLocationCanon.GetPossessionsOfOwner(cell).Any() &&
ModLogic.CanChangeTerrainOfCell(cell, CellTerrain.ShallowWater) &&
Grid.GetNeighbors(cell).Any(neighbor => neighbor.Terrain == CellTerrain.ShallowWater) &&
!Grid.GetNeighbors(cell).Any(neighbor => neighbor.Terrain == CellTerrain.FreshWater));
}
/// <inheritdoc/>
public IEnumerable <IHexCell> GetAllCellsAvailableToCity(ICity city)
{
var retval = new HashSet <IHexCell>();
foreach (var tile in PossessionCanon.GetPossessionsOfOwner(city))
{
foreach (var neighbor in HexGrid.GetNeighbors(tile))
{
if (IsCellAvailable(city, neighbor))
{
retval.Add(neighbor);
}
}
}
return(retval);
}
public bool IsUnitGarrisoned(IUnit unit)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
var citiesAt = CityLocationCanon.GetPossessionsOfOwner(unitLocation);
return(citiesAt.Any());
}
private void OnCellBecameExploredByCiv(Tuple <IHexCell, ICivilization> data)
{
var cityAtCell = CityLocationCanon.GetPossessionsOfOwner(data.Item1).FirstOrDefault();
if (cityAtCell != null && ExplorationCanon.IsCellExplored(data.Item1))
{
CitySummaryManager.BuildSummaryForCity(cityAtCell);
}
}
public override void Refresh()
{
if (ObjectToDisplay == null)
{
return;
}
DisplayBuildings(PossessionCanon.GetPossessionsOfOwner(ObjectToDisplay));
}
private void OnImprovementRemovedFromLocation(Tuple <IImprovement, IHexCell> dataTuple)
{
var location = dataTuple.Item2;
var nodeAtLocation = ResourceNodeLocationCanon.GetPossessionsOfOwner(location).FirstOrDefault();
if (nodeAtLocation == null)
{
return;
}
var civOwningCell = CivTerritoryLogic.GetCivClaimingCell(location);
if (civOwningCell != null)
{
ResourceTransferCanon.SynchronizeResourceForCiv(nodeAtLocation.Resource, civOwningCell);
}
}
private bool IsMovementValidForConnection(IHexCell fromCell, IHexCell toCell, ICivilization civOne, ICivilization civTwo)
{
if (toCell.Terrain.IsWater())
{
if (fromCell.Terrain.IsWater())
{
return(true);
}
var cityAtFromCell = CityLocationCanon.GetPossessionsOfOwner(fromCell).FirstOrDefault();
if (cityAtFromCell == null)
{
return(false);
}
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(cityAtFromCell);
if (cityOwner != civOne && cityOwner != civTwo)
{
return(false);
}
return(IsCityValidHarbor(cityAtFromCell));
}
else if (toCell.HasRoads)
{
return(true);
}
else
{
var cityAtToCell = CityLocationCanon.GetPossessionsOfOwner(toCell).FirstOrDefault();
if (cityAtToCell == null)
{
return(false);
}
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(cityAtToCell);
if (cityOwner != civOne && cityOwner != civTwo)
{
return(false);
}
return(!fromCell.Terrain.IsWater() || toCell.Terrain.IsWater() || IsCityValidHarbor(cityAtToCell));
}
}
public void SubscribeFreeBuildingToCiv(
IEnumerable <IBuildingTemplate> validTemplates, ICivilization civ
)
{
if (IsActive)
{
foreach (var city in CityPossessionCanon.GetPossessionsOfOwner(civ))
{
if (FreeBuildingApplier.CanApplyFreeBuildingToCity(validTemplates, city))
{
FreeBuildingApplier.ApplyFreeBuildingToCity(validTemplates, city);
return;
}
}
}
PendingFreeBuildingsOfCiv.AddElementToList(civ, validTemplates);
}
public float GetNextGoldenAgeCostForCiv(ICivilization civ)
{
int cityCount = CityPossessionCanon.GetPossessionsOfOwner(civ).Count();
float modifierFromCities = 1f + cityCount * CivConfig.GoldenAgePerCityMultiplier;
float costFromPreviousAges = CivConfig.GoldenAgeCostPerPreviousAge * GetPreviousGoldenAgesForCiv(civ);
return((CivConfig.GoldenAgeBaseCost + costFromPreviousAges) * modifierFromCities);
}
public IEnumerable <IHexCell> GetCellsClaimedByCiv(ICivilization civ)
{
var retval = new List <IHexCell>();
foreach (var city in CityPossessionCanon.GetPossessionsOfOwner(civ))
{
retval.AddRange(CityTerritoryCanon.GetPossessionsOfOwner(city));
}
return(retval);
}
public int GetStartingExperienceForUnit(IUnit unit, ICity producingCity)
{
int retval = 0;
foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(producingCity))
{
retval += building.Template.BonusExperience;
}
return(retval);
}
public int GetLocalHappinessOfCity(ICity city)
{
if (city == null)
{
throw new ArgumentNullException("city");
}
int retval = 0;
foreach (var building in BuildingPossessionCanon.GetPossessionsOfOwner(city))
{
retval += building.Template.LocalHappiness;
}
retval += Mathf.FloorToInt(
city.Population * CityModifiers.PerPopulationHappiness.GetValueForCity(city)
);
return(retval);
}
private IEnumerable <IBuilding> GetGlobalBuildings(ICivilization civ)
{
var retval = new List <IBuilding>();
foreach (var city in CityPossessionCanon.GetPossessionsOfOwner(civ))
{
retval.AddRange(BuildingPossessionCanon.GetPossessionsOfOwner(city));
}
return(retval);
}