Merge remote-tracking branch 'darkademic/dev'

Author: Inq8

OpenRA.Mods.CA/AIUtils.cs

@@ -8,9 +8,11 @@
  */
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using OpenRA.Mods.Common;
+using OpenRA.Mods.Common.Pathfinder;
 using OpenRA.Mods.Common.Traits;
 using OpenRA.Traits;
 
@@ -114,5 +116,213 @@ public static WPos PositionClosestTo_Old(this IEnumerable<WPos> positions, WPos
 		{
 			return positions.MinByOrDefault(p => (p - pos).LengthSquared);
 		}
+
+		// Finds multiple distinct routes between source and target for a given locomotor.
+		public static List<List<CPos>> FindDistinctRoutes(
+			World world,
+			Locomotor locomotor,
+			CPos source,
+			CPos target,
+			int maxRoutes = 3,
+			BlockedByActor check = BlockedByActor.None)
+		{
+			var routes = new List<List<CPos>>();
+
+			// Get the PathFinder trait from the world actor
+			var pathFinder = world.WorldActor.TraitOrDefault<PathFinder>();
+			if (pathFinder == null)
+				return routes;
+
+			// Get the abstract graph data from the hierarchical pathfinder
+			var (abstractGraph, abstractDomains) = pathFinder.GetOverlayDataForLocomotor(locomotor, check);
+			if (abstractGraph == null || abstractDomains == null)
+				return routes;
+
+			// Map source and target to their abstract nodes
+			var sourceAbstract = FindAbstractNodeForCell(source, abstractGraph, abstractDomains);
+			var targetAbstract = FindAbstractNodeForCell(target, abstractGraph, abstractDomains);
+
+			if (sourceAbstract == null || targetAbstract == null)
+				return routes;
+
+			// Check if source and target are in the same domain (connected)
+			if (!abstractDomains.TryGetValue(sourceAbstract.Value, out var sourceDomain) ||
+				!abstractDomains.TryGetValue(targetAbstract.Value, out var targetDomain) ||
+				sourceDomain != targetDomain)
+				return routes;
+
+			// Track nodes that have been used in previous routes
+			var excludedNodes = new HashSet<CPos>();
+
+			for (var i = 0; i < maxRoutes; i++)
+			{
+				var route = FindAbstractPath(sourceAbstract.Value, targetAbstract.Value, abstractGraph, excludedNodes);
+				if (route == null || route.Count == 0)
+					break; // No more valid routes available
+
+				routes.Add(route);
+
+				// Exclude all nodes in this route (except source and target) for future routes
+				foreach (var node in route)
+				{
+					if (node != sourceAbstract.Value
+						&& node != targetAbstract.Value
+						&& node != route.ElementAtOrDefault(1)
+						&& node != route.ElementAtOrDefault(2)
+						&& node != route.ElementAtOrDefault(route.Count - 2))
+						excludedNodes.Add(node);
+				}
+			}
+
+			return routes;
+		}
+
+		// Finds the abstract node that corresponds to a given cell position.
+		static CPos? FindAbstractNodeForCell(
+			CPos cell,
+			IReadOnlyDictionary<CPos, List<GraphConnection>> abstractGraph,
+			IReadOnlyDictionary<CPos, uint> abstractDomains)
+		{
+			// If the cell itself is an abstract node, return it
+			if (abstractDomains.ContainsKey(cell))
+				return cell;
+
+			// Otherwise, find the nearest abstract node
+			CPos? nearestNode = null;
+			var minDistSq = int.MaxValue;
+
+			foreach (var abstractNode in abstractDomains.Keys)
+			{
+				var distSq = (abstractNode - cell).LengthSquared;
+				if (distSq < minDistSq)
+				{
+					minDistSq = distSq;
+					nearestNode = abstractNode;
+				}
+			}
+
+			return nearestNode;
+		}
+
+		// Performs A* pathfinding on the abstract graph to find a route from source to target,
+		// avoiding any nodes in the excluded set.
+		static List<CPos> FindAbstractPath(
+			CPos source,
+			CPos target,
+			IReadOnlyDictionary<CPos, List<GraphConnection>> abstractGraph,
+			HashSet<CPos> excludedNodes)
+		{
+			var openSet = new Dictionary<CPos, PathNode>();
+			var closedSet = new HashSet<CPos>();
+
+			// Initialize the starting node
+			var startNode = new PathNode
+			{
+				Position = source,
+				CostFromStart = 0,
+				EstimatedTotalCost = Heuristic(source, target),
+				Parent = null
+			};
+
+			openSet[source] = startNode;
+
+			while (openSet.Count > 0)
+			{
+				// Find the node in openSet with the lowest estimated total cost
+				var current = openSet.Values.MinBy(n => n.EstimatedTotalCost);
+				if (current == null)
+					break;
+
+				// Check if we've reached the target
+				if (current.Position == target)
+					return ReconstructPath(current);
+
+				openSet.Remove(current.Position);
+				closedSet.Add(current.Position);
+
+				// Explore neighbors
+				if (!abstractGraph.TryGetValue(current.Position, out var connections))
+					continue;
+
+				foreach (var connection in connections)
+				{
+					var neighbor = connection.Destination;
+
+					// Skip if already evaluated or excluded (unless it's the target)
+					if (closedSet.Contains(neighbor) || (excludedNodes.Contains(neighbor) && neighbor != target))
+						continue;
+
+					var newCost = current.CostFromStart + connection.Cost;
+
+					// If this is a new node or we found a better path to it
+					if (!openSet.TryGetValue(neighbor, out var neighborNode))
+					{
+						neighborNode = new PathNode
+						{
+							Position = neighbor,
+							CostFromStart = newCost,
+							EstimatedTotalCost = newCost + Heuristic(neighbor, target),
+							Parent = current
+						};
+						openSet[neighbor] = neighborNode;
+					}
+					else if (newCost < neighborNode.CostFromStart)
+					{
+						neighborNode.CostFromStart = newCost;
+						neighborNode.EstimatedTotalCost = newCost + Heuristic(neighbor, target);
+						neighborNode.Parent = current;
+					}
+				}
+			}
+
+			// No path found
+			return null;
+		}
+
+		// Reconstructs the path by following parent pointers from target back to source.
+		static List<CPos> ReconstructPath(PathNode targetNode)
+		{
+			var path = new List<CPos>();
+			var current = targetNode;
+
+			while (current != null)
+			{
+				path.Add(current.Position);
+				current = current.Parent;
+			}
+
+			path.Reverse();
+			return path;
+		}
+
+		// Simple heuristic function for A* pathfinding (Manhattan distance).
+		static int Heuristic(CPos from, CPos to)
+		{
+			var delta = from - to;
+			return Math.Abs(delta.X) + Math.Abs(delta.Y);
+		}
+
+		// Helper class to represent a node in the A* pathfinding algorithm.
+		class PathNode
+		{
+			public CPos Position;
+			public int CostFromStart;
+			public int EstimatedTotalCost;
+			public PathNode Parent;
+		}
+
+		public static bool PathExistsForLocomotor(
+			World world,
+			Locomotor locomotor,
+			CPos source,
+			CPos target)
+		{
+			var pathFinder = world.WorldActor.TraitOrDefault<IPathFinder>();
+
+			if (pathFinder == null)
+				return false;
+
+			return pathFinder.PathExistsForLocomotor(locomotor, source, target);
+		}
 	}
 }

