From c1a416b2f488c595fcb1b2ebbe3545d1d3b75a61 Mon Sep 17 00:00:00 2001
From: jdj <jdj@cabal>
Date: Tue, 24 Jan 2017 08:43:40 -0600
Subject: [PATCH] Radioactivity code migrated to mod DLL.

---
 .../OpenRA.Mods.yupgi_alert.csproj            |   5 +-
 .../Traits/DamagedByRadioactivity.cs          |  69 ++++++
 .../Traits/DeployToTimedUpgrade.cs            |   2 +-
 .../Traits/ExplodeWeapon.cs                   | 107 +++++++++
 .../Traits/StructureChrono.cs                 |   2 +-
 .../Warheads/CreateRadioactivityWarhead.cs    | 111 ++++++++++
 .../Traits/World/RadioactivityLayer.cs        | 203 ++++++++++++++++++
 7 files changed, 496 insertions(+), 3 deletions(-)
 create mode 100644 OpenRA.Mods.yupgi_alert/Traits/DamagedByRadioactivity.cs
 create mode 100644 OpenRA.Mods.yupgi_alert/Traits/ExplodeWeapon.cs
 create mode 100644 OpenRA.Mods.yupgi_alert/Traits/Warheads/CreateRadioactivityWarhead.cs
 create mode 100644 OpenRA.Mods.yupgi_alert/Traits/World/RadioactivityLayer.cs

diff --git a/OpenRA.Mods.yupgi_alert/OpenRA.Mods.yupgi_alert.csproj b/OpenRA.Mods.yupgi_alert/OpenRA.Mods.yupgi_alert.csproj
index f9b8f86..55afa25 100644
--- a/OpenRA.Mods.yupgi_alert/OpenRA.Mods.yupgi_alert.csproj
+++ b/OpenRA.Mods.yupgi_alert/OpenRA.Mods.yupgi_alert.csproj
@@ -71,11 +71,15 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Traits\DamagedByRadioactivity.cs" />
     <Compile Include="Traits\DeployToTimedUpgrade.cs" />
+    <Compile Include="Traits\ExplodeWeapon.cs" />
     <Compile Include="Traits\StructureChrono.cs" />
     <Compile Include="Traits\SupportPowers\AttackOrderPower.cs" />
+    <Compile Include="Traits\Warheads\CreateRadioactivityWarhead.cs" />
     <Compile Include="Traits\Warheads\FireClusterWarhead.cs" />
     <Compile Include="Traits\Warheads\WarheadAS.cs" />
+    <Compile Include="Traits\World\RadioactivityLayer.cs" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Activities\" />
@@ -86,7 +90,6 @@
     <Folder Include="Traits\Conditions\" />
     <Folder Include="Traits\Render\" />
     <Folder Include="Traits\Widgets\" />
-    <Folder Include="Traits\World\" />
     <Folder Include="UtilityCommands\" />
   </ItemGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/OpenRA.Mods.yupgi_alert/Traits/DamagedByRadioactivity.cs b/OpenRA.Mods.yupgi_alert/Traits/DamagedByRadioactivity.cs
