Extract StoresResources from Harvester

OpenRA.Game/Traits/TraitsInterfaces.cs

@@ -173,7 +173,31 @@ public interface IVoiced
 	}
 
 	[RequireExplicitImplementation]
-	public interface IStoreResources { int Capacity { get; } }
+	public interface IStoresResourcesInfo : ITraitInfoInterface
+	{
+		string[] ResourceTypes { get; }
+	}
+
+	public interface IStoresResources
+	{
+		bool HasType(string resourceType);
+
+		/// <summary>The amount of resources that can be stored.</summary>
+		int Capacity { get; }
+
+		/// <summary>Stored resources.</summary>
+		/// <remarks>Dictionary key refers to resourceType, value refers to resource amount.</remarks>
+		IReadOnlyDictionary<string, int> Contents { get; }
+
+		/// <summary>A performance cheap method of getting the total sum of contents.</summary>
+		int ContentsSum { get; }
+
+		/// <summary>Returns the amount of <paramref name="value"/> that was not added.</summary>
+		int AddResource(string resourceType, int value);
+
+		/// <summary>Returns the amount of <paramref name="value"/> that was not removed.</summary>
+		int RemoveResource(string resourceType, int value);
+	}
 
 	public interface IEffectiveOwner
 	{

OpenRA.Mods.Common/Activities/HarvestResource.cs

@@ -87,7 +87,7 @@ public override bool Tick(Actor self)
 			if (resource.Type == null || resourceLayer.RemoveResource(resource.Type, self.Location) != 1)
 				return true;
 
-			harv.AcceptResource(self, resource.Type);
+			harv.AddResource(self, resource.Type);
 
 			foreach (var t in notifyHarvestActions)
 				t.Harvested(self, resource.Type);

OpenRA.Mods.Common/Traits/Harvester.cs

@@ -11,25 +11,21 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using OpenRA.Mods.Common.Activities;
 using OpenRA.Primitives;
 using OpenRA.Traits;
 
 namespace OpenRA.Mods.Common.Traits
 {
-	public class HarvesterInfo : DockClientBaseInfo, Requires<MobileInfo>
+	public class HarvesterInfo : DockClientBaseInfo, Requires<MobileInfo>, Requires<IStoresResourcesInfo>, IRulesetLoaded
 	{
 		[Desc("Docking type")]
 		public readonly BitSet<DockType> Type = new("Unload");
 
 		[Desc("Cell to move to when automatically unblocking DeliveryBuilding.")]
 		public readonly CVec UnblockCell = new(0, 4);
 
-		[Desc("How much resources it can carry.")]
-		public readonly int Capacity = 28;
-
 		public readonly int BaleLoadDelay = 4;
 
 		[Desc("How fast it can dump its bales.")]
@@ -41,7 +37,7 @@ public class HarvesterInfo : DockClientBaseInfo, Requires<MobileInfo>
 		public readonly int HarvestFacings = 0;
 
 		[Desc("Which resources it can harvest.")]
-		public readonly HashSet<string> Resources = new();
+		public readonly string[] Resources = Array.Empty<string>();
 
 		[Desc("Percentage of maximum speed when fully loaded.")]
 		public readonly int FullyLoadedSpeed = 85;
@@ -79,41 +75,37 @@ public class HarvesterInfo : DockClientBaseInfo, Requires<MobileInfo>
 		public readonly string HarvestCursor = "harvest";
 
 		public override object Create(ActorInitializer init) { return new Harvester(init.Self, this); }
+
+		void IRulesetLoaded<ActorInfo>.RulesetLoaded(Ruleset rules, ActorInfo info)
+		{
+			if (Resources.Length == 0)
+				throw new YamlException($"Harvester.{nameof(Resources)} is empty.");
+
+			var resourceTypes = Resources.Except(info.TraitInfos<IStoresResourcesInfo>().SelectMany(sr => sr.ResourceTypes)).ToArray();
+			if (resourceTypes.Length != 0)
+				throw new YamlException($"Invalid Harvester.{nameof(Resources)} types: {string.Join(',', resourceTypes)}.");
+		}
 	}
 
 	public class Harvester : DockClientBase<HarvesterInfo>, IIssueOrder, IResolveOrder, IOrderVoice,
 		ISpeedModifier, ISync, INotifyCreated
 	{
-		public readonly IReadOnlyDictionary<string, int> Contents;
-
 		readonly Mobile mobile;
 		readonly IResourceLayer resourceLayer;
 		readonly ResourceClaimLayer claimLayer;
-		readonly Dictionary<string, int> contents = new();
+		readonly IStoresResources[] storesResources;
 		int conditionToken = Actor.InvalidConditionToken;
 
 		public override BitSet<DockType> GetDockType => Info.Type;
 
 		[Sync]
 		int currentUnloadTicks;
 
-		[Sync]
-		public int ContentHash
-		{
-			get
-			{
-				var value = 0;
-				foreach (var c in contents)
-					value += c.Value << c.Key.Length;
-				return value;
-			}
-		}
-
 		public Harvester(Actor self, HarvesterInfo info)
 			: base(self, info)
 		{
-			Contents = new ReadOnlyDictionary<string, int>(contents);
 			mobile = self.Trait<Mobile>();
+			storesResources = self.TraitsImplementing<IStoresResources>().Where(sr => info.Resources.Any(r => sr.HasType(r))).ToArray();
 			resourceLayer = self.World.WorldActor.Trait<IResourceLayer>();
 			claimLayer = self.World.WorldActor.Trait<ResourceClaimLayer>();
 		}
@@ -129,9 +121,9 @@ protected override void Created(Actor self)
 			base.Created(self);
 		}
 
-		public bool IsFull => contents.Values.Sum() == Info.Capacity;
-		public bool IsEmpty => contents.Values.Sum() == 0;
-		public int Fullness => contents.Values.Sum() * 100 / Info.Capacity;
+		public bool IsFull => storesResources.All(sr => sr.ContentsSum >= sr.Capacity);
+		public bool IsEmpty => storesResources.All(sr => sr.ContentsSum == 0);
+		public int Fullness => storesResources.Sum(sr => sr.ContentsSum * 100 / sr.Capacity) / storesResources.Length;
 
 		protected override bool CanDock()
 		{
@@ -151,12 +143,11 @@ void UpdateCondition(Actor self)
 				conditionToken = self.RevokeCondition(conditionToken);
 		}
 
-		public void AcceptResource(Actor self, string resourceType)
+		public void AddResource(Actor self, string resourceType)
 		{
-			if (!contents.ContainsKey(resourceType))
-				contents[resourceType] = 1;
-			else
-				contents[resourceType]++;
+			foreach (var sr in storesResources)
+				if (sr.AddResource(resourceType, 1) == 0)
+					break;
 
 			UpdateCondition(self);
 		}
@@ -177,27 +168,23 @@ public override bool OnDockTick(Actor self, Actor hostActor, IDockHost host)
 			if (--currentUnloadTicks > 0)
 				return false;
 
-			if (contents.Keys.Count > 0)
+			foreach (var sr in storesResources)
 			{
-				foreach (var c in contents)
+				foreach (var c in sr.Contents)
 				{
-					var resourceType = c.Key;
 					var count = Math.Min(c.Value, Info.BaleUnloadAmount);
-					var accepted = acceptResources.AcceptResources(hostActor, resourceType, count);
+					var accepted = acceptResources.AcceptResources(hostActor, c.Key, count);
 					if (accepted == 0)
 						continue;
 
-					contents[resourceType] -= accepted;
-					if (contents[resourceType] <= 0)
-						contents.Remove(resourceType);
-
+					sr.RemoveResource(c.Key, accepted);
 					currentUnloadTicks = Info.BaleUnloadDelay;
 					UpdateCondition(self);
 					return false;
 				}
 			}
 
-			return contents.Count == 0;
+			return IsEmpty;
 		}
 
 		public override void OnDockCompleted(Actor self, Actor hostActor, IDockHost dock)
@@ -279,13 +266,12 @@ void IResolveOrder.ResolveOrder(Actor self, Order order)
 
 		int ISpeedModifier.GetSpeedModifier()
 		{
-			return 100 - (100 - Info.FullyLoadedSpeed) * contents.Values.Sum() / Info.Capacity;
+			return 100 - (100 - Info.FullyLoadedSpeed) * Fullness / 100;
 		}
 
 		protected override void TraitDisabled(Actor self)
 		{
 			base.TraitDisabled(self);
-			contents.Clear();
 
 			if (conditionToken != Actor.InvalidConditionToken)
 				conditionToken = self.RevokeCondition(conditionToken);

OpenRA.Mods.Common/Traits/Player/PlayerResources.cs

@@ -206,12 +206,12 @@ public bool TakeCash(int num, bool notifyLowFunds = false)
 			return true;
 		}
 
-		public void AddStorage(int capacity)
+		public void AddStorageCapacity(int capacity)
 		{
 			ResourceCapacity += capacity;
 		}
 
-		public void RemoveStorage(int capacity)
+		public void RemoveStorageCapacity(int capacity)
 		{
 			ResourceCapacity -= capacity;
 

OpenRA.Mods.Common/Traits/Render/WithHarvesterPipsDecoration.cs → OpenRA.Mods.Common/Traits/Render/WithStoresResourcesPipsDecoration.cs

@@ -10,12 +10,13 @@
 #endregion
 
 using System.Collections.Generic;
+using System.Linq;
 using OpenRA.Graphics;
 using OpenRA.Traits;
 
 namespace OpenRA.Mods.Common.Traits.Render
 {
-	public class WithHarvesterPipsDecorationInfo : WithDecorationBaseInfo, Requires<HarvesterInfo>
+	public class WithStoresResourcesPipsDecorationInfo : WithDecorationBaseInfo, Requires<IStoresResourcesInfo>
 	{
 		[FieldLoader.Require]
 		[Desc("Number of pips to display how filled unit is.")]
@@ -42,26 +43,27 @@ public class WithHarvesterPipsDecorationInfo : WithDecorationBaseInfo, Requires<
 		[PaletteReference]
 		public readonly string Palette = "chrome";
 
-		public override object Create(ActorInitializer init) { return new WithHarvesterPipsDecoration(init.Self, this); }
+		public override object Create(ActorInitializer init) { return new WithStoresResourcesPipsDecoration(init.Self, this); }
 	}
 
-	public class WithHarvesterPipsDecoration : WithDecorationBase<WithHarvesterPipsDecorationInfo>
+	public class WithStoresResourcesPipsDecoration : WithDecorationBase<WithStoresResourcesPipsDecorationInfo>
 	{
-		readonly Harvester harvester;
+		readonly IStoresResources storesResources;
 		readonly Animation pips;
 
-		public WithHarvesterPipsDecoration(Actor self, WithHarvesterPipsDecorationInfo info)
+		public WithStoresResourcesPipsDecoration(Actor self, WithStoresResourcesPipsDecorationInfo info)
 			: base(self, info)
 		{
-			harvester = self.Trait<Harvester>();
+			// TODO: allow to choose which stores resources trait to target.
+			storesResources = self.TraitsImplementing<IStoresResources>().First();
 			pips = new Animation(self.World, info.Image);
 		}
 
 		string GetPipSequence(int i)
 		{
-			var n = i * harvester.Info.Capacity / Info.PipCount;
+			var n = i * storesResources.Capacity / Info.PipCount;
 
-			foreach (var rt in harvester.Contents)
+			foreach (var rt in storesResources.Contents)
 			{
 				if (n < rt.Value)
 				{

OpenRA.Mods.Common/Traits/StoresPlayerResources.cs

@@ -0,0 +1,67 @@
+#region Copyright & License Information
+/*
+ * Copyright (c) The OpenRA Developers and Contributors
+ * 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 OpenRA.Primitives;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	[Desc("Adds capacity to a player's harvested resource limit.")]
+	public class StoresPlayerResourcesInfo : TraitInfo
+	{
+		[FieldLoader.Require]
+		public readonly int Capacity = 0;
+
+		public override object Create(ActorInitializer init) { return new StoresPlayerResources(init.Self, this); }
+	}
+
+	public class StoresPlayerResources : INotifyOwnerChanged, INotifyCapture, INotifyKilled, INotifyAddedToWorld, INotifyRemovedFromWorld
+	{
+		readonly StoresPlayerResourcesInfo info;
+		PlayerResources player;
+
+		public int Stored => player.ResourceCapacity == 0 ? 0 : (int)((long)info.Capacity * player.Resources / player.ResourceCapacity);
+
+		public StoresPlayerResources(Actor self, StoresPlayerResourcesInfo info)
+		{
+			this.info = info;
+			player = self.Owner.PlayerActor.Trait<PlayerResources>();
+		}
+
+		void INotifyOwnerChanged.OnOwnerChanged(Actor self, Player oldOwner, Player newOwner)
+		{
+			player = newOwner.PlayerActor.Trait<PlayerResources>();
+		}
+
+		void INotifyCapture.OnCapture(Actor self, Actor captor, Player oldOwner, Player newOwner, BitSet<CaptureType> captureTypes)
+		{
+			var resources = Stored;
+			oldOwner.PlayerActor.Trait<PlayerResources>().TakeResources(resources);
+			newOwner.PlayerActor.Trait<PlayerResources>().GiveResources(resources);
+		}
+
+		void INotifyKilled.Killed(Actor self, AttackInfo e)
+		{
+			// Lose the stored resources.
+			player.TakeResources(Stored);
+		}
+
+		void INotifyAddedToWorld.AddedToWorld(Actor self)
+		{
+			player.AddStorageCapacity(info.Capacity);
+		}
+
+		void INotifyRemovedFromWorld.RemovedFromWorld(Actor self)
+		{
+			player.RemoveStorageCapacity(info.Capacity);
+		}
+	}
+}