Move the AI namespace to Mods.Common

OpenRA.Mods.Common/AI/States/AirStates.cs

@@ -0,0 +1,259 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2015 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using OpenRA.Mods.Common.Activities;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.AI
+{
+	abstract class AirStateBase : StateBase
+	{
+		protected const int MissileUnitMultiplier = 3;
+
+		protected static int CountAntiAirUnits(IEnumerable<Actor> units)
+		{
+			if (!units.Any())
+				return 0;
+
+			var missileUnitsCount = 0;
+			foreach (var unit in units)
+			{
+				if (unit != null && unit.HasTrait<AttackBase>() && !unit.HasTrait<Aircraft>()
+					&& !unit.IsDisabled())
+				{
+					var arms = unit.TraitsImplementing<Armament>();
+					foreach (var a in arms)
+					{
+						if (a.Weapon.ValidTargets.Contains("Air"))
+						{
+							missileUnitsCount++;
+							break;
+						}
+					}
+				}
+			}
+
+			return missileUnitsCount;
+		}
+
+		protected static Actor FindDefenselessTarget(Squad owner)
+		{
+			Actor target = null;
+			FindSafePlace(owner, out target, true);
+			return target;
+		}
+
+		protected static CPos? FindSafePlace(Squad owner, out Actor detectedEnemyTarget, bool needTarget)
+		{
+			var map = owner.World.Map;
+			detectedEnemyTarget = null;
+			var x = (map.MapSize.X % DangerRadius) == 0 ? map.MapSize.X : map.MapSize.X + DangerRadius;
+			var y = (map.MapSize.Y % DangerRadius) == 0 ? map.MapSize.Y : map.MapSize.Y + DangerRadius;
+
+			for (var i = 0; i < x; i += DangerRadius * 2)
+			{
+				for (var j = 0; j < y; j += DangerRadius * 2)
+				{
+					var pos = new CPos(i, j);
+					if (NearToPosSafely(owner, map.CenterOfCell(pos), out detectedEnemyTarget))
+					{
+						if (needTarget && detectedEnemyTarget == null)
+							continue;
+
+						return pos;
+					}
+				}
+			}
+
+			return null;
+		}
+
+		protected static bool NearToPosSafely(Squad owner, WPos loc)
+		{
+			Actor a;
+			return NearToPosSafely(owner, loc, out a);
+		}
+
+		protected static bool NearToPosSafely(Squad owner, WPos loc, out Actor detectedEnemyTarget)
+		{
+			detectedEnemyTarget = null;
+			var unitsAroundPos = owner.World.FindActorsInCircle(loc, WRange.FromCells(DangerRadius))
+				.Where(unit => owner.Bot.Player.Stances[unit.Owner] == Stance.Enemy).ToList();
+
+			if (!unitsAroundPos.Any())
+				return true;
+
+			if (CountAntiAirUnits(unitsAroundPos) * MissileUnitMultiplier < owner.Units.Count)
+			{
+				detectedEnemyTarget = unitsAroundPos.Random(owner.Random);
+				return true;
+			}
+
+			return false;
+		}
+
+		protected static bool FullAmmo(Actor a)
+		{
+			var limitedAmmo = a.TraitOrDefault<LimitedAmmo>();
+			return limitedAmmo != null && limitedAmmo.FullAmmo();
+		}
+
+		protected static bool HasAmmo(Actor a)
+		{
+			var limitedAmmo = a.TraitOrDefault<LimitedAmmo>();
+			return limitedAmmo != null && limitedAmmo.HasAmmo();
+		}
+
+		protected static bool ReloadsAutomatically(Actor a)
+		{
+			return a.HasTrait<Reloads>();
+		}
+
+		protected static bool IsRearm(Actor a)
+		{
+			var activity = a.GetCurrentActivity();
+			if (activity == null)
+				return false;
+
+			var type = activity.GetType();
+			if (type == typeof(Rearm) || type == typeof(ResupplyAircraft))
+				return true;
+
+			var next = activity.NextActivity;
+			if (next == null)
+				return false;
+
+			var nextType = next.GetType();
+			if (nextType == typeof(Rearm) || nextType == typeof(ResupplyAircraft))
+				return true;
+
+			return false;
+		}
+
+		// Checks the number of anti air enemies around units
+		protected virtual bool ShouldFlee(Squad owner)
+		{
+			return base.ShouldFlee(owner, enemies => CountAntiAirUnits(enemies) * MissileUnitMultiplier > owner.Units.Count);
+		}
+	}
+
+	class AirIdleState : AirStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+
+		public void Tick(Squad owner)
+		{
+			if (!owner.IsValid)
+				return;
+
+			if (ShouldFlee(owner))
+			{
+				owner.FuzzyStateMachine.ChangeState(owner, new AirFleeState(), true);
+				return;
+			}
+
+			var e = FindDefenselessTarget(owner);
+			if (e == null)
+				return;
+
+			owner.TargetActor = e;
+			owner.FuzzyStateMachine.ChangeState(owner, new AirAttackState(), true);
+		}
+
+		public void Deactivate(Squad owner) { }
+	}
+
+	class AirAttackState : AirStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+
+		public void Tick(Squad owner)
+		{
+			if (!owner.IsValid)
+				return;
+
+			if (!owner.TargetIsValid)
+			{
+				var a = owner.Units.Random(owner.Random);
+				var closestEnemy = owner.Bot.FindClosestEnemy(a.CenterPosition);
+				if (closestEnemy != null)
+					owner.TargetActor = closestEnemy;
+				else
+				{
+					owner.FuzzyStateMachine.ChangeState(owner, new AirFleeState(), true);
+					return;
+				}
+			}
+
+			if (!NearToPosSafely(owner, owner.TargetActor.CenterPosition))
+			{
+				owner.FuzzyStateMachine.ChangeState(owner, new AirFleeState(), true);
+				return;
+			}
+
+			foreach (var a in owner.Units)
+			{
+				if (BusyAttack(a))
+					continue;
+
+				if (!ReloadsAutomatically(a))
+				{
+					if (!HasAmmo(a))
+					{
+						if (IsRearm(a))
+							continue;
+						owner.World.IssueOrder(new Order("ReturnToBase", a, false));
+						continue;
+					}
+
+					if (IsRearm(a))
+						continue;
+				}
+
+				if (owner.TargetActor.HasTrait<ITargetable>() && CanAttackTarget(a, owner.TargetActor))
+					owner.World.IssueOrder(new Order("Attack", a, false) { TargetActor = owner.TargetActor });
+			}
+		}
+
+		public void Deactivate(Squad owner) { }
+	}
+
+	class AirFleeState : AirStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+
+		public void Tick(Squad owner)
+		{
+			if (!owner.IsValid)
+				return;
+
+			foreach (var a in owner.Units)
+			{
+				if (!ReloadsAutomatically(a) && !FullAmmo(a))
+				{
+					if (IsRearm(a))
+						continue;
+
+					owner.World.IssueOrder(new Order("ReturnToBase", a, false));
+					continue;
+				}
+
+				owner.World.IssueOrder(new Order("Move", a, false) { TargetLocation = RandomBuildingLocation(owner) });
+			}
+
+			owner.FuzzyStateMachine.ChangeState(owner, new AirIdleState(), true);
+		}
+
+		public void Deactivate(Squad owner) { }
+	}
+}

