Merge pull request #6029 from pchote/gametomods

Move *Renderables and Render* out of Game.

OpenRA.Mods.RA/Render/RenderNameTag.cs

@@ -11,6 +11,7 @@
 using System.Collections.Generic;
 using System.Drawing;
 using OpenRA.Graphics;
+using OpenRA.Mods.RA.Graphics;
 using OpenRA.Traits;
 
 namespace OpenRA.Mods.RA.Render

OpenRA.Mods.RA/Render/RenderSimple.cs

@@ -0,0 +1,66 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2014 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 System.Collections.Generic;
+using OpenRA.Graphics;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.RA.Render
+{
+	public class RenderSimpleInfo : RenderSpritesInfo, ILegacyEditorRenderInfo, Requires<IBodyOrientationInfo>
+	{
+		public override object Create(ActorInitializer init) { return new RenderSimple(init.self); }
+
+		public virtual IEnumerable<IRenderable> RenderPreview(World world, ActorInfo ai, PaletteReference pr)
+		{
+			var anim = new Animation(world, RenderSimple.GetImage(ai), () => 0);
+			anim.PlayRepeating("idle");
+
+			return anim.Render(WPos.Zero, WVec.Zero, 0, pr, Scale);
+		}
+
+		public string EditorPalette { get { return Palette; } }
+		public string EditorImage(ActorInfo actor) { return RenderSimple.GetImage(actor); }
+	}
+
+	public class RenderSimple : RenderSprites, IAutoSelectionSize
+	{
+		public readonly Animation DefaultAnimation;
+
+		public RenderSimple(Actor self, Func<int> baseFacing)
+			: base(self)
+		{
+			DefaultAnimation = new Animation(self.World, GetImage(self), baseFacing);
+			Add("", DefaultAnimation);
+		}
+
+		public RenderSimple(Actor self)
+			: this(self, MakeFacingFunc(self))
+		{
+			DefaultAnimation.PlayRepeating(NormalizeSequence(self, "idle"));
+			self.Trait<IBodyOrientation>().SetAutodetectedFacings(DefaultAnimation.CurrentSequence.Facings);
+		}
+
+		public int2 SelectionSize(Actor self) { return AutoSelectionSize(self); }
+
+		public string NormalizeSequence(Actor self, string sequence)
+		{
+			return NormalizeSequence(DefaultAnimation, self.GetDamageState(), sequence);
+		}
+
+		public void PlayCustomAnim(Actor self, string name)
+		{
+			if (DefaultAnimation.HasSequence(name))
+				DefaultAnimation.PlayThen(NormalizeSequence(self, name),
+					() => DefaultAnimation.PlayRepeating(NormalizeSequence(self, "idle")));
+		}
+	}
+}

OpenRA.Mods.RA/Render/RenderSprites.cs

