Rework harvester automation.

OpenRA.Mods.Common/Activities/FindAndDeliverResources.cs

@@ -0,0 +1,235 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2019 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, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using OpenRA.Activities;
+using OpenRA.Mods.Common.Pathfinder;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Primitives;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Activities
+{
+	public class FindAndDeliverResources : Activity
+	{
+		readonly Harvester harv;
+		readonly HarvesterInfo harvInfo;
+		readonly Mobile mobile;
+		readonly LocomotorInfo locomotorInfo;
+		readonly ResourceClaimLayer claimLayer;
+		readonly IPathFinder pathFinder;
+		readonly DomainIndex domainIndex;
+		readonly Actor deliverActor;
+
+		CPos? orderLocation;
+		bool hasDeliveredLoad;
+		bool hasHarvestedCell;
+		bool hasWaited;
+
+		public FindAndDeliverResources(Actor self, Actor deliverActor = null)
+		{
+			harv = self.Trait<Harvester>();
+			harvInfo = self.Info.TraitInfo<HarvesterInfo>();
+			mobile = self.Trait<Mobile>();
+			locomotorInfo = mobile.Info.LocomotorInfo;
+			claimLayer = self.World.WorldActor.Trait<ResourceClaimLayer>();
+			pathFinder = self.World.WorldActor.Trait<IPathFinder>();
+			domainIndex = self.World.WorldActor.Trait<DomainIndex>();
+			this.deliverActor = deliverActor;
+		}
+
+		public FindAndDeliverResources(Actor self, CPos orderLocation)
+			: this(self, null)
+		{
+			this.orderLocation = orderLocation;
+		}
+
+		protected override void OnFirstRun(Actor self)
+		{
+			// If an explicit "harvest" order is given, direct the harvester to the ordered location instead of
+			// the previous harvested cell for the initial search.
+			if (orderLocation != null)
+			{
+				harv.LastHarvestedCell = orderLocation;
+
+				// If two "harvest" orders are issued consecutively, we deliver the load first if needed.
+				// We have to make sure the actual "harvest" order is not skipped if a third order is queued,
+				// so we keep deliveredLoad false.
+				if (harv.IsFull)
+					QueueChild(self, new DeliverResources(self), true);
+			}
+
+			// If an explicit "deliver" order is given, the harvester goes immediately to the refinery.
+			if (deliverActor != null)
+			{
+				QueueChild(self, new DeliverResources(self, deliverActor), true);
+				hasDeliveredLoad = true;
+			}
+		}
+
+		public override Activity Tick(Actor self)
+		{
+			if (ChildActivity != null)
+			{
+				ChildActivity = ActivityUtils.RunActivity(self, ChildActivity);
+				if (ChildActivity != null)
+					return this;
+			}
+
+			if (IsCanceling)
+				return NextActivity;
+
+			if (NextActivity != null)
+			{
+				// Interrupt automated harvesting after clearing the first cell.
+				if (!harvInfo.QueueFullLoad && (hasHarvestedCell || harv.LastSearchFailed))
+					return NextActivity;
+
+				// Interrupt automated harvesting after first complete harvest cycle.
+				if (hasDeliveredLoad || harv.IsFull)
+					return NextActivity;
+			}
+
+			// Are we full or have nothing more to gather? Deliver resources.
+			if (harv.IsFull || (!harv.IsEmpty && harv.LastSearchFailed))
+			{
+				QueueChild(self, new DeliverResources(self), true);
+				hasDeliveredLoad = true;
+				return this;
+			}
+
+			// After a failed search, wait and sit still for a bit before searching again.
+			if (harv.LastSearchFailed && !hasWaited)
+			{
+				QueueChild(self, new Wait(harv.Info.WaitDuration), true);
+				hasWaited = true;
+				return this;
+			}
+
+			var closestHarvestableCell = ClosestHarvestablePos(self);
+
+			// If no resources are found near the current field, search near the refinery instead.
+			// If that doesn't help, give up for now.
+			if (!closestHarvestableCell.HasValue)
+			{
+				if (harv.LastHarvestedCell != null)
+				{
+					harv.LastHarvestedCell = null; // Forces search from backup position.
+					closestHarvestableCell = ClosestHarvestablePos(self);
+					harv.LastSearchFailed = !closestHarvestableCell.HasValue;
+				}
+				else
+					harv.LastSearchFailed = true;
+			}
+
+			if (harv.LastSearchFailed)
+			{
+				// If no harvestable position could be found and we are at the refinery, get out of the way
+				// of the refinery entrance.
+				var lastproc = harv.LastLinkedProc ?? harv.LinkedProc;
+				if (lastproc != null && !lastproc.Disposed)
+				{
+					var deliveryLoc = lastproc.Location + lastproc.Trait<IAcceptResources>().DeliveryOffset;
+					if (self.Location == deliveryLoc && harv.IsEmpty)
+					{
+						// Get out of the way:
+						var unblockCell = deliveryLoc + harv.Info.UnblockCell;
+						var moveTo = mobile.NearestMoveableCell(unblockCell, 1, 5);
+						self.SetTargetLine(Target.FromCell(self.World, moveTo), Color.Green, false);
+						QueueChild(self, mobile.MoveTo(moveTo, 1), true);
+					}
+				}
+
+				return this;
+			}
+
+			// Attempt to claim the target cell
+			if (!claimLayer.TryClaimCell(self, closestHarvestableCell.Value))
+			{
+				QueueChild(self, new Wait(25), true);
+				return this;
+			}
+
+			harv.LastSearchFailed = false;
+
+			foreach (var n in self.TraitsImplementing<INotifyHarvesterAction>())
+				n.MovingToResources(self, closestHarvestableCell.Value, new FindAndDeliverResources(self));
+
+			self.SetTargetLine(Target.FromCell(self.World, closestHarvestableCell.Value), Color.Red, false);
+			QueueChild(self, mobile.MoveTo(closestHarvestableCell.Value, 1), true);
+			QueueChild(self, new HarvestResource(self));
+			hasHarvestedCell = true;
+			return this;
+		}
+
+		/// <summary>
+		/// Finds the closest harvestable pos between the current position of the harvester
+		/// and the last order location
+		/// </summary>
+		CPos? ClosestHarvestablePos(Actor self)
+		{
+			// Harvesters should respect an explicit harvest order instead of harvesting the current cell.
+			if (orderLocation == null)
+			{
+				if (harv.CanHarvestCell(self, self.Location) && claimLayer.CanClaimCell(self, self.Location))
+					return self.Location;
+			}
+			else
+			{
+				if (harv.CanHarvestCell(self, orderLocation.Value) && claimLayer.CanClaimCell(self, orderLocation.Value))
+					return orderLocation;
+
+				orderLocation = null;
+			}
+
+			// Determine where to search from and how far to search:
+			var searchFromLoc = harv.LastHarvestedCell ?? GetSearchFromLocation(self);
+			var searchRadius = harv.LastHarvestedCell.HasValue ? harvInfo.SearchFromOrderRadius : harvInfo.SearchFromProcRadius;
+			var searchRadiusSquared = searchRadius * searchRadius;
+
+			// Find any harvestable resources:
+			List<CPos> path;
+			using (var search = PathSearch.Search(self.World, locomotorInfo, self, true, loc =>
+					domainIndex.IsPassable(self.Location, loc, locomotorInfo) && harv.CanHarvestCell(self, loc) && claimLayer.CanClaimCell(self, loc))
+				.WithCustomCost(loc =>
+				{
+					if ((loc - searchFromLoc).LengthSquared > searchRadiusSquared)
+						return int.MaxValue;
+
+					return 0;
+				})
+				.FromPoint(searchFromLoc)
+				.FromPoint(self.Location))
+				path = pathFinder.FindPath(search);
+
+			if (path.Count > 0)
+				return path[0];
+
+			return null;
+		}
+
+		public override IEnumerable<Target> GetTargets(Actor self)
+		{
+			yield return Target.FromCell(self.World, self.Location);
+		}
+
+		CPos GetSearchFromLocation(Actor self)
+		{
+			if (harv.LastLinkedProc != null)
+				return harv.LastLinkedProc.Location + harv.LastLinkedProc.Trait<IAcceptResources>().DeliveryOffset;
+
+			if (harv.LinkedProc != null)
+				return harv.LinkedProc.Location + harv.LinkedProc.Trait<IAcceptResources>().DeliveryOffset;
+
+			return self.Location;
+		}
+	}
+}