OpenRA.Mods.Common/AI/States/GroundStates.cs

@@ -0,0 +1,171 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2015 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Linq;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.AI
+{
+	abstract class GroundStateBase : StateBase
+	{
+		protected virtual bool ShouldFlee(Squad owner)
+		{
+			return base.ShouldFlee(owner, enemies => !owner.AttackOrFleeFuzzy.CanAttack(owner.Units, enemies));
+		}
+	}
+
+	class GroundUnitsIdleState : GroundStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+
+		public void Tick(Squad owner)
+		{
+			if (!owner.IsValid)
+				return;
+
+			if (!owner.TargetIsValid)
+			{
+				var t = owner.Bot.FindClosestEnemy(owner.Units.FirstOrDefault().CenterPosition);
+				if (t == null) return;
+				owner.TargetActor = t;
+			}
+
+			var enemyUnits = owner.World.FindActorsInCircle(owner.TargetActor.CenterPosition, WRange.FromCells(10))
+				.Where(unit => owner.Bot.Player.Stances[unit.Owner] == Stance.Enemy).ToList();
+
+			if (enemyUnits.Any())
+			{
+				if (owner.AttackOrFleeFuzzy.CanAttack(owner.Units, enemyUnits))
+				{
+					foreach (var u in owner.Units)
+						owner.World.IssueOrder(new Order("AttackMove", u, false) { TargetLocation = owner.TargetActor.Location });
+
+					// We have gathered sufficient units. Attack the nearest enemy unit.
+					owner.FuzzyStateMachine.ChangeState(owner, new GroundUnitsAttackMoveState(), true);
+					return;
+				}
+				else
+					owner.FuzzyStateMachine.ChangeState(owner, new GroundUnitsFleeState(), true);
+			}
+		}
+
+		public void Deactivate(Squad owner) { }
+	}
+
+	class GroundUnitsAttackMoveState : GroundStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+
+		public void Tick(Squad owner)
+		{
+			if (!owner.IsValid)
+				return;
+
+			if (!owner.TargetIsValid)
+			{
+				var closestEnemy = owner.Bot.FindClosestEnemy(owner.Units.Random(owner.Random).CenterPosition);
+				if (closestEnemy != null)
+					owner.TargetActor = closestEnemy;
+				else
+				{
+					owner.FuzzyStateMachine.ChangeState(owner, new GroundUnitsFleeState(), true);
+					return;
+				}
+			}
+
+			var leader = owner.Units.ClosestTo(owner.TargetActor.CenterPosition);
+			if (leader == null)
+				return;
+			var ownUnits = owner.World.FindActorsInCircle(leader.CenterPosition, WRange.FromCells(owner.Units.Count) / 3)
+				.Where(a => a.Owner == owner.Units.FirstOrDefault().Owner && owner.Units.Contains(a)).ToHashSet();
+			if (ownUnits.Count < owner.Units.Count)
+			{
+				owner.World.IssueOrder(new Order("Stop", leader, false));
+				foreach (var unit in owner.Units.Where(a => !ownUnits.Contains(a)))
+					owner.World.IssueOrder(new Order("AttackMove", unit, false) { TargetLocation = leader.Location });
+			}
+			else
+			{
+				var enemies = owner.World.FindActorsInCircle(leader.CenterPosition, WRange.FromCells(12))
+					.Where(a1 => !a1.Destroyed && !a1.IsDead);
+				var enemynearby = enemies.Where(a1 => a1.HasTrait<ITargetable>() && leader.Owner.Stances[a1.Owner] == Stance.Enemy);
+				var target = enemynearby.ClosestTo(leader.CenterPosition);
+				if (target != null)
+				{
+					owner.TargetActor = target;
+					owner.FuzzyStateMachine.ChangeState(owner, new GroundUnitsAttackState(), true);
+					return;
+				}
+				else
+					foreach (var a in owner.Units)
+						owner.World.IssueOrder(new Order("AttackMove", a, false) { TargetLocation = owner.TargetActor.Location });
+			}
+
+			if (ShouldFlee(owner))
+			{
+				owner.FuzzyStateMachine.ChangeState(owner, new GroundUnitsFleeState(), true);
+				return;
+			}
+		}
+
+		public void Deactivate(Squad owner) { }
+	}
+
+	class GroundUnitsAttackState : GroundStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+
+		public void Tick(Squad owner)
+		{
+			if (!owner.IsValid)
+				return;
+
+			if (!owner.TargetIsValid)
+			{
+				var closestEnemy = owner.Bot.FindClosestEnemy(owner.Units.Random(owner.Random).CenterPosition);
+				if (closestEnemy != null)
+					owner.TargetActor = closestEnemy;
+				else
+				{
+					owner.FuzzyStateMachine.ChangeState(owner, new GroundUnitsFleeState(), true);
+					return;
+				}
+			}
+
+			foreach (var a in owner.Units)
+				if (!BusyAttack(a))
+					owner.World.IssueOrder(new Order("Attack", a, false) { TargetActor = owner.Bot.FindClosestEnemy(a.CenterPosition) });
+
+			if (ShouldFlee(owner))
+			{
+				owner.FuzzyStateMachine.ChangeState(owner, new GroundUnitsFleeState(), true);
+				return;
+			}
+		}
+
+		public void Deactivate(Squad owner) { }
+	}
+
+	class GroundUnitsFleeState : GroundStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+
+		public void Tick(Squad owner)
+		{
+			if (!owner.IsValid)
+				return;
+
+			GoToRandomOwnBuilding(owner);
+			owner.FuzzyStateMachine.ChangeState(owner, new GroundUnitsIdleState(), true);
+		}
+
+		public void Deactivate(Squad owner) { owner.Units.Clear(); }
+	}
+}