OpenRA.Mods.CA/Scripting/BuildingProperties.cs

@@ -27,6 +27,6 @@ public BuildingProperties(ScriptContext context, Actor self)
 		}
 
 		[Desc("Returns the building's footprint cells.")]
-		public CPos[] FootprintCells => building.Info.Tiles(Self.Location).ToArray();
+		public CPos[] FootprintCells => building.Info.Tiles(Self.Location).OrderBy(t => t.Y).ThenBy(t => t.X).ToArray();
 	}
 }

OpenRA.Mods.CA/Scripting/TargetedLeapAbilityGlobal.cs

@@ -30,7 +30,7 @@ public TargetableLeapAbilityProperties(ScriptContext context, Actor self)
 		public void TargetedLeap(CPos targetCell)
 		{
 			var target = Target.FromCell(Self.World, targetCell);
-			LeapAbility.ResolveOrder(Self, new Order("TargetableLeapOrderLeap", Self, target, true));
+			LeapAbility.ResolveOrder(Self, new Order("TargetedLeapOrderLeap", Self, target, true));
 		}
 	}
 }

OpenRA.Mods.CA/Traits/BotModules/SquadManagerBotModuleCA.cs

@@ -30,6 +30,10 @@ public class SquadManagerBotModuleCAInfo : ConditionalTraitInfo
 		[Desc("Actor types that are excluded from ground attacks.")]
 		public readonly HashSet<string> AirUnitsTypes = new HashSet<string>();
 
