Merge pull request #8388 from reaperrr/selectable-refactor1

Selectable bounds/selection box refactor

OpenRA.Mods.Common/Graphics/SelectionBoxRenderable.cs

@@ -0,0 +1,72 @@
+#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.Drawing;
+using OpenRA.Graphics;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Graphics
+{
+	public struct SelectionBoxRenderable : IRenderable, IFinalizedRenderable
+	{
+		readonly WPos pos;
+		readonly float scale;
+		readonly Rectangle visualBounds;
+		readonly Color color;
+
+		public SelectionBoxRenderable(Actor actor, Color color)
+			: this(actor.CenterPosition, actor.VisualBounds, 1f, color) { }
+
+		public SelectionBoxRenderable(WPos pos, Rectangle visualBounds, float scale, Color color)
+		{
+			this.pos = pos;
+			this.visualBounds = visualBounds;
+			this.scale = scale;
+			this.color = color;
+		}
+
+		public WPos Pos { get { return pos; } }
+
+		public PaletteReference Palette { get { return null; } }
+		public int ZOffset { get { return 0; } }
+		public bool IsDecoration { get { return true; } }
+
+		public IRenderable WithPalette(PaletteReference newPalette) { return this; }
+		public IRenderable WithZOffset(int newOffset) { return this; }
+		public IRenderable OffsetBy(WVec vec) { return new SelectionBoxRenderable(pos + vec, visualBounds, scale, color); }
+		public IRenderable AsDecoration() { return this; }
+
+		public IFinalizedRenderable PrepareRender(WorldRenderer wr) { return this; }
+		public void Render(WorldRenderer wr)
+		{
+			var screenPos = wr.ScreenPxPosition(pos);
+			var tl = screenPos + scale * new float2(visualBounds.Left, visualBounds.Top);
+			var br = screenPos + scale * new float2(visualBounds.Right, visualBounds.Bottom);
+			var tr = new float2(br.X, tl.Y);
+			var bl = new float2(tl.X, br.Y);
+			var u = new float2(4f / wr.Viewport.Zoom, 0);
+			var v = new float2(0, 4f / wr.Viewport.Zoom);
+
+			var wlr = Game.Renderer.WorldLineRenderer;
+			wlr.DrawLine(tl + u, tl, color);
+			wlr.DrawLine(tl, tl + v, color);
+			wlr.DrawLine(tr, tr - u, color);
+			wlr.DrawLine(tr, tr + v, color);
+
+			wlr.DrawLine(bl, bl + u, color);
+			wlr.DrawLine(bl, bl - v, color);
+			wlr.DrawLine(br, br - u, color);
+			wlr.DrawLine(br, br - v, color);
+		}
+
+		public void RenderDebugGeometry(WorldRenderer wr) { }
+		public Rectangle ScreenBounds(WorldRenderer wr) { return Rectangle.Empty; }
+	}
+}

OpenRA.Mods.Common/OpenRA.Mods.Common.csproj

@@ -171,6 +171,7 @@
     <Compile Include="Graphics\BeamRenderable.cs" />
     <Compile Include="Graphics\ContrailRenderable.cs" />
     <Compile Include="Graphics\RangeCircleRenderable.cs" />
+    <Compile Include="Graphics\SelectionBoxRenderable.cs" />
     <Compile Include="Graphics\SpriteActorPreview.cs" />
     <Compile Include="Graphics\TextRenderable.cs" />
     <Compile Include="Graphics\VoxelActorPreview.cs" />
@@ -309,6 +310,7 @@
     <Compile Include="Traits\Crushable.cs" />
     <Compile Include="Traits\CustomBuildTimeValue.cs" />
     <Compile Include="Traits\CustomSellValue.cs" />
+    <Compile Include="Traits\CustomSelectionSize.cs" />
     <Compile Include="Traits\Demolishable.cs" />
     <Compile Include="Traits\DetectCloaked.cs" />
     <Compile Include="Traits\EjectOnDeath.cs" />
@@ -438,6 +440,7 @@
     <Compile Include="Traits\RepairsBridges.cs" />
     <Compile Include="Traits\SeedsResource.cs" />
     <Compile Include="Traits\StoresResources.cs" />
+    <Compile Include="Traits\Render\SelectionDecorations.cs" />
     <Compile Include="Traits\SelfHealing.cs" />
     <Compile Include="Traits\Sellable.cs" />
     <Compile Include="Traits\ShakeOnDeath.cs" />

OpenRA.Mods.Common/Traits/CustomSelectionSize.cs