OpenRA.Mods.Common/AI/States/ProtectionStates.cs

@@ -0,0 +1,62 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2015 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+namespace OpenRA.Mods.Common.AI
+{
+	class UnitsForProtectionIdleState : GroundStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+		public void Tick(Squad owner) { owner.FuzzyStateMachine.ChangeState(owner, new UnitsForProtectionAttackState(), true); }
+		public void Deactivate(Squad owner) { }
+	}
+
+	class UnitsForProtectionAttackState : GroundStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+
+		public void Tick(Squad owner)
+		{
+			if (!owner.IsValid)
+				return;
+
+			if (!owner.TargetIsValid)
+			{
+				owner.TargetActor = owner.Bot.FindClosestEnemy(owner.CenterPosition, WRange.FromCells(8));
+
+				if (owner.TargetActor == null)
+				{
+					owner.FuzzyStateMachine.ChangeState(owner, new UnitsForProtectionFleeState(), true);
+					return;
+				}
+			}
+
+			foreach (var a in owner.Units)
+				owner.World.IssueOrder(new Order("AttackMove", a, false) { TargetLocation = owner.TargetActor.Location });
+		}
+
+		public void Deactivate(Squad owner) { }
+	}
+
+	class UnitsForProtectionFleeState : GroundStateBase, IState
+	{
+		public void Activate(Squad owner) { }
+
+		public void Tick(Squad owner)
+		{
+			if (!owner.IsValid)
+				return;
+
+			GoToRandomOwnBuilding(owner);
+			owner.FuzzyStateMachine.ChangeState(owner, new UnitsForProtectionIdleState(), true);
+		}
+
+		public void Deactivate(Squad owner) { owner.Units.Clear(); }
+	}
+}

