private bool IsUnitInCity(IUnit unit)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
var cityAtLocation = CityLocationCanon.GetPossessionsOfOwner(unitLocation).FirstOrDefault();
return(cityAtLocation != null);
}
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 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);
}
}
public float GetUtilityForUnit(IUnit unit, InfluenceMaps maps)
{
if (!unit.CanAttack)
{
return(0f);
}
IEnumerable <IHexCell> attackCandidates = null;
if (unit.RangedAttackStrength > 0)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
attackCandidates = Grid.GetCellsInRadius(unitLocation, unit.AttackRange)
.Where(FilterLogic.GetRangedAttackFilter(unit));
}
else
{
attackCandidates = UnitVisibilityLogic.GetCellsVisibleToUnit(unit)
.Where(FilterLogic.GetMeleeAttackFilter(unit));
}
if (attackCandidates.Any())
{
return(attackCandidates.Max(UtilityLogic.GetAttackUtilityFunction(unit, maps)));
}
else
{
return(0f);
}
}
public float GetUtilityForUnit(IUnit unit, InfluenceMaps maps)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
return(Grid.GetCellsInRadius(unitLocation, Mathf.RoundToInt(unit.MaxMovement)).Max(
UtilityLogic.GetPillageUtilityFunction(unit, maps)
));
}
public bool CanHandleCommandOnUnit(AbilityCommandRequest command, IUnit unit)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
return(command.Type == AbilityCommandType.BuildRoad &&
unitLocation != null &&
!unitLocation.HasRoads);
}
public void RefreshPosition()
{
var occupiedCell = PositionCanon.GetOwnerOfPossession(this);
if (occupiedCell != null)
{
transform.position = Grid.PerformIntersectionWithTerrainSurface(occupiedCell.AbsolutePosition);
}
}
public float GetUtilityForUnit(IUnit unit, InfluenceMaps maps)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
float unitStrength = UnitStrengthEstimator.EstimateUnitDefensiveStrength(unit, unitLocation);
float logisticX = maps.EnemyPresence[unitLocation.Index] - maps.AllyPresence[unitLocation.Index];
var logistic = AIMath.NormalizedLogisticCurve(unitStrength, BarbarianConfig.FleeUtilityLogisticSlope, logisticX);
return(logistic);
}
public bool CanHandleCommandOnUnit(AbilityCommandRequest command, IUnit unit)
{
if (command.Type == AbilityCommandType.FoundCity)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
return(CityValidityLogic.IsCellValidForCity(unitLocation));
}
else
{
return(false);
}
}
public bool CanHandleCommandOnUnit(AbilityCommandRequest command, IUnit unit)
{
if (command.Type == AbilityCommandType.ClearVegetation)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
return(unitLocation.Vegetation.ToString().Equals(command.ArgsToPass.FirstOrDefault()));
}
else
{
return(false);
}
}
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 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 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 void Refresh()
{
if (AttackingUnit != null && DefendingUnit != null)
{
var defenderLocation = UnitPositionCanon.GetOwnerOfPossession(DefendingUnit);
var estimatedCombat = IsMeleeAttack
? CombatEstimator.EstimateMeleeAttackResults(AttackingUnit, DefendingUnit, defenderLocation)
: CombatEstimator.EstimateRangedAttackResults(AttackingUnit, DefendingUnit, defenderLocation);
AttackerNameField.text = AttackingUnit.Name;
AttackerDamageSufferedField.text = estimatedCombat.DamageToAttacker.ToString();
AttackerHealthLeftField.text = (AttackingUnit.CurrentHitpoints - estimatedCombat.DamageToAttacker).ToString();
AttackerExpectedHealthSlider.minValue = 0;
AttackerExpectedHealthSlider.maxValue = AttackingUnit.MaxHitpoints;
AttackerExpectedHealthSlider.value = AttackingUnit.CurrentHitpoints - estimatedCombat.DamageToAttacker;
DefenderNameField.text = DefendingUnit.Name;
DefenderDamageSufferedField.text = estimatedCombat.DamageToDefender.ToString();
DefenderHealthLeftField.text = (DefendingUnit.CurrentHitpoints - estimatedCombat.DamageToDefender).ToString();
DefenderExpectedHealthSlider.minValue = 0;
DefenderExpectedHealthSlider.maxValue = DefendingUnit.MaxHitpoints;
DefenderExpectedHealthSlider.value = DefendingUnit.CurrentHitpoints - estimatedCombat.DamageToDefender;
}
}
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 void HandleCommandOnUnit(AbilityCommandRequest command, IUnit unit)
{
if (!CanHandleCommandOnUnit(command, unit))
{
throw new InvalidOperationException("Cannot handle command");
}
if (CanHandleWithExistingSite(command, unit))
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
unit.LockIntoConstruction();
var improvementOnCell = ImprovementLocationCanon.GetPossessionsOfOwner(unitLocation).FirstOrDefault();
improvementOnCell.WorkInvested += ImprovementWorkLogic.GetWorkOfUnitOnImprovement(unit, improvementOnCell);
if (improvementOnCell.IsReadyToConstruct)
{
improvementOnCell.Construct();
}
}
else
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
var templateOfName = GetTemplateOfName(command.ArgsToPass.FirstOrDefault());
var improvementAtLocation = ImprovementLocationCanon.GetPossessionsOfOwner(unitLocation).FirstOrDefault();
if (improvementAtLocation != null)
{
ImprovementLocationCanon.ChangeOwnerOfPossession(improvementAtLocation, null);
improvementAtLocation.Destroy();
}
var newImprovement = ImprovementFactory.BuildImprovement(templateOfName, unitLocation);
unit.LockIntoConstruction();
newImprovement.WorkInvested += ImprovementWorkLogic.GetWorkOfUnitOnImprovement(unit, newImprovement);
if (newImprovement.IsReadyToConstruct)
{
newImprovement.Construct();
}
}
}
public float GetUtilityForUnit(IUnit unit, InfluenceMaps maps)
{
var unitPosition = UnitPositionCanon.GetOwnerOfPossession(unit);
if (EncampmentLocationCanon.GetPossessionsOfOwner(unitPosition).Any())
{
return(BarbarianConfig.StayInEncampmentUtility);
}
else if (Grid.GetCellsInRadius(unitPosition, BarbarianConfig.DefendEncampmentRadius).Any(HasUndefendedEncampment))
{
return(BarbarianConfig.HeadTowardsEncampmentUtility);
}
else
{
return(0f);
}
}
private void SetUnitToAttack(IUnit unit)
{
Clear();
UnitToAttack = unit;
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(UnitToAttack);
OverlayManager.ShowOverlayOfCell(unitLocation, CellOverlayType.AttackIndicator);
CombatSummaryDisplay.AttackingUnit = SelectedUnit;
CombatSummaryDisplay.DefendingUnit = unit;
CombatSummaryDisplay.IsMeleeAttack = true;
CombatSummaryDisplay.gameObject.SetActive(true);
CombatSummaryDisplay.Refresh();
}
public bool IsUnitGarrisoned(IUnit unit)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
var citiesAt = CityLocationCanon.GetPossessionsOfOwner(unitLocation);
return(citiesAt.Any());
}
public Func <IHexCell, int> GetWanderWeightFunction(IUnit unit, InfluenceMaps maps)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
return(delegate(IHexCell cell) {
if (cell == unitLocation || !UnitPositionCanon.CanPlaceUnitAtLocation(unit, cell, false))
{
return 0;
}
else
{
float fromDistance = Grid.GetDistance(cell, unitLocation) * BarbarianConfig.WanderSelectionWeight_Distance;
float fromAllies = -maps.AllyPresence [cell.Index] * BarbarianConfig.WanderSelectionWeight_Allies;
float fromEnemies = -maps.EnemyPresence[cell.Index] * BarbarianConfig.WanderSelectionWeight_Enemies;
return Math.Max(0, Mathf.RoundToInt(fromDistance + fromAllies + fromEnemies));
}
});
}
public Func <IHexCell, float> GetPillageUtilityFunction(IUnit unit, InfluenceMaps maps)
{
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
return(delegate(IHexCell cell) {
float divisor = Grid.GetDistance(unitLocation, cell) + 1;
return Mathf.Clamp01(maps.PillagingValue[cell.Index] * BarbarianConfig.PillageUtilityCoefficient / divisor);
});
}
public float GetUtilityForUnit(IUnit unit, InfluenceMaps maps)
{
var unitPosition = UnitPositionCanon.GetOwnerOfPossession(unit);
var reachableCells = HexPathfinder.GetAllCellsReachableIn(
unitPosition, unit.CurrentMovement,
(current, next) => UnitPositionCanon.GetTraversalCostForUnit(unit, current, next, true),
Grid.Cells
);
if (reachableCells.Keys.Any(FilterLogic.GetCaptureCivilianFilter(unit)))
{
return(BarbarianConfig.CaptureCivilianUtility);
}
else
{
return(0f);
}
}
public void StartExecution()
{
if (DesiredLocation == null)
{
throw new InvalidOperationException("Cannot execute while DesiredLocation is null");
}
Status = CommandStatus.Running;
UnitToMove.CurrentPath = null;
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(UnitToMove);
if (unitLocation == null)
{
throw new InvalidOperationException("Cannot move a unit with a null location");
}
if (unitLocation == DesiredLocation)
{
Status = CommandStatus.Succeeded;
}
else
{
var pathTo = HexPathfinder.GetShortestPathBetween(
unitLocation, DesiredLocation,
(current, next) => UnitPositionCanon.GetTraversalCostForUnit(UnitToMove, current, next, false)
);
if (pathTo != null)
{
UnitToMove.CurrentPath = pathTo;
UnitToMove.PerformMovement(false, OnUnitFinishedMovement);
}
else
{
Status = CommandStatus.Failed;
}
}
}
public bool CanHandleCommandOnUnit(AbilityCommandRequest command, IUnit unit)
{
if (command.Type != AbilityCommandType.HurryProduction)
{
return(false);
}
var unitLocation = UnitPositionCanon.GetOwnerOfPossession(unit);
var cityAtLocation = CityLocationCanon.GetPossessionsOfOwner(unitLocation).FirstOrDefault();
if (cityAtLocation == null || cityAtLocation.ActiveProject == null)
{
return(false);
}
var unitOwner = UnitPossessionCanon.GetOwnerOfPossession(unit);
var cityOwner = CityPossessionCanon.GetOwnerOfPossession(cityAtLocation);
return(unitOwner == cityOwner);
}
private void OnUnitBeingDestroyed(IUnit unit)
{
if (UnitPositionCanon.GetOwnerOfPossession(unit) != null)
{
UnitPositionCanon.ChangeOwnerOfPossession(unit, null);
}
if (UnitPossessionCanon.GetOwnerOfPossession(unit) != null)
{
UnitPossessionCanon.ChangeOwnerOfPossession(unit, null);
}
}
public void RespondToCombat(IUnit attacker, IUnit defender, CombatInfo combatInfo)
{
if (!attacker.CombatSummary.CanMoveAfterAttacking)
{
attacker.CurrentMovement = 0;
}
else if (combatInfo.CombatType == CombatType.Melee)
{
var attackerLocation = UnitPositionCanon.GetOwnerOfPossession(attacker);
var defenderLocation = UnitPositionCanon.GetOwnerOfPossession(defender);
var costToMove = UnitPositionCanon.GetTraversalCostForUnit(
attacker, attackerLocation, defenderLocation, true
);
attacker.CurrentMovement = Math.Max(0, attacker.CurrentMovement - costToMove);
}
else if (combatInfo.CombatType == CombatType.Ranged)
{
attacker.CurrentMovement--;
}
}
public bool IsMeleeAttackValid(IUnit attacker, IUnit defender)
{
if (!CommonAttackValidityLogic.DoesAttackMeetCommonConditions(attacker, defender))
{
return(false);
}
var attackerLocation = UnitPositionCanon.GetOwnerOfPossession(attacker);
var defenderLocation = UnitPositionCanon.GetOwnerOfPossession(defender);
if (defenderLocation == null)
{
return(false);
}
var shortestPath = HexPathfinder.GetShortestPathBetween(
attackerLocation, defenderLocation, attacker.CurrentMovement,
(current, next) => UnitPositionCanon.GetTraversalCostForUnit(attacker, current, next, true),
Grid.Cells
);
if (shortestPath == null)
{
return(false);
}
if (!LineOfSightLogic.GetCellsVisibleToUnit(attacker).Contains(defenderLocation))
{
return(false);
}
if (attacker.CombatStrength <= 0)
{
return(false);
}
return(true);
}
public void ApplyCityModifiersToCombat(IUnit attacker, IUnit defender, CombatInfo combatInfo)
{
if (attacker.Type == UnitType.City)
{
var attackerLocation = UnitPositionCanon.GetOwnerOfPossession(attacker);
var cityAt = CityLocationCanon.GetPossessionsOfOwner(attackerLocation).FirstOrDefault();
if (cityAt != null && combatInfo.CombatType == CombatType.Ranged)
{
combatInfo.AttackerCombatModifier += CityModifiers.GarrisionedRangedCombatStrength.GetValueForCity(cityAt);
}
}
}
public void ApplyAurasToCombat(
IUnit attacker, IUnit defender, CombatInfo combatInfo
)
{
var attackerLocation = UnitPositionCanon.GetOwnerOfPossession(attacker);
var defenderLocation = UnitPositionCanon.GetOwnerOfPossession(defender);
float attackerAuraStrength = 0f, defenderAuraStrength = 0f;
var attackerAllyAuraModifiers = GetNearbyAllies(attacker, UnitConfig.AuraRange).SelectMany(
ally => ally.CombatSummary.AuraModifiersWhenAttacking
);
foreach (var auraModifier in attackerAllyAuraModifiers)
{
if (auraModifier.DoesModifierApply(attacker, defender, attackerLocation, combatInfo.CombatType))
{
attackerAuraStrength += auraModifier.Modifier;
}
}
var defenderAllyAuraModifiers = GetNearbyAllies(defender, UnitConfig.AuraRange).SelectMany(
ally => ally.CombatSummary.AuraModifiersWhenDefending
);
foreach (var auraModifier in defenderAllyAuraModifiers)
{
if (auraModifier.DoesModifierApply(defender, attacker, defenderLocation, combatInfo.CombatType))
{
defenderAuraStrength += auraModifier.Modifier;
}
}
combatInfo.AttackerCombatModifier += attackerAuraStrength;
combatInfo.DefenderCombatModifier += defenderAuraStrength;
}
public void PerformMeleeAttack(IUnit attacker, IUnit defender, Action successAction, Action failAction)
{
if (!CanPerformMeleeAttack(attacker, defender))
{
throw new InvalidOperationException("CanPerformMeleeCombat must return true");
}
var attackerLocation = UnitPositionCanon.GetOwnerOfPossession(attacker);
var defenderLocation = UnitPositionCanon.GetOwnerOfPossession(defender);
var pathToDefender = HexPathfinder.GetShortestPathBetween(
attackerLocation, defenderLocation, attacker.CurrentMovement,
(current, next) => UnitPositionCanon.GetTraversalCostForUnit(attacker, current, next, true),
Grid.Cells
);
attacker.CurrentPath = pathToDefender.GetRange(0, pathToDefender.Count - 1);
attacker.PerformMovement(
false, PerformMeleeAttack_GetPostMovementCallback(
attacker, defender, defenderLocation, successAction, failAction
)
);
}