@@ -0,0 +1,36 @@
+#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 OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	[Desc("Special case trait for unselectable actors that need to define targetable area bounds",
+	"for special cases like C4, engineer repair and tooltips.",
+	"Examples: bridge huts and crates.")]
+	public class CustomSelectionSizeInfo : ITraitInfo
+	{
+		public readonly int[] CustomBounds = null;
+
+		public object Create(ActorInitializer init) { return new CustomSelectionSize(this); }
+	}
+
+	public class CustomSelectionSize : IAutoSelectionSize
+	{
+		readonly CustomSelectionSizeInfo info;
+		public CustomSelectionSize(CustomSelectionSizeInfo info) { this.info = info; }
+
+		public int2 SelectionSize(Actor self)
+		{
+			return new int2(info.CustomBounds[0], info.CustomBounds[1]);
+		}
+	}
+}

OpenRA.Mods.Common/Traits/Render/SelectionDecorations.cs

@@ -0,0 +1,177 @@
+#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.Drawing;
+using System.Linq;
+using OpenRA.Graphics;
+using OpenRA.Mods.Common.Graphics;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	public class SelectionDecorationsInfo : ITraitInfo, ISelectionDecorationsInfo
+	{
+		public readonly string Palette = "chrome";
+
+		[Desc("Visual bounds for selection box. If null, it uses AutoSelectionSize.",
+		"The first two values define the bounds' size, the optional third and fourth",
+		"values specify the position relative to the actors' center. Defaults to selectable bounds.")]
+		public readonly int[] VisualBounds = null;
+
+		[Desc("Health bar, production progress bar etc.")]
+		public readonly bool RenderSelectionBars = true;
+
+		public readonly bool RenderSelectionBox = true;
+
+		public readonly Color SelectionBoxColor = Color.White;
+
+		public object Create(ActorInitializer init) { return new SelectionDecorations(init.Self, this); }
+
+		public int[] SelectionBoxBounds { get { return VisualBounds; } }
+	}
+
+	public class SelectionDecorations : IPostRenderSelection
+	{
+		// depends on the order of pips in TraitsInterfaces.cs!
+		static readonly string[] PipStrings = { "pip-empty", "pip-green", "pip-yellow", "pip-red", "pip-gray", "pip-blue", "pip-ammo", "pip-ammoempty" };
+		static readonly string[] TagStrings = { "", "tag-fake", "tag-primary" };
+
+		public readonly SelectionDecorationsInfo Info;
+		readonly Actor self;
+
+		public SelectionDecorations(Actor self, SelectionDecorationsInfo info)
+		{
+			this.self = self;
+			Info = info;
+		}
+
+		IEnumerable<WPos> ActivityTargetPath()
+		{
+			if (!self.IsInWorld || self.IsDead)
+				yield break;
+
+			var activity = self.GetCurrentActivity();
+			if (activity != null)
+			{
+				var targets = activity.GetTargets(self);
+				yield return self.CenterPosition;
+
+				foreach (var t in targets.Where(t => t.Type != TargetType.Invalid))
+					yield return t.CenterPosition;
+			}
+		}
+
+		public IEnumerable<IRenderable> RenderAfterWorld(WorldRenderer wr)
+		{
+			if (!self.Owner.IsAlliedWith(self.World.RenderPlayer) || self.World.FogObscures(self))
+				yield break;
+
+			if (Info.RenderSelectionBox)
+				yield return new SelectionBoxRenderable(self, Info.SelectionBoxColor);
+
+			if (Info.RenderSelectionBars)
+				yield return new SelectionBarsRenderable(self);
+
+			if (self.World.LocalPlayer != null && self.World.LocalPlayer.PlayerActor.Trait<DeveloperMode>().PathDebug)
+				yield return new TargetLineRenderable(ActivityTargetPath(), Color.Green);
+
+			var b = self.VisualBounds;
+			var pos = wr.ScreenPxPosition(self.CenterPosition);
+			var tl = wr.Viewport.WorldToViewPx(pos + new int2(b.Left, b.Top));
+			var bl = wr.Viewport.WorldToViewPx(pos + new int2(b.Left, b.Bottom));
+			var tm = wr.Viewport.WorldToViewPx(pos + new int2((b.Left + b.Right) / 2, b.Top));
+
+			foreach (var r in DrawControlGroup(wr, self, tl))
+				yield return r;
+
+			foreach (var r in DrawPips(wr, self, bl))
+				yield return r;
+
+			foreach (var r in DrawTags(wr, self, tm))
+				yield return r;
+		}
+
+		IEnumerable<IRenderable> DrawControlGroup(WorldRenderer wr, Actor self, int2 basePosition)
+		{
+			var group = self.World.Selection.GetControlGroupForActor(self);
+			if (group == null)
+				yield break;
+
+			var pipImages = new Animation(self.World, "pips");
+			var pal = wr.Palette(Info.Palette);
+			pipImages.PlayFetchIndex("groups", () => (int)group);
+			pipImages.Tick();
+
+			var pos = basePosition - (0.5f * pipImages.Image.Size).ToInt2() + new int2(9, 5);
+			yield return new UISpriteRenderable(pipImages.Image, pos, 0, pal, 1f);
+		}
+
+		IEnumerable<IRenderable> DrawPips(WorldRenderer wr, Actor self, int2 basePosition)
+		{
+			var pipSources = self.TraitsImplementing<IPips>();
+			if (!pipSources.Any())
+				yield break;
+
+			var pipImages = new Animation(self.World, "pips");
+			pipImages.PlayRepeating(PipStrings[0]);
+
+			var pipSize = pipImages.Image.Size.ToInt2();
+			var pipxyBase = basePosition + new int2(1 - pipSize.X / 2, -(3 + pipSize.Y / 2));
+			var pipxyOffset = new int2(0, 0);
+			var pal = wr.Palette(Info.Palette);
+			var width = self.VisualBounds.Width;
+
+			foreach (var pips in pipSources)
+			{
+				var thisRow = pips.GetPips(self);
+				if (thisRow == null)
+					continue;
+
+				foreach (var pip in thisRow)
+				{
+					if (pipxyOffset.X + pipSize.X >= width)
+						pipxyOffset = new int2(0, pipxyOffset.Y - pipSize.Y);
+
+					pipImages.PlayRepeating(PipStrings[(int)pip]);
+					pipxyOffset += new int2(pipSize.X, 0);
+
+					yield return new UISpriteRenderable(pipImages.Image, pipxyBase + pipxyOffset, 0, pal, 1f);
+				}
+
+				// Increment row
+				pipxyOffset = new int2(0, pipxyOffset.Y - (pipSize.Y + 1));
+			}
+		}
+
+		IEnumerable<IRenderable> DrawTags(WorldRenderer wr, Actor self, int2 basePosition)
+		{
+			var tagImages = new Animation(self.World, "pips");
+			var pal = wr.Palette(Info.Palette);
+			var tagxyOffset = new int2(0, 6);
+
+			foreach (var tags in self.TraitsImplementing<ITags>())
+			{
+				foreach (var tag in tags.GetTags())
+				{
+					if (tag == TagType.None)
+						continue;
+
+					tagImages.PlayRepeating(TagStrings[(int)tag]);
+					var pos = basePosition + tagxyOffset - (0.5f * tagImages.Image.Size).ToInt2();
+					yield return new UISpriteRenderable(tagImages.Image, pos, 0, pal, 1f);
+
+					// Increment row
+					tagxyOffset = tagxyOffset.WithY(tagxyOffset.Y + 8);
+				}
+			}
+		}
+	}
+}