@@ -0,0 +1,189 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2011 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 System.Collections.Generic;
+using System.Linq;
+using OpenRA.Graphics;
+using OpenRA.Traits;
+using OpenRA.Primitives;
+
+namespace OpenRA.Mods.RA.Render
+{
+	public class RenderSpritesInfo : ITraitInfo
+	{
+		[Desc("Defaults to the actor name.")]
+		public readonly string Image = null;
+
+		[Desc("Custom palette name")]
+		public readonly string Palette = null;
+		[Desc("Custom PlayerColorPalette: BaseName")]
+		public readonly string PlayerPalette = "player";
+		[Desc("Change the sprite image size.")]
+		public readonly float Scale = 1f;
+
+		public virtual object Create(ActorInitializer init) { return new RenderSprites(init.self); }
+	}
+
+	public class RenderSprites : IRender, ITick, INotifyOwnerChanged, INotifyEffectiveOwnerChanged
+	{
+		class AnimationWrapper
+		{
+			public readonly AnimationWithOffset Animation;
+			public readonly string Palette;
+			public readonly bool IsPlayerPalette;
+			public PaletteReference PaletteReference { get; private set; }
+
+			public AnimationWrapper(AnimationWithOffset animation, string palette, bool isPlayerPalette)
+			{
+				Animation = animation;
+				Palette = palette;
+				IsPlayerPalette = isPlayerPalette;
+			}
+
+			public void CachePalette(WorldRenderer wr, Player owner)
+			{
+				PaletteReference = wr.Palette(IsPlayerPalette ? Palette + owner.InternalName : Palette);
+			}
+
+			public void OwnerChanged()
+			{
+				// Update the palette reference next time we draw
+				if (IsPlayerPalette)
+					PaletteReference = null;
+			}
+
+			public bool IsVisible
+			{
+				get
+				{
+					return Animation.DisableFunc == null || !Animation.DisableFunc();
+				}
+			}
+		}
+
+		Dictionary<string, AnimationWrapper> anims = new Dictionary<string, AnimationWrapper>();
+
+		public static Func<int> MakeFacingFunc(Actor self)
+		{
+			var facing = self.TraitOrDefault<IFacing>();
+			if (facing == null) return () => 0;
+			return () => facing.Facing;
+		}
+
+		readonly RenderSpritesInfo info;
+		string cachedImage = null;
+
+		public RenderSprites(Actor self)
+		{
+			info = self.Info.Traits.Get<RenderSpritesInfo>();
+		}
+
+		public static string GetImage(ActorInfo actor)
+		{
+			var Info = actor.Traits.Get<RenderSpritesInfo>();
+			return Info.Image ?? actor.Name;
+		}
+
+		public string GetImage(Actor self)
+		{
+			if (cachedImage != null)
+				return cachedImage;
+
+			return cachedImage = GetImage(self.Info);
+		}
+
+		protected void UpdatePalette()
+		{
+			foreach (var anim in anims.Values)
+				anim.OwnerChanged();
+		}
+
+		public void OnOwnerChanged(Actor self, Player oldOwner, Player newOwner) { UpdatePalette(); }
+		public void OnEffectiveOwnerChanged(Actor self, Player oldEffectiveOwner, Player newEffectiveOwner) { UpdatePalette(); }
+
+		public virtual IEnumerable<IRenderable> Render(Actor self, WorldRenderer wr)
+		{
+			foreach (var a in anims.Values)
+			{
+				if (!a.IsVisible)
+					continue;
+
+				if (a.PaletteReference == null)
+				{
+					var owner = self.EffectiveOwner != null && self.EffectiveOwner.Disguised ? self.EffectiveOwner.Owner : self.Owner;
+					a.CachePalette(wr, owner);
+				}
+
+				foreach (var r in a.Animation.Render(self, wr, a.PaletteReference, info.Scale))
+					yield return r;
+			}
+		}
+
+		public virtual void Tick(Actor self)
+		{
+			foreach (var a in anims.Values)
+				a.Animation.Animation.Tick();
+		}
+
+		public void Add(string key, AnimationWithOffset anim, string palette = null, bool isPlayerPalette = false)
+		{
+			// Use defaults
+			if (palette == null)
+			{
+				palette = info.Palette ?? info.PlayerPalette;
+				isPlayerPalette = info.Palette == null;
+			}
+
+			anims.Add(key, new AnimationWrapper(anim, palette, isPlayerPalette));
+		}
+
+		public void Remove(string key)
+		{
+			anims.Remove(key);
+		}
+
+		public static string NormalizeSequence(Animation anim, DamageState state, string sequence)
+		{
+			var states = new Pair<DamageState, string>[]
+			{
+				Pair.New(DamageState.Critical, "critical-"),
+				Pair.New(DamageState.Heavy, "damaged-"),
+				Pair.New(DamageState.Medium, "scratched-"),
+				Pair.New(DamageState.Light, "scuffed-")
+			};
+
+			// Remove existing damage prefix
+			foreach (var s in states)
+			{
+				if (sequence.StartsWith(s.Second))
+				{
+					sequence = sequence.Substring(s.Second.Length);
+					break;
+				}
+			}
+
+			foreach (var s in states)
+				if (state >= s.First && anim.HasSequence(s.Second + sequence))
+					return s.Second + sequence;
+
+			return sequence;
+		}
+
+		// Required by RenderSimple
+		protected int2 AutoSelectionSize(Actor self)
+		{
+			return anims.Values.Where(b => b.IsVisible
+				&& b.Animation.Animation.CurrentSequence != null)
+					.Select(a => (a.Animation.Animation.Image.size*info.Scale).ToInt2())
+					.FirstOrDefault();
+		}
+	}
+}

OpenRA.Mods.RA/Render/RenderVoxels.cs

@@ -11,6 +11,7 @@
 using System.Collections.Generic;
 using OpenRA.Graphics;
 using OpenRA.Traits;
+using OpenRA.Mods.RA.Graphics;
 
 namespace OpenRA.Mods.RA.Render
 {