private bool IsUnitInFriendlyTerritory(IUnit unit)
{
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
return(unitLocation != null && unitOwner == CivTerritoryLogic.GetCivClaimingCell(unitLocation));
}
public bool IsCityConnectedToCapital(ICity city)
{
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(city);
var capitalOfOwner = CapitalCityCanon.GetCapitalOfCiv(cityOwner);
if (capitalOfOwner == city)
{
return(true);
}
if (capitalOfOwner == null)
{
return(false);
}
var cityLocation = CityLocationCanon.GetOwnerOfPossession(city);
var capitalLocation = CityLocationCanon.GetOwnerOfPossession(capitalOfOwner);
var pathTo = HexPathfinder.GetShortestPathBetween(
cityLocation, capitalLocation, ConnectionPathCostLogic.BuildCapitalConnectionPathCostFunction(cityOwner)
);
return(pathTo != null);
}
public bool CanPlaceUnitAtLocation(IUnit unit, IHexCell location, bool isMeleeAttacking)
{
if (location == null)
{
return(true);
}
isMeleeAttacking &= unit.Type != UnitType.Civilian;
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
if (IsCellImpassableFor(unit.MovementSummary, location, unitOwner, isMeleeAttacking))
{
return(false);
}
else if (CellHasDomesticUnits(location, unitOwner))
{
return(!LocationHasUnitBlockingType(location, unit.Type));
}
else if (CellHasForeignUnits(location, unitOwner))
{
return(isMeleeAttacking);
}
else
{
return(true);
}
}
public bool AreCivilizationsConnected(ICivilization civOne, ICivilization civTwo)
{
var capitalOne = CapitalCityCanon.GetCapitalOfCiv(civOne);
var capitalTwo = CapitalCityCanon.GetCapitalOfCiv(civTwo);
var capitalOneLocation = CityLocationCanon.GetOwnerOfPossession(capitalOne);
var capitalTwoLocation = CityLocationCanon.GetOwnerOfPossession(capitalTwo);
return(HexPathfinder.GetShortestPathBetween(
capitalOneLocation, capitalTwoLocation, ConnectionPathCostLogic.BuildCivConnectionPathCostFunction(civOne, civTwo)
) != null);
}
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);
}
private void OnCityGainedBuilding(Tuple <ICity, IBuilding> data)
{
var city = data.Item1;
var building = data.Item2;
var cityLocation = CityLocationCanon.GetOwnerOfPossession(city);
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(city);
foreach (var templateToBuild in building.Template.FreeUnits)
{
var validCell = GetValidNearbyCell(cityLocation, templateToBuild, cityOwner);
UnitFactory.BuildUnit(validCell, templateToBuild, cityOwner);
}
}
public YieldSummary GetYieldOfCellForCity(IHexCell cell, ICity city)
{
if (cell == null)
{
throw new ArgumentNullException("slot");
}
else if (city == null)
{
throw new ArgumentNullException("city");
}
ICivilization owner = CityPossessionCanon.GetOwnerOfPossession(city);
return(CellYieldLogic.GetYieldOfCell(cell, owner) * GetMultiplier(city));
}
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 void ComposeUnits(SerializableMapData mapData)
{
mapData.Units = new List <SerializableUnitData>();
foreach (var unit in UnitFactory.AllUnits)
{
if (unit.Type == UnitType.City)
{
continue;
}
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
var unitData = new SerializableUnitData()
{
Location = unitLocation.Coordinates,
Template = unit.Template.name,
Owner = unitOwner.Template.Name,
CurrentMovement = unit.CurrentMovement,
Hitpoints = unit.CurrentHitpoints,
CurrentPath = unit.CurrentPath != null?unit.CurrentPath.Select(cell => cell.Coordinates).ToList() : null,
IsSetUpToBombard = unit.IsSetUpToBombard,
Experience = unit.Experience,
Level = unit.Level,
PromotionTree = PromotionTreeComposer.ComposePromotionTree(unit.PromotionTree)
};
mapData.Units.Add(unitData);
}
}
public bool IsCellValidForCity(IHexCell cell)
{
if (CellPossessionCanon.GetOwnerOfPossession(cell) != null)
{
return(false);
}
if (cell.Terrain.IsWater())
{
return(false);
}
if (cell.Feature != CellFeature.None)
{
return(false);
}
foreach (var city in CityFactory.AllCities)
{
var cityLocation = CityLocationCanon.GetOwnerOfPossession(city);
if (HexGrid.GetDistance(cell, cityLocation) < Config.MinimumSeparation)
{
return(false);
}
}
return(true);
}
public float GetFoodStockpileAdditionFromIncome(ICity city, float foodIncome)
{
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(city);
var ownerHappiness = CivilizationHappinessLogic.GetNetHappinessOfCiv(cityOwner);
float unmodifiedFoodGained;
if (ownerHappiness < 0)
{
if (ownerHappiness > -10)
{
unmodifiedFoodGained = foodIncome / 4f;
}
else
{
unmodifiedFoodGained = 0;
}
}
else
{
unmodifiedFoodGained = foodIncome;
}
float growthModifier = CityModifiers.Growth.GetValueForCity(city);
return(unmodifiedFoodGained * growthModifier);
}
public void PerformDamageOnUnitFromImprovements(IUnit unit)
{
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
float highestDamage = 0f;
foreach (var nearbyCell in Grid.GetCellsInRadius(unitLocation, 1))
{
var ownerOfCell = CivTerritoryLogic.GetCivClaimingCell(nearbyCell);
if (ownerOfCell == null || !WarCanon.AreAtWar(unitOwner, ownerOfCell))
{
continue;
}
foreach (var improvement in ImprovementLocationCanon.GetPossessionsOfOwner(nearbyCell))
{
highestDamage = Mathf.Max(highestDamage, improvement.Template.AdjacentEnemyDamagePercentage);
}
}
if (highestDamage > 0f)
{
unit.CurrentHitpoints -= Mathf.RoundToInt(unit.MaxHitpoints * highestDamage);
}
}
public bool CanHandleCommandOnUnit(AbilityCommandRequest command, IUnit unit)
{
if (command.Type != AbilityCommandType.Pillage)
{
return(false);
}
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
bool hasImprovement = ImprovementLocationCanon.GetPossessionsOfOwner(unitLocation).Any(
improvement => !improvement.IsPillaged
);
if (hasImprovement || unitLocation.HasRoads)
{
var cellOwner = CivTerritoryLogic.GetCivClaimingCell(unitLocation);
return(cellOwner == null || WarCanon.AreAtWar(unitOwner, cellOwner));
}
else
{
return(false);
}
}
private void SetCityToAttack(ICity city)
{
Clear();
CityToAttack = city;
var cityLocation = CityLocationCanon.GetOwnerOfPossession(city);
OverlayManager.ShowOverlayOfCell(cityLocation, CellOverlayType.AttackIndicator);
CombatSummaryDisplay.AttackingUnit = SelectedUnit;
CombatSummaryDisplay.DefendingUnit = city.CombatFacade;
CombatSummaryDisplay.IsMeleeAttack = true;
CombatSummaryDisplay.gameObject.SetActive(true);
CombatSummaryDisplay.Refresh();
}
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 override void Refresh()
{
foreach (var projectRecord in new List <CityProjectRecord>(InstantiatedProjectRecords))
{
Destroy(projectRecord.gameObject);
}
InstantiatedProjectRecords.Clear();
if (ObjectToDisplay == null)
{
return;
}
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(ObjectToDisplay);
if (DisplayType == CityDisplayType.PlayMode)
{
AddUnitProjects(cityOwner);
AddBuildingProjects(
cityOwner, TechCanon.GetResearchedBuildings(cityOwner),
template => ObjectToDisplay.ActiveProject = ProjectFactory.ConstructProject(template)
);
}
else if (DisplayType == CityDisplayType.MapEditor)
{
AddBuildingProjects(
cityOwner, AllBuildingTemplates,
template => BuildingFactory.BuildBuilding(template, ObjectToDisplay)
);
}
}
public void ApplyToMaps(InfluenceMaps maps, ICivilization targetCiv)
{
foreach (var unit in UnitFactory.AllUnits)
{
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
float unitStrength = UnitStrengthEstimator.EstimateUnitStrength(unit);
if (unitOwner == targetCiv)
{
InfluenceMapApplier.ApplyInfluenceToMap(
unitStrength, maps.AllyPresence, unitLocation, AIConfig.UnitMaxInfluenceRadius,
InfluenceMapApplier.PowerOfTwoRolloff, InfluenceMapApplier.ApplySum
);
}
else if (WarCanon.AreAtWar(unitOwner, targetCiv))
{
InfluenceMapApplier.ApplyInfluenceToMap(
unitStrength, maps.EnemyPresence, unitLocation, AIConfig.UnitMaxInfluenceRadius,
InfluenceMapApplier.PowerOfTwoRolloff, InfluenceMapApplier.ApplySum
);
}
}
}
public IEnumerable <IPromotion> GetPromotionsForUnit(IUnit unit)
{
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
return(unit.Template.StartingPromotions
.Concat(GlobalPromotionLogic.GetGlobalPromotionsOfCiv(unitOwner))
.Concat(unit.PromotionTree.GetAllPromotions()));
}
public bool CanSetCapitalOfCiv(ICivilization civ, ICity city)
{
if (civ == null)
{
throw new ArgumentNullException("civ");
}
return(city == null || (GetCapitalOfCiv(civ) != city && CityPossessionCanon.GetOwnerOfPossession(city) == civ));
}
private bool ShouldCombatResultInCitySack(IUnit attacker, IUnit defender, CombatInfo combatInfo)
{
var attackerOwner = UnitPossessionCanon.GetOwnerOfPossession(attacker);
return(attackerOwner.Template.IsBarbaric &&
defender.CurrentHitpoints <= 0 &&
defender.Type == UnitType.City &&
combatInfo.CombatType == CombatType.Melee);
}
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));
}
}
private void OnCityGainedBuilding(Tuple <ICity, IBuilding> data)
{
var city = data.Item1;
var building = data.Item2;
if (building.Template.StartsGoldenAge)
{
TryStartGoldenAge(CityPossessionCanon.GetOwnerOfPossession(city));
}
}
public bool IsCityGarrisoned(ICity city)
{
var cityLocation = CityLocationCanon.GetOwnerOfPossession(city);
var militaryUnitsAt = UnitPositionCanon
.GetPossessionsOfOwner(cityLocation)
.Where(unit => unit.Type != UnitType.Civilian && unit.Type != UnitType.City);
return(militaryUnitsAt.Any());
}
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 void OnMeleeCombatWithUnit(UnitCombatResults results)
{
HandleBounty(results);
if (results.Defender.Type != UnitType.City)
{
return;
}
var attackerOwner = UnitPossessionLogic.GetOwnerOfPossession(results.Attacker);
var defenderOwner = UnitPossessionLogic.GetOwnerOfPossession(results.Defender);
var goldStolen = Mathf.Min(
results.DamageToDefender * results.Attacker.CombatSummary.GoldRaidingPercentage,
defenderOwner.GoldStockpile
);
defenderOwner.GoldStockpile -= Mathf.FloorToInt(goldStolen);
attackerOwner.GoldStockpile += Mathf.FloorToInt(goldStolen);
}
private bool IsConditionMetByAdjacentUnits(IUnit centerUnit)
{
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(centerUnit);
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(centerUnit);
foreach (var adjacentCell in Grid.GetNeighbors(unitLocation))
{
foreach (var adjacentUnit in UnitPositionCanon.GetPossessionsOfOwner(adjacentCell))
{
var adjacentOwner = UnitPossessionCanon.GetOwnerOfPossession(adjacentUnit);
if (adjacentOwner == unitOwner && UnitTypeArguments.Contains(adjacentUnit.Type))
{
return(true);
}
}
}
return(false);
}
public void RazeCity(ICity city)
{
var cityLocation = CityLocationCanon.GetOwnerOfPossession(city);
city.Destroy();
if (cityLocation.Feature == CellFeature.None && CellModLogic.CanChangeFeatureOfCell(cityLocation, CellFeature.CityRuins))
{
CellModLogic.ChangeFeatureOfCell(cityLocation, CellFeature.CityRuins);
}
}
public override bool CanExecuteBetweenCivs(ICivilization fromCiv, ICivilization toCiv)
{
if (CityInput == null)
{
return(false);
}
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(CityInput);
return(cityOwner == fromCiv && CityPossessionCanon.CanChangeOwnerOfPossession(CityInput, toCiv));
}
private bool DoesCellHaveUnitsForeignTo(IHexCell cell, ICivilization domesticCiv)
{
foreach (var unit in UnitPositionCanon.GetPossessionsOfOwner(cell))
{
if (UnitPossessionCanon.GetOwnerOfPossession(unit) != domesticCiv)
{
return(true);
}
}
return(false);
}
protected override void DoOnPossessionEstablished(IBuilding building, ICity newOwner)
{
if (newOwner == null)
{
return;
}
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(newOwner);
foreach (var resource in building.Template.ResourcesConsumed)
{
ResourceLockingCanon.LockCopyOfResourceForCiv(resource, cityOwner);
}
if (building.Template.ProvidesFreeTech)
{
TechCanon.AddFreeTechToCiv(cityOwner);
}
CitySignals.GainedBuilding.OnNext(new Tuple <ICity, IBuilding>(newOwner, building));
}