OpenRA.Mods.Common/Traits/SupportPowers/GrantUpgradePower.cs

@@ -12,6 +12,7 @@ using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
 using OpenRA.Graphics;
+using OpenRA.Mods.Common.Graphics;
 using OpenRA.Traits;
 
 namespace OpenRA.Mods.Common.Traits

OpenRA.Mods.Common/UtilityCommands/UpgradeRules.cs

@@ -1152,6 +1152,29 @@ namespace OpenRA.Mods.Common.UtilityCommands
 					}
 				}
 
+				// 'Selectable' boolean was removed from selectable trait.
+				if (engineVersion < 20150619)
+				{
+					if (depth == 1 && node.Value.Nodes.Exists(n => n.Key == "Selectable"))
+					{
+						var selectable = node.Value.Nodes.FirstOrDefault(n => n.Key == "Selectable");
+						if (node.Key == "Selectable" && selectable.Value.Value == "false")
+							node.Key = "SelectableRemoveMe";
+
+						// To cover rare cases where the boolean was 'true'
+						if (node.Key == "Selectable" && selectable.Value.Value == "true")
+							node.Value.Nodes.Remove(selectable);
+					}
+
+					if (depth == 0 && node.Value.Nodes.Exists(n => n.Key == "SelectableRemoveMe"))
+						node.Value.Nodes.RemoveAll(n => n.Key == "SelectableRemoveMe");
+						Console.WriteLine("The 'Selectable' boolean has been removed from the Selectable trait.");
+						Console.WriteLine("If you just want to disable an inherited Selectable trait, use -Selectable instead.");
+						Console.WriteLine("For special cases like bridge huts, which need bounds to be targetable by C4 and engineers,");
+						Console.WriteLine("give them the CustomSelectionSize trait with CustomBounds.");
+						Console.WriteLine("See RA and C&C bridge huts or crates for reference.");
+				}
+
 				UpgradeActorRules(engineVersion, ref node.Value.Nodes, node, depth + 1);
 			}
 		}