protected float GetRatioOfAlliesAroundTargetPosition(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float result = 0f;
if (potentialTarget.Neighbours == null)
{
return(result);
}
int count = potentialTarget.Neighbours.Count;
int num = 0;
if (count > 0)
{
for (int i = 0; i < count; i++)
{
BattleSimulationUnit unit2 = potentialTarget.Neighbours[i].Unit;
if (unit2 != null && unit2.Contender.Group == unit.Contender.Group)
{
num++;
}
}
result = (float)num / (float)count;
}
return(result);
}
protected bool IsGroundUnit(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
if (potentialTarget.Unit == null)
{
return(false);
}
return(potentialTarget.Unit.SimulationObject.DescriptorHolders.Exists((SimulationDescriptorHolder match) => match.Descriptor.Name == PathfindingContext.MovementCapacityWalkDescriptor));
}
protected float GetIsTargetTransportShipUnit(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
if (potentialTarget.Unit != null && potentialTarget.Unit.SimulationObject.Tags.Contains(DownloadableContent16.TransportShipUnit))
{
return(1f);
}
return(0f);
}
protected float GetDoesTargetPlaysBeforeMe(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
if (potentialTarget.Unit != null && (potentialTarget.Unit.HasUnitActions || potentialTarget.Unit.UnitRoundRank < unit.UnitRoundRank))
{
return(1f);
}
return(0f);
}
protected bool IAmInDarkForm(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
if (unit.Unit == null)
{
return(false);
}
SimulationProperty property = unit.Unit.SimulationObject.GetProperty(SimulationProperties.ShiftingForm);
return(property != null && property.Value == 1f);
}
protected float GetIsTargetLower(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float propertyValue = unit.GetPropertyValue(SimulationProperties.Altitude);
float num = (float)unit.ElevationMap.GetValue(potentialTarget.StaticPosition);
if (propertyValue > num)
{
return(1f);
}
return(0f);
}
protected float GetNumberOfTurnToReachTargetByAir(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float result = 0f;
float propertyValue = unit.GetPropertyValue(SimulationProperties.BattleMaximumMovement);
if (propertyValue != 0f)
{
result = (float)this.worldPositionningService.GetDistance(unit.Position, potentialTarget.StaticPosition) / propertyValue;
}
return(result);
}
protected float GetRatioOfTargetAltitudeToMyAltitude(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float result = 0f;
float propertyValue = unit.GetPropertyValue(SimulationProperties.Altitude);
if (propertyValue != 0f)
{
float num = (float)unit.ElevationMap.GetValue(potentialTarget.StaticPosition);
result = num / propertyValue;
}
return(result);
}
protected float GetRatioOfTargetSpeedToBattleArea(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float result = 0f;
if (potentialTarget.Unit != null)
{
float propertyValue = potentialTarget.Unit.GetPropertyValue(SimulationProperties.BattleMaximumMovement);
int num = potentialTarget.Unit.Contender.Deployment.DeploymentArea.MaxColumn - potentialTarget.Unit.Contender.Deployment.DeploymentArea.MinColumn + 1;
result = propertyValue / (float)num;
}
return(result);
}
protected float GetRatioDistanceToAttackAndMoveRange(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float result = 0f;
float distanceByGround = unit.GetDistanceByGround(potentialTarget.StaticPosition);
if (distanceByGround > 0f)
{
float propertyValue = unit.GetPropertyValue(SimulationProperties.BattleMaximumMovement);
float propertyValue2 = unit.GetPropertyValue(SimulationProperties.BattleRange);
result = distanceByGround / (propertyValue + propertyValue2);
}
return(result);
}
protected float GetRatioMyDefenseToTargetAttack(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float result = 2f;
BattleSimulationUnit unit2 = potentialTarget.Unit;
if (unit2 != null)
{
float propertyValue = unit2.GetPropertyValue(SimulationProperties.Attack);
if (propertyValue != 0f)
{
result = Mathf.Clamp(unit.GetPropertyValue(SimulationProperties.Defense) / propertyValue, 0.5f, 2f);
}
}
return(result);
}
protected float GetTargetHPRatio(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float result = 0f;
if (potentialTarget.Unit != null)
{
float propertyValue = potentialTarget.Unit.GetPropertyValue(SimulationProperties.Health);
float propertyValue2 = potentialTarget.Unit.GetPropertyValue(SimulationProperties.MaximumHealth);
if (propertyValue2 != 0f)
{
result = propertyValue / propertyValue2;
}
}
return(result);
}
protected float GetTargetDefensiveMilitaryPowerRatio(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float result = 0f;
if (potentialTarget.Unit != null)
{
float propertyValue = potentialTarget.Unit.GetPropertyValue(SimulationProperties.DefensiveMilitaryPower);
float unitsSimulationAverageData = this.battleSimulation.GetUnitsSimulationAverageData(potentialTarget.Unit.Contender.Group, SimulationProperties.DefensiveMilitaryPower);
if (unitsSimulationAverageData != 0f)
{
result = propertyValue / unitsSimulationAverageData;
}
}
return(result);
}
public ActivePeriod[] GetTargetActivePeriods(BattleSimulationTarget target)
{
List <ActivePeriod> list = new List <ActivePeriod>();
Diagnostics.Assert(this.activeBattleActions != null);
for (int i = 0; i < this.activeBattleActions.Count; i++)
{
BattleActionContext battleActionContext = this.activeBattleActions[i];
Diagnostics.Assert(battleActionContext != null && battleActionContext.Targets != null);
if (battleActionContext.Targets.Contains(target))
{
Diagnostics.Assert(battleActionContext.ActivePeriods != null);
list.AddRange(battleActionContext.ActivePeriods);
}
}
return(list.ToArray());
}
public bool ExecuteBattleAction(BattleAction battleAction, BattleEffects[] battleEffectsList, BattleSimulationUnit referenceUnit, WorldPosition targetPosition, bool immediate)
{
if (battleAction == null)
{
throw new ArgumentNullException("battleAction");
}
if (battleEffectsList == null)
{
throw new ArgumentNullException("battleEffectsList");
}
if (referenceUnit == null)
{
throw new ArgumentNullException("initiators");
}
BattleSimulationTarget[] currentTargets = new BattleSimulationTarget[]
{
new BattleSimulationTarget(targetPosition)
};
return(this.ExecuteBattleAction(battleAction, battleEffectsList, referenceUnit, currentTargets, immediate, null));
}
protected float GetTargetedByAlliesWithMyBodyCount(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float result = 0f;
List <BattleSimulationUnit> targeters = potentialTarget.Targeters;
if (potentialTarget.Unit != null)
{
targeters = potentialTarget.Unit.Targeters;
}
if (targeters != null)
{
int num = 0;
for (int i = 0; i < targeters.Count; i++)
{
if (targeters[i].Contender.Group == unit.Contender.Group && targeters[i].UnitGUID != unit.UnitGUID && targeters[i].Unit.UnitDesign.UnitBodyDefinition == unit.Unit.UnitDesign.UnitBodyDefinition)
{
num++;
}
}
result = (float)num;
}
return(result);
}
protected float IsMyBattleEffectAppliedOnTarget(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
if (potentialTarget.Unit != null)
{
IEnumerable <BattleUnitActionController.UnitAction> availableActions;
if (potentialTarget.Unit.Contender.Group == unit.Contender.Group)
{
availableActions = this.battleSimulation.BattleUnitActionController.GetAvailableActions(unit, BattleActionUnit.ActionType.Support);
}
else
{
availableActions = this.battleSimulation.BattleUnitActionController.GetAvailableActions(unit, BattleActionUnit.ActionType.Attack);
}
if (availableActions != null)
{
foreach (BattleUnitActionController.UnitAction unitAction in availableActions)
{
for (int i = 0; i < unitAction.BattleAction.BattleEffects.Length; i++)
{
BattleEffects battleEffects = unitAction.BattleAction.BattleEffects[i];
if (battleEffects != null && battleEffects.BattleEffectList != null)
{
for (int j = 0; j < battleEffects.BattleEffectList.Length; j++)
{
BattleEffectContext contextFromBattleEffect = unit.GetContextFromBattleEffect(battleEffects.BattleEffectList[j]);
if (contextFromBattleEffect != null && contextFromBattleEffect.Target.Unit == potentialTarget.Unit)
{
return(1f);
}
}
}
}
}
}
}
return(0f);
}
protected bool IsNotMe(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(potentialTarget.Unit == null || unit.UnitGUID != potentialTarget.Unit.UnitGUID);
}
private void ExecuteAOEBattleAction(float battleActionContextRandomNumber, BattleAction battleAction, BattleEffectsArea battleEffectsArea, BattleSimulationUnit initiator, BattleSimulationUnit activator, BattleSimulationTarget[] aoeCenterTargets, bool immediate)
{
if (battleAction == null)
{
throw new ArgumentNullException("battleAction");
}
if (battleEffectsArea == null)
{
throw new ArgumentNullException("battleEffectsArea");
}
if (aoeCenterTargets == null || aoeCenterTargets.Length == 0)
{
return;
}
List <BattleSimulationTarget> list = new List <BattleSimulationTarget>();
foreach (BattleSimulationTarget battleSimulationTarget3 in aoeCenterTargets)
{
WorldOrientation worldOrientation = (battleSimulationTarget3.Unit == null) ? WorldOrientation.Undefined : battleSimulationTarget3.Unit.Orientation;
if (battleEffectsArea.InitiatorAsCenter || worldOrientation == WorldOrientation.Undefined)
{
worldOrientation = ((initiator == null) ? worldOrientation : initiator.Orientation);
}
List <WorldPosition> list2 = null;
if (battleEffectsArea.Type == BattleEffectsArea.AreaType.Chain)
{
Diagnostics.Assert(this.Simulation != null);
BattleSimulationTarget[] array = null;
if (battleSimulationTarget3.Unit != null)
{
array = this.Simulation.FilterTargets(BattleEffects.TargetFlags.SameGroup, battleSimulationTarget3.Unit, null);
}
if (array != null && array.Length != 0)
{
list2 = new List <WorldPosition>(array.Length);
list2.AddRange(from battleSimulationTarget in array
select battleSimulationTarget.DynamicPosition);
}
}
SimulationObject context = null;
if (initiator != null)
{
context = initiator.SimulationObject;
}
Diagnostics.Assert(this.Simulation != null);
WorldPosition dynamicPosition = battleSimulationTarget3.DynamicPosition;
if (battleEffectsArea.InitiatorAsCenter)
{
dynamicPosition = new BattleSimulationTarget(initiator).DynamicPosition;
}
IPathfindingArea area = battleEffectsArea.GetArea(dynamicPosition, worldOrientation, list2, this.Simulation.WorldParameters, this.Simulation.BattleZone, context);
if (area == null)
{
Diagnostics.LogError("Unknown area of effect {0}, the effect will be applied on the filtered unit.", new object[]
{
battleEffectsArea.Type
});
}
else
{
WorldPosition[] worldPositions = area.GetWorldPositions(this.Simulation.WorldParameters);
if (worldPositions == null)
{
Diagnostics.LogError("Can't get area of effect positions.");
}
else
{
list.Clear();
for (int j = 0; j < worldPositions.Length; j++)
{
BattleSimulationUnit unitFromPosition = this.Simulation.GetUnitFromPosition(worldPositions[j], false);
if (unitFromPosition != null)
{
BattleSimulationTarget battleSimulationTarget2 = new BattleSimulationTarget(unitFromPosition);
if (battleEffectsArea.AvoidCastingUnit)
{
bool flag = false;
for (int k = 0; k < aoeCenterTargets.Length; k++)
{
if (aoeCenterTargets[k].DynamicPosition == battleSimulationTarget2.DynamicPosition)
{
if (battleEffectsArea.Type != BattleEffectsArea.AreaType.Chain)
{
flag = true;
break;
}
battleSimulationTarget2.Ignore = true;
}
}
if (flag)
{
goto IL_225;
}
}
list.Add(battleSimulationTarget2);
}
IL_225 :;
}
BattleActionAOEInstruction battleActionAOEInstruction = new BattleActionAOEInstruction(initiator.UnitGUID, battleEffectsArea.RealizationVisualEffectName);
battleActionAOEInstruction.RealizationApplicationMethod = battleEffectsArea.RealizationApplicationMethod;
battleActionAOEInstruction.RealizationApplicationData = battleEffectsArea.RealizationApplicationData;
this.ReportInstruction(battleActionAOEInstruction);
List <IUnitReportInstruction> list3 = this.reportCopy;
this.reportCopy = battleActionAOEInstruction.ReportInstructions;
Diagnostics.Assert(battleEffectsArea.BattleEffects != null);
for (int l = 0; l < battleEffectsArea.BattleEffects.Length; l++)
{
BattleEffects battleEffects = battleEffectsArea.BattleEffects[l];
this.ExecuteBattleAction(battleActionContextRandomNumber, battleAction, battleEffects, initiator, activator, list.ToArray(), immediate);
}
this.reportCopy = list3;
}
}
}
}
public void ExecuteBattleEffect(BattleSimulationUnit initiator, BattleSimulationUnit activator, BattleSimulationTarget target, BattleEffect battleEffect, BattleActionContext actionContext)
{
Diagnostics.Assert(this.battleEffectsContexts != null, "this.battleEffectsContexts != null");
BattleEffectController battleEffectController;
if (this.battleEffectsContexts.ContainsKey(target))
{
battleEffectController = this.battleEffectsContexts[target];
}
else
{
battleEffectController = new BattleEffectController(target, this.Simulation);
this.battleEffectsContexts.Add(target, battleEffectController);
}
Diagnostics.Assert(battleEffectController != null);
battleEffectController.Execute(battleEffect, initiator, activator, this, actionContext);
}
protected bool IsUnit(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(!this.IsFreePosition(unit, potentialTarget));
}
protected bool CanTargetBeDebuffed(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(potentialTarget.Unit != null && potentialTarget.Unit.SimulationObject.GetPropertyValue("CantBeDebuffed") <= 0f);
}
protected bool IsTargetNotMindControlled(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(potentialTarget.Unit != null && potentialTarget.Unit.SimulationObject.GetPropertyValue(SimulationProperties.MindControlCounter) <= 0f);
}
protected bool AlliesArePresent(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(this.battleSimulation.GetUnitAliveAlliesCount(unit) > 1);
}
protected bool IsTargetWithinMovementRange(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
float distanceByGround = unit.GetDistanceByGround(potentialTarget.StaticPosition);
return(distanceByGround <= unit.GetPropertyValue(SimulationProperties.BattleMovement));
}
protected bool IAmNotTransportShip(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(!this.IAmTransportShip(unit, potentialTarget));
}
protected bool IAmTransportShip(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(unit.Unit != null && unit.Unit.SimulationObject.Tags.Contains(DownloadableContent16.TransportShipUnit));
}
protected bool IsEnemy(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(potentialTarget.Unit != null && unit.BattleSimulationArmy.Group != potentialTarget.Unit.BattleSimulationArmy.Group);
}
protected bool IAmCombatUnit(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(unit.Unit != null && !this.IsUnitClass(unit, "UnitClassSupport") && !this.IsUnitClass(unit, "UnitClassRanged"));
}
protected bool IsFreePosition(BattleSimulationUnit unit, BattleSimulationTarget potentialTarget)
{
return(potentialTarget.Unit == null || potentialTarget.Unit.UnitGUID == unit.UnitGUID);
}
