Make a bit more use of direct extension methods.

tompeeters_macomi · tompeeters_macomi · commit b0ac15e1018e · 2026-02-02T20:31:39.000+01:00
diff --git a/WCSharp.Buffs/Aura.cs b/WCSharp.Buffs/Aura.cs
@@ -163,13 +163,13 @@ public void Action()
 			{
 				SearchIntervalLeft = SearchInterval;
 				var units = GetAuraTargets();
-				for (var i = 0; i < units.Count; i++)
+				for (var i = 1; i <= units.Count; i++)
 				{
-					var unit = units[i];
+					var unit = units.DirectGet(i);
 					var found = false;
-					for (var j = 0; j < this.activeBuffs.Count; j++)
+					for (var j = 1; j <= this.activeBuffs.Count; j++)
 					{
-						var activeBuff = this.activeBuffs[j];
+						var activeBuff = this.activeBuffs.DirectGet(j);
 						if (activeBuff.Unit == unit)
 						{
 							activeBuff.Duration = Duration;
@@ -191,13 +191,16 @@ public void Action()
 				SearchIntervalLeft -= BuffSystem.TickInterval;
 			}
 
-			for (var i = this.activeBuffs.Count - 1; i >= 0; i--)
+			var size = this.activeBuffs.Count;
+			for (var i = 1; i <= size; i++)
 			{
-				var buff = this.activeBuffs[i];
+				var buff = this.activeBuffs.DirectGet(i);
 				if (buff.Duration <= 0)
 				{
 					buff.Buff.Stacks--;
-					this.activeBuffs.RemoveAt(i);
+					this.activeBuffs.DirectNilShift(i, size);
+					size--;
+					i--;
 				}
 				else
 				{
diff --git a/WCSharp.Buffs/BuffSystem.cs b/WCSharp.Buffs/BuffSystem.cs
@@ -79,9 +79,9 @@ private static void OnDeath()
 				}
 			}
 
-			for (var i = 0; i < buffsOnUnit.Count; i++)
+			for (var i = 1; i <= buffsOnUnit.Count; i++)
 			{
-				var buff = buffsOnUnit[i];
+				var buff = buffsOnUnit.DirectGet(i);
 				if (buff.Active)
 				{
 					buff.Active = false;
@@ -101,9 +101,9 @@ public static Buff Add(Buff buff, StackBehaviour stackBehaviour = StackBehaviour
 				if (stackBehaviour != StackBehaviour.None)
 				{
 					var type = buff.GetType();
-					for (var i = 0; i < buffsOnUnit.Count; i++)
+					for (var i = 1; i <= buffsOnUnit.Count; i++)
 					{
-						var currentBuff = buffsOnUnit[i];
+						var currentBuff = buffsOnUnit.DirectGet(i);
 						if (currentBuff.Active && currentBuff.GetType() == type)
 						{
 							if (stackBehaviour == StackBehaviour.Stack ||
@@ -171,19 +171,19 @@ private static void OnUnitTypeChangesOwner()
 			if (GetUnitTypeId(unit) == DummySystem.UNIT_TYPE_DUMMY)
 				return;
 
-			for (var i = 0; i < buffs.Count; i++)
+			for (var i = 1; i <= buffs.Count; i++)
 			{
-				if (buffs[i].Caster == unit)
+				if (buffs.DirectGet(i).Caster == unit)
 				{
-					buffs[i].CastingPlayer = GetOwningPlayer(unit);
+					buffs.DirectGet(i).CastingPlayer = GetOwningPlayer(unit);
 				}
 			}
 
 			var owner = GetOwningPlayer(unit);
 			var list = GetBuffsOnUnit(unit);
-			for (var i = 0; i < list.Count; i++)
+			for (var i = 1; i <= list.Count; i++)
 			{
-				var buff = list[i];
+				var buff = list.DirectGet(i);
 				buff.TargetPlayer = owner;
 			}
 		}
@@ -210,9 +210,9 @@ public static List<Dispel> Dispel(unit target, unit dispeller, bool isBeneficial
 		{
 			var dispels = new List<Dispel>();
 			var list = GetBuffsOnUnit(target);
-			for (var i = 0; i < list.Count; i++)
+			for (var i = 1; i <= list.Count; i++)
 			{
-				var buff = list[i];
+				var buff = list.DirectGet(i);
 				if (buff.IsBeneficial == isBeneficial)
 				{
 					var stacks = buff.Stacks;
@@ -246,9 +246,9 @@ public static List<Dispel> Dispel(unit target, unit dispeller, bool isBeneficial
 		{
 			var dispels = new List<Dispel>();
 			var list = GetBuffsOnUnit(target);
-			for (var i = 0; i < list.Count; i++)
+			for (var i = 1; i <= list.Count; i++)
 			{
-				var buff = list[i];
+				var buff = list.DirectGet(i);
 				if (buff.IsBeneficial == isBeneficial && buff.BuffTypes.Contains(dispelType))
 				{
 					var stacks = buff.Stacks;
@@ -282,9 +282,9 @@ public static List<Dispel> Dispel(unit target, unit dispeller, bool isBeneficial
 		{
 			var dispels = new List<Dispel>();
 			var list = GetBuffsOnUnit(target);
-			for (var i = 0; i < list.Count; i++)
+			for (var i = 1; i <= list.Count; i++)
 			{
-				var buff = list[i];
+				var buff = list.DirectGet(i);
 				if (buff.IsBeneficial == isBeneficial && buff.BuffTypes.Any(x => dispelTypes.Contains(x)))
 				{
 					var stacks = buff.Stacks;
@@ -319,9 +319,9 @@ public static List<Dispel> Dispel(unit target, unit dispeller, bool isBeneficial
 		{
 			var dispels = new List<Dispel>();
 			var list = GetBuffsOnUnit(target);
-			for (var i = 0; i < list.Count; i++)
+			for (var i = 1; i <= list.Count; i++)
 			{
-				var buff = list[i];
+				var buff = list.DirectGet(i);
 				if (buff.IsBeneficial == isBeneficial && buff.BuffTypes.Any(x => dispelTypes.Contains(x)) && !buff.BuffTypes.Any(x => exclusions.Contains(x)))
 				{
 					var stacks = buff.Stacks;
diff --git a/WCSharp.Dummies/DummySystem.cs b/WCSharp.Dummies/DummySystem.cs
@@ -40,18 +40,19 @@ private static void OnDummyCast()
 		private static void Countdown(Timer timer)
 		{
 			var size = dummiesBeingRecycled.Count;
-			for (var i = size - 1; i >= 0; i--)
+			for (var i = size; i > 0; i--)
 			{
-				var dummy = dummiesBeingRecycled[i];
+				var dummy = dummiesBeingRecycled.DirectGet(i);
 				if (dummy.TimeLeft <= 0)
 				{
 					SetUnitX(dummy.Dummy, 0);
 					SetUnitY(dummy.Dummy, 0);
-					dummiesReady.Add(dummy.Dummy);
+					dummiesReady.DirectAdd(dummy.Dummy);
 
+					dummiesBeingRecycled.DirectMove(size, i);
 					size--;
-					dummiesBeingRecycled[i] = dummiesBeingRecycled[size];
 					dummiesBeingRecycled.RemoveAt(size);
+					i++;
 				}
 				else
 				{
@@ -69,7 +70,7 @@ public static void RecycleDummy(unit dummy, float recycleTime = 2.0f)
 			{
 				TimerSystem.Add(timer);
 			}
-			dummiesBeingRecycled.Add(new DummyBeingRecycled(dummy, recycleTime));
+			dummiesBeingRecycled.DirectAdd(new DummyBeingRecycled(dummy, recycleTime));
 		}
 
 		/// <summary>
diff --git a/WCSharp.Events/EventHandlers/EventSet.cs b/WCSharp.Events/EventHandlers/EventSet.cs
@@ -18,7 +18,7 @@ public EventSet()
 
 		public void Add(Action action, object filterObj)
 		{
-			this.actions.Add(action);
+			this.actions.DirectAdd(action);
 		}
 
 		public bool Remove(Action action, object filterObj)
diff --git a/WCSharp.Events/EventHandlers/PlayerUnitEventHandlers/AbstractPlayerUnitEventHandler.cs b/WCSharp.Events/EventHandlers/PlayerUnitEventHandlers/AbstractPlayerUnitEventHandler.cs
@@ -135,7 +135,7 @@ private IEventSet AddEventSet(IEventSet eventSet)
 				EnableTrigger(this.trigger);
 			}
 
-			this.eventSets.Add(eventSet);
+			this.eventSets.DirectAdd(eventSet);
 			return eventSet;
 		}
 
diff --git a/WCSharp.Events/PeriodicDisposableTrigger.cs b/WCSharp.Events/PeriodicDisposableTrigger.cs
@@ -1,5 +1,6 @@
 ﻿using System.Collections.Generic;
 using System.Linq;
+using WCSharp.Shared.Extensions;
 
 namespace WCSharp.Events
 {
@@ -48,26 +49,22 @@ public void Add(T periodicDisposableTrigger)
 		private bool Periodic()
 		{
 			var size = this.actions.Count;
-			var i = 0;
 
-			while (i < size)
+			for (var i = 1; i <= size; i++)
 			{
-				var action = this.actions[i];
+				var action = this.actions.DirectGet(i);
 				if (action.Active)
 				{
 					action.Action();
 				}
 
-				if (action.Active)
-				{
-					i++;
-				}
-				else
+				if (!action.Active)
 				{
+					action.Dispose();
+					this.actions.DirectMove(size, i);
 					size--;
-					this.actions[i] = this.actions[size];
 					this.actions.RemoveAt(size);
-					action.Dispose();
+					i--;
 				}
 			}
 
diff --git a/WCSharp.Events/PeriodicEvents.cs b/WCSharp.Events/PeriodicEvents.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using WCSharp.Api;
+using WCSharp.Shared.Extensions;
 using static WCSharp.Api.Common;
 
 namespace WCSharp.Events
@@ -72,22 +73,20 @@ public static void AddPeriodicEvent(PeriodicEvent timerEvent)
 		private static void Tick()
 		{
 			var size = timerEvents.Count;
-			var i = 0;
-			while (i < size)
+
+			for (var i = 1; i <= size; i++)
 			{
-				// Purposely written stupidly to avoid decompilation into a for loop
-				var timerEvent = timerEvents[i];
-				i++;
+				var timerEvent = timerEvents.DirectGet(i);
 				timerEvent.IntervalLeft -= SYSTEM_INTERVAL;
 				while (timerEvent.IntervalLeft <= 0)
 				{
 					timerEvent.IntervalLeft += timerEvent.Interval;
 					if (!timerEvent.Method.Invoke())
 					{
-						i--;
+						timerEvents.DirectMove(size, i);
 						size--;
-						timerEvents[i] = timerEvents[size];
 						timerEvents.RemoveAt(size);
+						i--;
 						break;
 					}
 				}
diff --git a/WCSharp.Events/PeriodicTrigger.cs b/WCSharp.Events/PeriodicTrigger.cs
@@ -1,5 +1,6 @@
 ﻿using System.Collections.Generic;
 using System.Linq;
+using WCSharp.Shared.Extensions;
 
 namespace WCSharp.Events
 {
@@ -47,25 +48,21 @@ public void Add(T periodicTrigger)
 		private bool Periodic()
 		{
 			var size = this.actions.Count;
-			var i = 0;
 
-			while (i < size)
+			for (var i = 1; i <= size; i++)
 			{
-				var action = this.actions[i];
+				var action = this.actions.DirectGet(i);
 				if (action.Active)
 				{
 					action.Action();
 				}
 
-				if (action.Active)
-				{
-					i++;
-				}
-				else
+				if (!action.Active)
 				{
+					this.actions.DirectMove(size, i);
 					size--;
-					this.actions[i] = this.actions[size];
 					this.actions.RemoveAt(size);
+					i--;
 				}
 			}
 
diff --git a/WCSharp.Events/PlayerUnitEvents.cs b/WCSharp.Events/PlayerUnitEvents.cs
@@ -3,6 +3,7 @@
 using WCSharp.Api;
 using WCSharp.Events.EventHandlers.PlayerUnitEventHandlers;
 using WCSharp.Shared.Data;
+using WCSharp.Shared.Extensions;
 using static WCSharp.Api.Common;
 
 namespace WCSharp.Events
@@ -194,7 +195,7 @@ private static void Register(int @event, Action action)
 			else
 			{
 				AbstractPlayerUnitEventHandler.RequiresUpdate = true;
-				pendingUpdates.Add(() => Register(@event, action));
+				pendingUpdates.DirectAdd(() => Register(@event, action));
 			}
 		}
 
@@ -209,7 +210,7 @@ private static void Register(int @event, Action action, int filterId)
 			else
 			{
 				AbstractPlayerUnitEventHandler.RequiresUpdate = true;
-				pendingUpdates.Add(() => Register(@event, action, filterId));
+				pendingUpdates.DirectAdd(() => Register(@event, action, filterId));
 			}
 		}
 
@@ -224,7 +225,7 @@ private static void Register(int @event, Action action, handle handle)
 			else
 			{
 				AbstractPlayerUnitEventHandler.RequiresUpdate = true;
-				pendingUpdates.Add(() => Register(@event, action, handle));
+				pendingUpdates.DirectAdd(() => Register(@event, action, handle));
 			}
 		}
 
@@ -388,7 +389,7 @@ private static void Unregister(int @event, Action action)
 			else
 			{
 				AbstractPlayerUnitEventHandler.RequiresUpdate = true;
-				pendingUpdates.Add(() => Unregister(@event, action));
+				pendingUpdates.DirectAdd(() => Unregister(@event, action));
 			}
 		}
 
@@ -403,7 +404,7 @@ private static void Unregister(int @event, Action action, int filterId)
 			else
 			{
 				AbstractPlayerUnitEventHandler.RequiresUpdate = true;
-				pendingUpdates.Add(() => Unregister(@event, action, filterId));
+				pendingUpdates.DirectAdd(() => Unregister(@event, action, filterId));
 			}
 		}
 
@@ -418,7 +419,7 @@ private static void Unregister(int @event, Action action, handle handle)
 			else
 			{
 				AbstractPlayerUnitEventHandler.RequiresUpdate = true;
-				pendingUpdates.Add(() => Unregister(@event, action, handle));
+				pendingUpdates.DirectAdd(() => Unregister(@event, action, handle));
 			}
 		}
 
diff --git a/WCSharp.Events/SmoothDisposableTrigger.cs b/WCSharp.Events/SmoothDisposableTrigger.cs
@@ -1,5 +1,6 @@
 ﻿using System.Collections.Generic;
 using System.Linq;
+using WCSharp.Shared.Extensions;
 using static WCSharp.Api.Common;
 
 namespace WCSharp.Events
@@ -73,13 +74,10 @@ public void Add(T smoothDisposableTrigger)
 		private bool Periodic()
 		{
 			var size = this.actions.Count;
-			var i = 0;
 
-			while (i < size)
+			for (var i = 1; i <= size; i++)
 			{
-				var action = this.actions[i];
-				// Purposely written stupidly to avoid decompilation into a for loop
-				i++;
+				var action = this.actions.DirectGet(i);
 				action.TicksLeft--;
 				if (action.TicksLeft <= 0)
 				{
@@ -92,11 +90,10 @@ private bool Periodic()
 					if (!action.Active)
 					{
 						action.Dispose();
-						i--;
-
+						this.actions.DirectMove(size, i);
 						size--;
-						this.actions[i] = this.actions[size];
 						this.actions.RemoveAt(size);
+						i--;
 					}
 				}
 			}
diff --git a/WCSharp.Events/SmoothTrigger.cs b/WCSharp.Events/SmoothTrigger.cs
diff --git a/WCSharp.Missiles/Missile.cs b/WCSharp.Missiles/Missile.cs

Original file line number	Diff line number	Diff line change
`@@ -163,13 +163,13 @@ public void Action()`
`163`	`163`	`{`
`164`	`164`	`SearchIntervalLeft = SearchInterval;`
`165`	`165`	`var units = GetAuraTargets();`
`166`		`- for (var i = 0; i < units.Count; i++)`
	`166`	`+ for (var i = 1; i <= units.Count; i++)`
`167`	`167`	`{`
`168`		`- var unit = units[i];`
	`168`	`+ var unit = units.DirectGet(i);`
`169`	`169`	`var found = false;`
`170`		`- for (var j = 0; j < this.activeBuffs.Count; j++)`
	`170`	`+ for (var j = 1; j <= this.activeBuffs.Count; j++)`
`171`	`171`	`{`
`172`		`- var activeBuff = this.activeBuffs[j];`
	`172`	`+ var activeBuff = this.activeBuffs.DirectGet(j);`
`173`	`173`	`if (activeBuff.Unit == unit)`
`174`	`174`	`{`
`175`	`175`	`activeBuff.Duration = Duration;`
`@@ -191,13 +191,16 @@ public void Action()`
`191`	`191`	`SearchIntervalLeft -= BuffSystem.TickInterval;`
`192`	`192`	`}`
`193`	`193`
`194`		`- for (var i = this.activeBuffs.Count - 1; i >= 0; i--)`
	`194`	`+ var size = this.activeBuffs.Count;`
	`195`	`+ for (var i = 1; i <= size; i++)`
`195`	`196`	`{`
`196`		`- var buff = this.activeBuffs[i];`
	`197`	`+ var buff = this.activeBuffs.DirectGet(i);`
`197`	`198`	`if (buff.Duration <= 0)`
`198`	`199`	`{`
`199`	`200`	`buff.Buff.Stacks--;`
`200`		`- this.activeBuffs.RemoveAt(i);`
	`201`	`+ this.activeBuffs.DirectNilShift(i, size);`
	`202`	`+ size--;`
	`203`	`+ i--;`
`201`	`204`	`}`
`202`	`205`	`else`
`203`	`206`	`{`
Original file line number	Diff line number	Diff line change
`@@ -79,9 +79,9 @@ private static void OnDeath()`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`		`- for (var i = 0; i < buffsOnUnit.Count; i++)`
	`82`	`+ for (var i = 1; i <= buffsOnUnit.Count; i++)`
`83`	`83`	`{`
`84`		`- var buff = buffsOnUnit[i];`
	`84`	`+ var buff = buffsOnUnit.DirectGet(i);`
`85`	`85`	`if (buff.Active)`
`86`	`86`	`{`
`87`	`87`	`buff.Active = false;`
`@@ -101,9 +101,9 @@ public static Buff Add(Buff buff, StackBehaviour stackBehaviour = StackBehaviour`
`101`	`101`	`if (stackBehaviour != StackBehaviour.None)`
`102`	`102`	`{`
`103`	`103`	`var type = buff.GetType();`
`104`		`- for (var i = 0; i < buffsOnUnit.Count; i++)`
	`104`	`+ for (var i = 1; i <= buffsOnUnit.Count; i++)`
`105`	`105`	`{`
`106`		`- var currentBuff = buffsOnUnit[i];`
	`106`	`+ var currentBuff = buffsOnUnit.DirectGet(i);`
`107`	`107`	`if (currentBuff.Active && currentBuff.GetType() == type)`
`108`	`108`	`{`
`109`	`109`	`if (stackBehaviour == StackBehaviour.Stack \|\|`
`@@ -171,19 +171,19 @@ private static void OnUnitTypeChangesOwner()`
`171`	`171`	`if (GetUnitTypeId(unit) == DummySystem.UNIT_TYPE_DUMMY)`
`172`	`172`	`return;`
`173`	`173`
`174`		`- for (var i = 0; i < buffs.Count; i++)`
	`174`	`+ for (var i = 1; i <= buffs.Count; i++)`
`175`	`175`	`{`
`176`		`- if (buffs[i].Caster == unit)`
	`176`	`+ if (buffs.DirectGet(i).Caster == unit)`
`177`	`177`	`{`
`178`		`- buffs[i].CastingPlayer = GetOwningPlayer(unit);`
	`178`	`+ buffs.DirectGet(i).CastingPlayer = GetOwningPlayer(unit);`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`var owner = GetOwningPlayer(unit);`
`183`	`183`	`var list = GetBuffsOnUnit(unit);`
`184`		`- for (var i = 0; i < list.Count; i++)`
	`184`	`+ for (var i = 1; i <= list.Count; i++)`
`185`	`185`	`{`
`186`		`- var buff = list[i];`
	`186`	`+ var buff = list.DirectGet(i);`
`187`	`187`	`buff.TargetPlayer = owner;`
`188`	`188`	`}`
`189`	`189`	`}`
`@@ -210,9 +210,9 @@ public static List<Dispel> Dispel(unit target, unit dispeller, bool isBeneficial`
`210`	`210`	`{`
`211`	`211`	`var dispels = new List<Dispel>();`
`212`	`212`	`var list = GetBuffsOnUnit(target);`
`213`		`- for (var i = 0; i < list.Count; i++)`
	`213`	`+ for (var i = 1; i <= list.Count; i++)`
`214`	`214`	`{`
`215`		`- var buff = list[i];`
	`215`	`+ var buff = list.DirectGet(i);`
`216`	`216`	`if (buff.IsBeneficial == isBeneficial)`
`217`	`217`	`{`
`218`	`218`	`var stacks = buff.Stacks;`
`@@ -246,9 +246,9 @@ public static List<Dispel> Dispel(unit target, unit dispeller, bool isBeneficial`
`246`	`246`	`{`
`247`	`247`	`var dispels = new List<Dispel>();`
`248`	`248`	`var list = GetBuffsOnUnit(target);`
`249`		`- for (var i = 0; i < list.Count; i++)`
	`249`	`+ for (var i = 1; i <= list.Count; i++)`
`250`	`250`	`{`
`251`		`- var buff = list[i];`
	`251`	`+ var buff = list.DirectGet(i);`
`252`	`252`	`if (buff.IsBeneficial == isBeneficial && buff.BuffTypes.Contains(dispelType))`
`253`	`253`	`{`
`254`	`254`	`var stacks = buff.Stacks;`
`@@ -282,9 +282,9 @@ public static List<Dispel> Dispel(unit target, unit dispeller, bool isBeneficial`
`282`	`282`	`{`
`283`	`283`	`var dispels = new List<Dispel>();`
`284`	`284`	`var list = GetBuffsOnUnit(target);`
`285`		`- for (var i = 0; i < list.Count; i++)`
	`285`	`+ for (var i = 1; i <= list.Count; i++)`
`286`	`286`	`{`
`287`		`- var buff = list[i];`
	`287`	`+ var buff = list.DirectGet(i);`
`288`	`288`	`if (buff.IsBeneficial == isBeneficial && buff.BuffTypes.Any(x => dispelTypes.Contains(x)))`
`289`	`289`	`{`
`290`	`290`	`var stacks = buff.Stacks;`
`@@ -319,9 +319,9 @@ public static List<Dispel> Dispel(unit target, unit dispeller, bool isBeneficial`
`319`	`319`	`{`
`320`	`320`	`var dispels = new List<Dispel>();`
`321`	`321`	`var list = GetBuffsOnUnit(target);`
`322`		`- for (var i = 0; i < list.Count; i++)`
	`322`	`+ for (var i = 1; i <= list.Count; i++)`
`323`	`323`	`{`
`324`		`- var buff = list[i];`
	`324`	`+ var buff = list.DirectGet(i);`
`325`	`325`	`if (buff.IsBeneficial == isBeneficial && buff.BuffTypes.Any(x => dispelTypes.Contains(x)) && !buff.BuffTypes.Any(x => exclusions.Contains(x)))`
`326`	`326`	`{`
`327`	`327`	`var stacks = buff.Stacks;`
Original file line number	Diff line number	Diff line change
`@@ -40,18 +40,19 @@ private static void OnDummyCast()`
`40`	`40`	`private static void Countdown(Timer timer)`
`41`	`41`	`{`
`42`	`42`	`var size = dummiesBeingRecycled.Count;`
`43`		`- for (var i = size - 1; i >= 0; i--)`
	`43`	`+ for (var i = size; i > 0; i--)`
`44`	`44`	`{`
`45`		`- var dummy = dummiesBeingRecycled[i];`
	`45`	`+ var dummy = dummiesBeingRecycled.DirectGet(i);`
`46`	`46`	`if (dummy.TimeLeft <= 0)`
`47`	`47`	`{`
`48`	`48`	`SetUnitX(dummy.Dummy, 0);`
`49`	`49`	`SetUnitY(dummy.Dummy, 0);`
`50`		`- dummiesReady.Add(dummy.Dummy);`
	`50`	`+ dummiesReady.DirectAdd(dummy.Dummy);`
`51`	`51`
	`52`	`+ dummiesBeingRecycled.DirectMove(size, i);`
`52`	`53`	`size--;`
`53`		`- dummiesBeingRecycled[i] = dummiesBeingRecycled[size];`
`54`	`54`	`dummiesBeingRecycled.RemoveAt(size);`
	`55`	`+ i++;`
`55`	`56`	`}`
`56`	`57`	`else`
`57`	`58`	`{`
`@@ -69,7 +70,7 @@ public static void RecycleDummy(unit dummy, float recycleTime = 2.0f)`
`69`	`70`	`{`
`70`	`71`	`TimerSystem.Add(timer);`
`71`	`72`	`}`
`72`		`- dummiesBeingRecycled.Add(new DummyBeingRecycled(dummy, recycleTime));`
	`73`	`+ dummiesBeingRecycled.DirectAdd(new DummyBeingRecycled(dummy, recycleTime));`
`73`	`74`	`}`
`74`	`75`
`75`	`76`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public EventSet()`
`18`	`18`
`19`	`19`	`public void Add(Action action, object filterObj)`
`20`	`20`	`{`
`21`		`- this.actions.Add(action);`
	`21`	`+ this.actions.DirectAdd(action);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public bool Remove(Action action, object filterObj)`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ private IEventSet AddEventSet(IEventSet eventSet)`
`135`	`135`	`EnableTrigger(this.trigger);`
`136`	`136`	`}`
`137`	`137`
`138`		`- this.eventSets.Add(eventSet);`
	`138`	`+ this.eventSets.DirectAdd(eventSet);`
`139`	`139`	`return eventSet;`
`140`	`140`	`}`
`141`	`141`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`	`using System.Linq;`
	`3`	`+using WCSharp.Shared.Extensions;`
`3`	`4`
`4`	`5`	`namespace WCSharp.Events`
`5`	`6`	`{`
`@@ -48,26 +49,22 @@ public void Add(T periodicDisposableTrigger)`
`48`	`49`	`private bool Periodic()`
`49`	`50`	`{`
`50`	`51`	`var size = this.actions.Count;`
`51`		`- var i = 0;`
`52`	`52`
`53`		`- while (i < size)`
	`53`	`+ for (var i = 1; i <= size; i++)`
`54`	`54`	`{`
`55`		`- var action = this.actions[i];`
	`55`	`+ var action = this.actions.DirectGet(i);`
`56`	`56`	`if (action.Active)`
`57`	`57`	`{`
`58`	`58`	`action.Action();`
`59`	`59`	`}`
`60`	`60`
`61`		`- if (action.Active)`
`62`		`- {`
`63`		`- i++;`
`64`		`- }`
`65`		`- else`
	`61`	`+ if (!action.Active)`
`66`	`62`	`{`
	`63`	`+ action.Dispose();`
	`64`	`+ this.actions.DirectMove(size, i);`
`67`	`65`	`size--;`
`68`		`- this.actions[i] = this.actions[size];`
`69`	`66`	`this.actions.RemoveAt(size);`
`70`		`- action.Dispose();`
	`67`	`+ i--;`
`71`	`68`	`}`
`72`	`69`	`}`
`73`	`70`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using WCSharp.Api;`
	`4`	`+using WCSharp.Shared.Extensions;`
`4`	`5`	`using static WCSharp.Api.Common;`
`5`	`6`
`6`	`7`	`namespace WCSharp.Events`
`@@ -72,22 +73,20 @@ public static void AddPeriodicEvent(PeriodicEvent timerEvent)`
`72`	`73`	`private static void Tick()`
`73`	`74`	`{`
`74`	`75`	`var size = timerEvents.Count;`
`75`		`- var i = 0;`
`76`		`- while (i < size)`
	`76`	`+`
	`77`	`+ for (var i = 1; i <= size; i++)`
`77`	`78`	`{`
`78`		`- // Purposely written stupidly to avoid decompilation into a for loop`
`79`		`- var timerEvent = timerEvents[i];`
`80`		`- i++;`
	`79`	`+ var timerEvent = timerEvents.DirectGet(i);`
`81`	`80`	`timerEvent.IntervalLeft -= SYSTEM_INTERVAL;`
`82`	`81`	`while (timerEvent.IntervalLeft <= 0)`
`83`	`82`	`{`
`84`	`83`	`timerEvent.IntervalLeft += timerEvent.Interval;`
`85`	`84`	`if (!timerEvent.Method.Invoke())`
`86`	`85`	`{`
`87`		`- i--;`
	`86`	`+ timerEvents.DirectMove(size, i);`
`88`	`87`	`size--;`
`89`		`- timerEvents[i] = timerEvents[size];`
`90`	`88`	`timerEvents.RemoveAt(size);`
	`89`	`+ i--;`
`91`	`90`	`break;`
`92`	`91`	`}`
`93`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using WCSharp.Api;`
`4`	`4`	`using WCSharp.Events.EventHandlers.PlayerUnitEventHandlers;`
`5`	`5`	`using WCSharp.Shared.Data;`
	`6`	`+using WCSharp.Shared.Extensions;`
`6`	`7`	`using static WCSharp.Api.Common;`
`7`	`8`
`8`	`9`	`namespace WCSharp.Events`
`@@ -194,7 +195,7 @@ private static void Register(int @event, Action action)`
`194`	`195`	`else`
`195`	`196`	`{`
`196`	`197`	`AbstractPlayerUnitEventHandler.RequiresUpdate = true;`
`197`		`- pendingUpdates.Add(() => Register(@event, action));`
	`198`	`+ pendingUpdates.DirectAdd(() => Register(@event, action));`
`198`	`199`	`}`
`199`	`200`	`}`
`200`	`201`
`@@ -209,7 +210,7 @@ private static void Register(int @event, Action action, int filterId)`
`209`	`210`	`else`
`210`	`211`	`{`
`211`	`212`	`AbstractPlayerUnitEventHandler.RequiresUpdate = true;`
`212`		`- pendingUpdates.Add(() => Register(@event, action, filterId));`
	`213`	`+ pendingUpdates.DirectAdd(() => Register(@event, action, filterId));`
`213`	`214`	`}`
`214`	`215`	`}`
`215`	`216`
`@@ -224,7 +225,7 @@ private static void Register(int @event, Action action, handle handle)`
`224`	`225`	`else`
`225`	`226`	`{`
`226`	`227`	`AbstractPlayerUnitEventHandler.RequiresUpdate = true;`
`227`		`- pendingUpdates.Add(() => Register(@event, action, handle));`
	`228`	`+ pendingUpdates.DirectAdd(() => Register(@event, action, handle));`
`228`	`229`	`}`
`229`	`230`	`}`
`230`	`231`
`@@ -388,7 +389,7 @@ private static void Unregister(int @event, Action action)`
`388`	`389`	`else`
`389`	`390`	`{`
`390`	`391`	`AbstractPlayerUnitEventHandler.RequiresUpdate = true;`
`391`		`- pendingUpdates.Add(() => Unregister(@event, action));`
	`392`	`+ pendingUpdates.DirectAdd(() => Unregister(@event, action));`
`392`	`393`	`}`
`393`	`394`	`}`
`394`	`395`
`@@ -403,7 +404,7 @@ private static void Unregister(int @event, Action action, int filterId)`
`403`	`404`	`else`
`404`	`405`	`{`
`405`	`406`	`AbstractPlayerUnitEventHandler.RequiresUpdate = true;`
`406`		`- pendingUpdates.Add(() => Unregister(@event, action, filterId));`
	`407`	`+ pendingUpdates.DirectAdd(() => Unregister(@event, action, filterId));`
`407`	`408`	`}`
`408`	`409`	`}`
`409`	`410`
`@@ -418,7 +419,7 @@ private static void Unregister(int @event, Action action, handle handle)`
`418`	`419`	`else`
`419`	`420`	`{`
`420`	`421`	`AbstractPlayerUnitEventHandler.RequiresUpdate = true;`
`421`		`- pendingUpdates.Add(() => Unregister(@event, action, handle));`
	`422`	`+ pendingUpdates.DirectAdd(() => Unregister(@event, action, handle));`
`422`	`423`	`}`
`423`	`424`	`}`
`424`	`425`