+		[ActorReference]
+		[Desc("Actor types that are valid for harasser squads.")]
+		public readonly HashSet<string> HarasserTypes = new HashSet<string>();
+
 		[ActorReference]
 		[Desc("Actor types that should generally be excluded from attack squads.")]
 		public readonly HashSet<string> ExcludeFromSquadsTypes = new HashSet<string>();
@@ -49,12 +53,6 @@ public class SquadManagerBotModuleCAInfo : ConditionalTraitInfo
 		[Desc("Target types are used for identifying aircraft.")]
 		public readonly BitSet<TargetableType> AircraftTargetType = new("Air");
 
-		[Desc("Minimum number of units AI must have before attacking.")]
-		public readonly int SquadSize = 8;
-
-		[Desc("Random number of up to this many units is added to squad size when creating an attack squad.")]
-		public readonly int SquadSizeRandomBonus = 30;
-
 		[Desc("Delay (in ticks) between giving out orders to units.")]
 		public readonly int AssignRolesInterval = 50;
 
@@ -102,8 +100,14 @@ public class SquadManagerBotModuleCAInfo : ConditionalTraitInfo
 		[Desc("Minimum value of units AI must have before attacking.")]
 		public readonly int SquadValue = 0;
 
-		[Desc("Random number of up to this value units is added to squad valuee when creating an attack squad.")]
-		public readonly int SquadValueRandomBonus = 0;
+		[Desc("Random number of up to this value units is added to squad value when creating an attack squad.")]
+		public readonly int SquadValueMaxEarlyBonus = 0;
+
+		[Desc("The random number added to squad value increases to this value over the first 20 minutes.")]
+		public readonly int SquadValueMinLateBonus = 0;
+
+		[Desc("The random number added to squad value increases to this value over the first 20 minutes.")]
+		public readonly int SquadValueMaxLateBonus = 0;
 
 		[Desc("Percent change for ground squads to attack a random priority target rather than the closest enemy.")]
 		public readonly int HighValueTargetPriority = 0;
@@ -123,12 +127,21 @@ public class SquadManagerBotModuleCAInfo : ConditionalTraitInfo
 		[Desc("Air threats to prioritise above all others.")]
 		public readonly HashSet<string> BigAirThreats = new HashSet<string>();
 
+		[Desc("Percent chance to take a less direct route to targets.")]
+		public readonly int IndirectRouteChance = 50;
+
 		public override void RulesetLoaded(Ruleset rules, ActorInfo ai)
 		{
 			base.RulesetLoaded(rules, ai);
 
 			if (DangerScanRadius <= 0)
 				throw new YamlException("DangerScanRadius must be greater than zero.");
+
+			if (SquadValueMaxEarlyBonus > SquadValueMaxLateBonus)
+				throw new YamlException("SquadValueMaxEarlyBonus cannot be greater than SquadValueMaxLateBonus.");
+
+			if (SquadValueMinLateBonus > SquadValueMaxLateBonus)
+				throw new YamlException("SquadValueMinLateBonus cannot be greater than SquadValueMaxLateBonus.");
 		}
 
 		public override object Create(ActorInitializer init) { return new SquadManagerBotModuleCA(init.Self, this); }
@@ -175,7 +188,8 @@ public CPos GetRandomBaseCenter()
 		Actor protectOwnFrom; // CA: Track what we're protecting from
 
 		int desiredAttackForceValue; // CA: Value-based squad thresholds