new file mode 100644
index 0000000..e57951f
--- /dev/null
+++ b/OpenRA.Mods.yupgi_alert/Traits/DamagedByRadioactivity.cs
@@ -0,0 +1,69 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2016 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 System.Linq;
+using OpenRA.GameRules;
+using OpenRA.Traits;
+using OpenRA.Mods.Common.Traits;
+
+namespace OpenRA.Mods.yupgi_alert.Traits
+{
+	[Desc("This actor receives damage from the given weapon when in radioactive area.")]
+	class DamagedByRadioactivityInfo : UpgradableTraitInfo, Requires<HealthInfo>
+	{
+		[Desc("Related to amount of damage received per DamageInterval ticks. (Damage = DamageCoeff * RadioactivityLevel")]
+		[FieldLoader.Require] public readonly float DamageCoeff = 0;
+
+		[Desc("Delay between receiving damage.")]
+		public readonly int DamageInterval = 0;
+
+		[Desc("Apply the damage using these damagetypes.")]
+		public readonly HashSet<string> DamageTypes = new HashSet<string>();
+
+		public override object Create(ActorInitializer init) { return new DamagedByRadioactivity(init.Self, this); }
+	}
+
+	class DamagedByRadioactivity : UpgradableTrait<DamagedByRadioactivityInfo>, ITick, ISync
+	{
+		readonly Health health;
+		readonly RadioactivityLayer raLayer;
+
+		[Sync] int damageTicks;
+
+		public DamagedByRadioactivity(Actor self, DamagedByRadioactivityInfo info) : base(info)
+		{
+			health = self.Trait<Health>();
+			raLayer = self.World.WorldActor.Trait<RadioactivityLayer>();
+		}
+
+		public void Tick(Actor self)
+		{
+			if (IsTraitDisabled || --damageTicks > 0)
+				return;
+
+			// Prevents harming cargo.
+			if (!self.IsInWorld)
+				return;
+
+			var level = raLayer.GetLevel(self.Location);
+			if (level <= 0)
+				return;
+
+			float dmg = Info.DamageCoeff * level;
+			if (dmg < 1.0f)
+				dmg = 1.0f; // cos we will be rounding this as int.
+
+			self.InflictDamage(self.World.WorldActor, new Damage((int) dmg, Info.DamageTypes));
+			damageTicks = Info.DamageInterval;
+		}
+	}
+}
diff --git a/OpenRA.Mods.yupgi_alert/Traits/DeployToTimedUpgrade.cs b/OpenRA.Mods.yupgi_alert/Traits/DeployToTimedUpgrade.cs
index 34f5c4d..39188d7 100644
--- a/OpenRA.Mods.yupgi_alert/Traits/DeployToTimedUpgrade.cs
+++ b/OpenRA.Mods.yupgi_alert/Traits/DeployToTimedUpgrade.cs
@@ -25,7 +25,7 @@
 using OpenRA.Mods.Common.Traits.Render;
 using OpenRA.Traits;
 