OpenRA.Mods.Common/AI/States/StateBase.cs

@@ -0,0 +1,96 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2015 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OpenRA.Mods.Common.Activities;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.AI
+{
+	abstract class StateBase
+	{
+		protected const int DangerRadius = 10;
+
+		protected static void GoToRandomOwnBuilding(Squad squad)
+		{
+			var loc = RandomBuildingLocation(squad);
+			foreach (var a in squad.Units)
+				squad.World.IssueOrder(new Order("Move", a, false) { TargetLocation = loc });
+		}
+
+		protected static CPos RandomBuildingLocation(Squad squad)
+		{
+			var location = squad.Bot.BaseCenter;
+			var buildings = squad.World.ActorsWithTrait<Building>()
+				.Where(a => a.Actor.Owner == squad.Bot.Player).Select(a => a.Actor).ToList();
+			if (buildings.Count > 0)
+				location = buildings.Random(squad.Random).Location;
+			return location;
+		}
+
+		protected static bool BusyAttack(Actor a)
+		{
+			if (a.IsIdle)
+				return false;
+
+			var type = a.GetCurrentActivity().GetType();
+			if (type == typeof(Attack) || type == typeof(FlyAttack))
+				return true;
+
+			var next = a.GetCurrentActivity().NextActivity;
+			if (next == null)
+				return false;
+
+			var nextType = a.GetCurrentActivity().NextActivity.GetType();
+			if (nextType == typeof(Attack) || nextType == typeof(FlyAttack))
+				return true;
+
+			return false;
+		}
+
+		protected static bool CanAttackTarget(Actor a, Actor target)
+		{
+			if (!a.HasTrait<AttackBase>())
+				return false;
+
+			var targetable = target.TraitOrDefault<ITargetable>();
+			if (targetable == null)
+				return false;
+
+			var arms = a.TraitsImplementing<Armament>();
+			foreach (var arm in arms)
+				if (arm.Weapon.ValidTargets.Intersect(targetable.TargetTypes).Any())
+					return true;
+
+			return false;
+		}
+
+		protected virtual bool ShouldFlee(Squad squad, Func<IEnumerable<Actor>, bool> flee)
+		{
+			if (!squad.IsValid)
+				return false;
+
+			var u = squad.Units.Random(squad.Random);
+			var units = squad.World.FindActorsInCircle(u.CenterPosition, WRange.FromCells(DangerRadius)).ToList();
+			var ownBaseBuildingAround = units.Where(unit => unit.Owner == squad.Bot.Player && unit.HasTrait<Building>());
+			if (ownBaseBuildingAround.Any())
+				return false;
+
+			var enemyAroundUnit = units.Where(unit => squad.Bot.Player.Stances[unit.Owner] == Stance.Enemy && unit.HasTrait<AttackBase>());
+			if (!enemyAroundUnit.Any())
+				return false;
+
+			return flee(enemyAroundUnit);
+		}
+	}
+}