-		int desiredAttackForceSize;
+
+		Dictionary<string, int> cachedUnitValues = new();
 
 		public SquadManagerBotModuleCA(Actor self, SquadManagerBotModuleCAInfo info)
 			: base(info)
@@ -482,6 +496,27 @@ void FindNewUnits(IBot bot)
 						newNavalSquad.Units.Add(a);
 					}
 				}
+				else if (Info.HarasserTypes.Contains(a.Info.Name))
+				{
+					var harasserSquads = Squads.Where(s => s.Type == SquadCAType.Harass);
+					var matchingHarasserSquadFound = false;
+
+					foreach (var harasserSquad in harasserSquads)
+					{
+						if (harasserSquad.Units.Any(u => u.Info.Name == a.Info.Name))
+						{
+							harasserSquad.Units.Add(a);
+							matchingHarasserSquadFound = true;
+							break;
+						}
+					}
+
+					if (!matchingHarasserSquadFound)
+					{
+						var newHarasserSquad = RegisterNewSquad(bot, SquadCAType.Harass);
+						newHarasserSquad.Units.Add(a);
+					}
+				}
 				else
 					unitsHangingAroundTheBase.Add(a);
 
@@ -503,13 +538,17 @@ void CreateAttackForce(IBot bot)
 			{
 				foreach (var a in unitsHangingAroundTheBase)
 				{
-					var valued = a.Info.TraitInfoOrDefault<ValuedInfo>();
-					if (valued != null)
-						idleUnitsValue += valued.Cost;
+					if (!cachedUnitValues.TryGetValue(a.Info.Name, out var unitCost))
+					{
+						unitCost = a.Info.TraitInfoOrDefault<ValuedInfo>()?.Cost ?? 0;
+						cachedUnitValues[a.Info.Name] = unitCost;
+					}
+
+					idleUnitsValue += unitCost;
 				}
 			}
 
-			if (idleUnitsValue >= desiredAttackForceValue && unitsHangingAroundTheBase.Count >= desiredAttackForceSize)
+			if (idleUnitsValue >= desiredAttackForceValue)
 			{
 				var attackForce = RegisterNewSquad(bot, SquadCAType.Assault);
 
@@ -526,11 +565,18 @@ void CreateAttackForce(IBot bot)
 
 		void SetNextDesiredAttackForce()
 		{
-			desiredAttackForceSize = Info.SquadSize + World.LocalRandom.Next(Info.SquadSizeRandomBonus);
-			desiredAttackForceValue = 0;
+			desiredAttackForceValue = Info.SquadValue;
+
+			// Add a random bonus between a min and max that scale over the first 20 minutes.
+			// Min scales from 0 to SquadValueMinLateBonus; max scales from SquadValueMaxEarlyBonus to SquadValueMaxLateBonus.
+			var t = Math.Min(1f, World.WorldTick / (20f * 60f * 25f));
+			var minBonus = (int)(Info.SquadValueMinLateBonus * t);
+			var maxBonus = (int)(Info.SquadValueMaxEarlyBonus + (Info.SquadValueMaxLateBonus - Info.SquadValueMaxEarlyBonus) * t);
 
-			if (Info.SquadValue > 0) // CA: Value-based squad thresholds
-				desiredAttackForceValue = Info.SquadValue + World.LocalRandom.Next(Info.SquadValueRandomBonus);
+			if (maxBonus <= minBonus)
+				desiredAttackForceValue += minBonus;
+			else
+				desiredAttackForceValue += World.LocalRandom.Next(minBonus, maxBonus);
 		}
 
 		void ProtectOwn(IBot bot, Actor attacker)
@@ -671,7 +717,7 @@ bool IsValidEnemyUnit(Actor a)
 
 		public bool IsPreferredEnemyBuilding(Actor a)
 		{
-			return IsValidEnemyUnit(a) && a.Info.HasTraitInfo<BuildingInfo>();
+			return IsValidEnemyUnit(a) && a.Info.HasTraitInfo<RepairableBuildingInfo>();
 		}
 
 		public bool IsPreferredEnemyAircraft(Actor a)