-namespace OpenRA.Mods.yupgi_alert.Traits
+namespace OpenRA.Mods.AS.Traits
 {
 	public class DeployToTimedUpgradeInfo : ITraitInfo, Requires<UpgradeManagerInfo>
 	{
diff --git a/OpenRA.Mods.yupgi_alert/Traits/ExplodeWeapon.cs b/OpenRA.Mods.yupgi_alert/Traits/ExplodeWeapon.cs
new file mode 100644
index 0000000..5bf2ae1
--- /dev/null
+++ b/OpenRA.Mods.yupgi_alert/Traits/ExplodeWeapon.cs
@@ -0,0 +1,107 @@
+#region Copyright & License Information
+/*
+ * Copyright 2015- OpenRA.Mods.AS Developers (see AUTHORS)
+ * This file is a part of a third-party plugin for 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.Linq;
+using OpenRA.GameRules;
+using OpenRA.Mods.Common;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Traits;
+
+
+// Remark:
+// While I'm modding latest stable version,
+// UpgradableTrait is renamed to ConditionalTrait in bleed version of OpenRA.
+
+namespace OpenRA.Mods.AS.Traits
+{
+	[Desc("Explodes a weapon at the actor's position when enabled."
+		+ "Reload/burstdelays are used as explosion intervals.")]
+	public class ExplodeWeaponInfo : UpgradableTraitInfo, IRulesetLoaded
+	{
+		[WeaponReference, FieldLoader.Require]
+		[Desc("Has to be defined in weapons.yaml as well.")]
+		public readonly string Weapon = null;
+
+		public readonly bool ResetReloadWhenEnabled = true;
+
+		public WeaponInfo WeaponInfo { get; private set; }
+
+		[Desc("Explosion offset relative to actor's position.")]
+		public readonly WVec LocalOffset = WVec.Zero;
+
+		public override object Create(ActorInitializer init) { return new ExplodeWeapon(init.Self, this); }
+
+		void IRulesetLoaded<ActorInfo>.RulesetLoaded(Ruleset rules, ActorInfo info)
+		{
+			WeaponInfo weaponInfo;
+
+			var weaponToLower = Weapon.ToLowerInvariant();
+			if (!rules.Weapons.TryGetValue(weaponToLower, out weaponInfo))
+				throw new YamlException("Weapons Ruleset does not contain an entry '{0}'".F(weaponToLower));
+
+			WeaponInfo = weaponInfo;
+		}
+	}
+
+	class ExplodeWeapon : UpgradableTrait<ExplodeWeaponInfo>, ITick
+	{
+		readonly ExplodeWeaponInfo info;
+		readonly WeaponInfo weapon;
+		readonly BodyOrientation body;
+
+		int fireDelay;
+		int burst;
+
+		public ExplodeWeapon(Actor self, ExplodeWeaponInfo info)
+			: base(info)
+		{
+			this.info = info;
+
+			weapon = info.WeaponInfo;
+			burst = weapon.Burst;
+			body = self.TraitOrDefault<BodyOrientation>();
+		}
+
+		void ITick.Tick(Actor self)
+		{
+			if (IsTraitDisabled)
+				return;
+
+			if (--fireDelay < 0)
+			{
+				var localoffset = body != null
+					? body.LocalToWorld(info.LocalOffset.Rotate(body.QuantizeOrientation(self, self.Orientation)))
+					: info.LocalOffset;
+
+				weapon.Impact(Target.FromPos(self.CenterPosition + localoffset), self,
+					self.TraitsImplementing<IFirepowerModifier>().Select(a => a.GetFirepowerModifier()).ToArray());
+
+				if (--burst > 0)
+					fireDelay = weapon.BurstDelay;
+				else
+				{
+					var modifiers = self.TraitsImplementing<IReloadModifier>()
+						.Select(m => m.GetReloadModifier());
+					fireDelay = Util.ApplyPercentageModifiers(weapon.ReloadDelay, modifiers);
+					burst = weapon.Burst;
+				}
+			}
+		}
+
+		protected override void UpgradeEnabled(Actor self)
+		{
+			if (info.ResetReloadWhenEnabled)
+			{
+				burst = weapon.Burst;
+				fireDelay = 0;
+			}
+		}
+	}
+}
diff --git a/OpenRA.Mods.yupgi_alert/Traits/StructureChrono.cs b/OpenRA.Mods.yupgi_alert/Traits/StructureChrono.cs
index 83a5b0b..cf67e39 100644
--- a/OpenRA.Mods.yupgi_alert/Traits/StructureChrono.cs
+++ b/OpenRA.Mods.yupgi_alert/Traits/StructureChrono.cs
@@ -21,7 +21,7 @@
 using OpenRA.Primitives;
 using OpenRA.Mods.Common;
 
-namespace OpenRA.Mods.RA.Traits
+namespace OpenRA.Mods.yupgi_alert.Traits
 {
 	class StructureChronoInfo : ITraitInfo
 	{
diff --git a/OpenRA.Mods.yupgi_alert/Traits/Warheads/CreateRadioactivityWarhead.cs b/OpenRA.Mods.yupgi_alert/Traits/Warheads/CreateRadioactivityWarhead.cs
new file mode 100644
index 0000000..5a3520e
--- /dev/null
+++ b/OpenRA.Mods.yupgi_alert/Traits/Warheads/CreateRadioactivityWarhead.cs
@@ -0,0 +1,111 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2016 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.GameRules;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Traits;
+using OpenRA.Mods.Common.Warheads;
+using OpenRA.Mods.yupgi_alert.Traits;
+
+namespace OpenRA.Mods.yupgi_alert.Warheads
+{
+	public class CreateRadioactivityWarhead : DamageWarhead, IRulesetLoaded<WeaponInfo>
+	{
+		[Desc("Range between falloff steps, in cells")]
+		public readonly int Spread = 1;
+
+		[Desc("Radioactivity level percentage at each range step")]
+		public readonly int[] Falloff = { 100, 37, 14, 5, 0 };
+
+		// Since radioactivity level is accumulative, we pre-compute this var from Falloff. (Lookup table)
+		private int[] FalloffDifference;
+
+		[Desc("Ranges at which each Falloff step is defined (in cells). Overrides Spread.")]
+		public int[] Range = null;
+
+		[Desc("Radio activity level per shot (Sievert?)")]
+		public int Level = 32;
+
+		[Desc("Radio activity saturates at this level, by this weapon.")]
+		// this means if the cell is affected by other stronger radioactive weapon, the level can go past this value.
+		// For details, have a look at RadioactivityLayers.cs:IncreaseLevel()
+		public int MaxLevel = 128;
+
+		[Desc("Half-life of the RA level, from this weapon, in ticks.")]
+		public int HalfLife = 15;
+
+		public void RulesetLoaded(Ruleset rules, WeaponInfo info)
+		{
+			if (Range != null)
+			{
+				if (Range.Length != 1 && Range.Length != Falloff.Length)
+					throw new YamlException("Number of range values must be 1 or equal to the number of Falloff values.");
+
+				for (var i = 0; i < Range.Length - 1; i++)
+					if (Range[i] > Range[i + 1])
+						throw new YamlException("Range values must be specified in an increasing order.");
+			}
+			else
+				Range = Exts.MakeArray(Falloff.Length, i => i * Spread);
+
+			// Compute FalloffDifference LUT.
+			FalloffDifference = new int[Falloff.Length];
+			for(var i = 0; i < FalloffDifference.Length-1; i++)
+			{
+				// with Falloff = { 100, 37, 14, 5, 0 }, you get
+				// { 63, 23, 9, 5, 0 }
+				FalloffDifference[i] = Falloff[i] - Falloff[i + 1];
+			}
+			FalloffDifference[FalloffDifference.Length - 1] = 0;
+		}
+
+		public override void DoImpact(WPos pos, Actor firedBy, IEnumerable<int> damageModifiers)
+		{
+			var world = firedBy.World;
+			var resLayer = world.WorldActor.Trait<RadioactivityLayer>();
+
+			if (world.LocalPlayer != null)
+			{
+				var devMode = world.LocalPlayer.PlayerActor.TraitOrDefault<DeveloperMode>();
+				if (devMode != null && devMode.ShowCombatGeometry)
+				{
+					WDist[] rng = Exts.MakeArray(Range.Length, i => WDist.FromCells(Range[i]));
+					world.WorldActor.Trait<WarheadDebugOverlay>().AddImpact(pos, rng, DebugOverlayColor);
+				}
+			}
+
+			// Accumulate radiation
+			var targetTile = world.Map.CellContaining(pos);
+			for (var i = Range.Length-1; i >=0; i--)
+			{
+				// Find affected cells, from outer Range down to inner range.
+				var affectedCells = world.Map.FindTilesInAnnulus(targetTile, 0, Range[i]);
+
+				var ra_layer = world.WorldActor.Trait<RadioactivityLayer>();
+
+				foreach (var cell in affectedCells)
+				{
+					var foff = FalloffDifference[i];
+					IncreaseRALevel(cell, foff, ra_layer);
+				}
+			}
+		}
+
+		// Increase radiation level of the cell at given pos, considering falloff
+		void IncreaseRALevel(CPos pos, int foff, RadioactivityLayer ra_layer)
+		{
+			// increase RA level of the cell by this amount.
+			int level = this.Level * foff / 100;
+			ra_layer.IncreaseLevel(pos, level, HalfLife, MaxLevel);
+		}
+	}
+}
diff --git a/OpenRA.Mods.yupgi_alert/Traits/World/RadioactivityLayer.cs b/OpenRA.Mods.yupgi_alert/Traits/World/RadioactivityLayer.cs
new file mode 100644
index 0000000..b6d6a10
--- /dev/null
+++ b/OpenRA.Mods.yupgi_alert/Traits/World/RadioactivityLayer.cs
@@ -0,0 +1,203 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2016 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;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using OpenRA.Graphics;
+using System.Drawing;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.yupgi_alert.Traits
+{
+	[Desc("Attach this to the world actor. Radioactivity layer, as in RA2 desolator radioactivity.", "Order of the layers defines the Z sorting.")]
+	// You can attach this layer by editing rules/world.yaml
+	// I (boolbada) made this layer by cloning resources layer, as resource amount is quite similar to
+	// radio activity. I looked at SmudgeLayer too.
+
+	public class RadioactivityLayerInfo : ITraitInfo
+	{
+		[Desc("Color of radio activity")]
+		public readonly Color Color = Color.Green;
+
+		[Desc("Delay of half life, in ticks")]
+		public readonly int Halflife = 0; // in ticks. However, half life is defined by each weapon...
+
+		// Damage dealing is handled by "DamagedByRadioactivity" trait attached at each actor.
+
+		public object Create(ActorInitializer init) { return new RadioactivityLayer(init.Self, this); }
+	}
+
+	class Radioactivity
+	{
+		public int ticks = 0;
+		public int level = 0;
+		public int halflife = 0;
+
+		public Radioactivity Clone()
+		{
+			Radioactivity result = new Radioactivity();
+			result.ticks = ticks;
+			result.level = level;
+			result.halflife = halflife;
+			return result;
+		}
+	}
+
+	public class RadioactivityLayer : IRenderOverlay, IWorldLoaded, ITickRender, INotifyActorDisposing, ITick
+	{
+		readonly World world;
+		readonly RadioactivityLayerInfo info;
+
+		// In the following, I think dictionary is better than array, as radioactivity has similar affecting area as smudges.
+
+		// true radioactivity values, without considering fog of war.
+		readonly Dictionary<CPos, Radioactivity> tiles = new Dictionary<CPos, Radioactivity>();
+
+		// what's visible to the player.
+		readonly Dictionary<CPos, Radioactivity> rendered_tiles = new Dictionary<CPos, Radioactivity>();
+
+		readonly HashSet<CPos> dirty = new HashSet<CPos>(); // dirty, as in cache dirty bits.
+
+		public RadioactivityLayer(Actor self, RadioactivityLayerInfo info)
+		{
+			world = self.World;
+			this.info = info;
+		}
+
+		public void Render(WorldRenderer wr)
+		{
+			//foreach (var kv in spriteLayers.Values)
+			//kv.Draw(wr.Viewport);
+			foreach (var tile in rendered_tiles)
+			{
+				var ra = tile.Value;
+				var center = wr.World.Map.CenterOfCell(tile.Key);
+				float alpha = ra.level > 255 ? 255 : ra.level;
+				alpha *= 64.0f/255.0f; // you don't want radio activity indication to be too opaque. Scale to range of [0, 64].
+				var tl = wr.Screen3DPosition(center - new WVec(512, 512, 0)); // cos 512 is half a cell.
+				var br = wr.Screen3DPosition(center + new WVec(512, 512, 0));
+				Game.Renderer.WorldRgbaColorRenderer.FillRect(tl, br, Color.FromArgb((int)alpha, info.Color));
+			}
+		}
+
+		public void Tick(Actor self)
+		{
+			var remove = new List<CPos>();
+
+			// Apply half life to each cell.
+			foreach (var kv in tiles)
+			{
+				var ra = kv.Value;
+				ra.ticks--; // count half-life.
+				if (ra.ticks > 0)
+					continue;
+
+				// on each half life...
+				ra.ticks = ra.halflife; // reset ticks
+				ra.level /= 2; // half the radiation level
+
+				if (ra.level <= 0)
+				{
+					// Not radioactive anymore. Remove from this.tiles.
+					remove.Add(kv.Key);
+				}
+
+				dirty.Add(kv.Key);
+			}
+
+			// Lets actually remove the entry.
+			foreach (var r in remove)
+				tiles.Remove(r);
+		}
+
+		public void WorldLoaded(World w, WorldRenderer wr)
+		{
+			// hmm dunno what to do, at the moment.
+		}
+
+		// tick render, regardless of pause state.
+		public void TickRender(WorldRenderer wr, Actor self)
+		{
+			var remove = new List<CPos>();
+			foreach (var c in dirty)
+			{
+				if (!self.World.FogObscures(c))
+				{
+					// synchronize observations with true value.
+					if (tiles.ContainsKey(c))
+						rendered_tiles[c] = tiles[c].Clone();
+					else
+						rendered_tiles.Remove(c);
+					remove.Add(c);
+				}
+			}
+
+			foreach (var r in remove)
+				dirty.Remove(r);
+		}
+
+		public int GetLevel(CPos cell)
+		{
+			if (tiles.ContainsKey(cell))
+				return tiles[cell].level;
+			return 0;
+		}
+
+		public void IncreaseLevel(CPos cell, int level, int halflife, int max_level)
+		{
+			// Initialize, on fresh impact.
+			if (!tiles.ContainsKey(cell))
+				tiles[cell] = new Radioactivity();
+
+			var ra = tiles[cell];
+			var new_level = level + ra.level;
+
+			if (new_level > max_level)
+				new_level = max_level;
+
+			if (ra.level > new_level)
+				return; // the given weapon can't make the cell more radio active. (saturate)
+
+			// apply new level.
+			ra.level = new_level;
+
+			// Current half life model is inaccurate. To compute exactly, we need to remember all the effects that has happened.
+			// I'm not doing that and it will be performance intensive, even if I implemented it.
+			if (ra.halflife < halflife)
+				ra.halflife = halflife;
+			ra.ticks = ra.halflife;
+
+			dirty.Add(cell);
+		}
+
+		public void Destroy(CPos cell)
+		{
+			// Clear cell
+			//Content[cell] = EmptyCell;
+			//world.Map.CustomTerrain[cell] = byte.MaxValue;
+
+			//dirty[cell] = 100;
+		}
+		
+		bool disposed = false;
+		public void Disposing(Actor self)
+		{
+			if (disposed)
+				return;
+
+			// dispose all stuff
+
+			disposed = true;
+		}
+	}
+}