Simplify and fix code quality in GpsDot.

OpenRA.Mods.Cnc/Effects/GpsDot.cs

@@ -11,6 +11,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using OpenRA.Effects;
 using OpenRA.Graphics;
 using OpenRA.Mods.Cnc.Traits;
@@ -20,7 +21,7 @@
 
 namespace OpenRA.Mods.Cnc.Effects
 {
-	[Desc("Attach this to actors to render pictograms while hidden.")]
+	[Desc("Show an indicator revealing the actor underneath the fog when a GPSWatcher is activated.")]
 	class GpsDotInfo : ITraitInfo
 	{
 		[Desc("Sprite collection for symbols.")]
@@ -31,119 +32,111 @@ class GpsDotInfo : ITraitInfo
 
 		[PaletteReference(true)] public readonly string IndicatorPalettePrefix = "player";
 
-		public object Create(ActorInitializer init)
+		public object Create(ActorInitializer init) { return new GpsDot(init.Self, this); }
+	}
+
+	class GpsDot : INotifyAddedToWorld, INotifyRemovedFromWorld
+	{
+		readonly GpsDotInfo info;
+		GpsDotEffect effect;
+
+		public GpsDot(Actor self, GpsDotInfo info)
 		{
-			return new GpsDot(init.Self, this);
+			this.info = info;
+		}
+
+		void INotifyAddedToWorld.AddedToWorld(Actor self)
+		{
+			effect = new GpsDotEffect(self, info);
+			self.World.AddFrameEndTask(w => w.Add(effect));
+		}
+
+		void INotifyRemovedFromWorld.RemovedFromWorld(Actor self)
+		{
+			self.World.AddFrameEndTask(w => w.Remove(effect));
 		}
 	}
 
-	class GpsDot : IEffect, IEffectAboveShroud
+	class GpsDotEffect : IEffect, IEffectAboveShroud
 	{
-		readonly Actor self;
+		readonly Actor actor;
 		readonly GpsDotInfo info;
 		readonly Animation anim;
 
 		readonly PlayerDictionary<DotState> dotStates;
-		readonly Lazy<HiddenUnderFog> huf;
-		readonly Lazy<FrozenUnderFog> fuf;
-		readonly Lazy<Disguise> disguise;
-		readonly Lazy<Cloak> cloak;
-		readonly Cache<Player, FrozenActorLayer> frozen;
+		readonly IDefaultVisibility visibility;
+		readonly IVisibilityModifier[] visibilityModifiers;
 
 		class DotState
 		{
-			public readonly GpsWatcher Gps;
-			public bool IsTargetable;
-			public bool ShouldRender;
-			public DotState(GpsWatcher gps)
+			public readonly GpsWatcher Watcher;
+			public readonly FrozenActor FrozenActor;
+			public bool Visible;
+			public DotState(Actor a, GpsWatcher watcher, FrozenActorLayer frozenLayer)
 			{
-				Gps = gps;
+				Watcher = watcher;
+				if (frozenLayer != null)
+					FrozenActor = frozenLayer.FromID(a.ActorID);
 			}
 		}
 
-		public GpsDot(Actor self, GpsDotInfo info)
+		public GpsDotEffect(Actor actor, GpsDotInfo info)
 		{
-			this.self = self;
+			this.actor = actor;
 			this.info = info;
-			anim = new Animation(self.World, info.Image);
+			anim = new Animation(actor.World, info.Image);
 			anim.PlayRepeating(info.String);
 
-			self.World.AddFrameEndTask(w => w.Add(this));
-
-			huf = Exts.Lazy(() => self.TraitOrDefault<HiddenUnderFog>());
-			fuf = Exts.Lazy(() => self.TraitOrDefault<FrozenUnderFog>());
-			disguise = Exts.Lazy(() => self.TraitOrDefault<Disguise>());
-			cloak = Exts.Lazy(() => self.TraitOrDefault<Cloak>());
+			visibility = actor.TraitOrDefault<IDefaultVisibility>();
+			visibilityModifiers = actor.TraitsImplementing<IVisibilityModifier>().ToArray();
 
-			frozen = new Cache<Player, FrozenActorLayer>(p => p.PlayerActor.Trait<FrozenActorLayer>());
-			dotStates = new PlayerDictionary<DotState>(self.World, player => new DotState(player.PlayerActor.Trait<GpsWatcher>()));
+			dotStates = new PlayerDictionary<DotState>(actor.World,
+			player => new DotState(actor, player.PlayerActor.Trait<GpsWatcher>(), player.PlayerActor.TraitOrDefault<FrozenActorLayer>()));
 		}
 
-		public bool IsDotVisible(Player toPlayer)
+		bool ShouldRender(DotState state, Player toPlayer)
 		{
-			return dotStates[toPlayer].IsTargetable;
-		}
-
-		bool IsTargetableBy(Player toPlayer, out bool shouldRenderIndicator)
-		{
-			shouldRenderIndicator = false;
-
-			if (cloak.Value != null && cloak.Value.Cloaked)
+			// Hide the indicator if no watchers are available
+			if (!state.Watcher.Granted && !state.Watcher.GrantedAllies)
 				return false;
 
-			if (disguise.Value != null && disguise.Value.Disguised)
+			// Hide the indicator if a frozen actor portrait is visible
+			if (state.FrozenActor != null && state.FrozenActor.HasRenderables)
 				return false;
 
-			if (huf.Value != null && !huf.Value.IsVisible(self, toPlayer)
-				&& toPlayer.Shroud.IsExplored(self.CenterPosition))
-			{
-				var f1 = FrozenActorForPlayer(toPlayer);
-				shouldRenderIndicator = f1 == null || !f1.HasRenderables;
-				return true;
-			}
-
-			if (fuf.Value == null)
-				return false;
+			// Hide indicator if the actor wouldn't otherwise be visible if there wasn't fog
+			foreach (var visibilityModifier in visibilityModifiers)
+				if (!visibilityModifier.IsVisible(actor, toPlayer))
+					return false;
 
-			var f2 = FrozenActorForPlayer(toPlayer);
-			if (f2 == null)
+			// Hide the indicator behind shroud
+			if (!toPlayer.Shroud.IsExplored(actor.CenterPosition))
 				return false;
 
-			shouldRenderIndicator = !f2.HasRenderables;
-
-			return f2.Visible && !f2.Shrouded && toPlayer.Shroud.IsExplored(self.CenterPosition);
-		}
-
-		FrozenActor FrozenActorForPlayer(Player player)
-		{
-			return frozen[player].FromID(self.ActorID);
+			return !visibility.IsVisible(actor, toPlayer) && toPlayer.Shroud.IsExplored(actor.CenterPosition);
 		}
 
 		void IEffect.Tick(World world)
 		{
-			if (self.Disposed)
-				world.AddFrameEndTask(w => w.Remove(this));
-
 			for (var playerIndex = 0; playerIndex < dotStates.Count; playerIndex++)
 			{
 				var state = dotStates[playerIndex];
-				var shouldRender = false;
-				if (self.IsInWorld && !self.IsDead)
-					state.IsTargetable = (state.Gps.Granted || state.Gps.GrantedAllies) && IsTargetableBy(world.Players[playerIndex], out shouldRender);
-
-				state.ShouldRender = state.IsTargetable && shouldRender;
+				state.Visible = ShouldRender(state, world.Players[playerIndex]);
 			}
 		}
 
 		IEnumerable<IRenderable> IEffect.Render(WorldRenderer wr) { return SpriteRenderable.None; }
 
 		IEnumerable<IRenderable> IEffectAboveShroud.RenderAboveShroud(WorldRenderer wr)
 		{
-			if (self.World.RenderPlayer == null || !dotStates[self.World.RenderPlayer].ShouldRender || self.Disposed)
+			if (actor.World.RenderPlayer == null || !dotStates[actor.World.RenderPlayer].Visible)
 				return SpriteRenderable.None;
 
-			var palette = wr.Palette(info.IndicatorPalettePrefix + self.Owner.InternalName);
-			return anim.Render(self.CenterPosition, palette);
+			var effectiveOwner = actor.EffectiveOwner != null && actor.EffectiveOwner.Owner != null ?
+				actor.EffectiveOwner.Owner : actor.Owner;
+
+			var palette = wr.Palette(info.IndicatorPalettePrefix + effectiveOwner.InternalName);
+			return anim.Render(actor.CenterPosition, palette);
 		}
 	}
 }