feat(battle-engine): full Unity/VFX/god-object shims + expanded copy closure (2570 files)

Authored Unity primitive/object-model shim, VFX layer (control-flow-preserving, InstantVfx never invokes its action -- headless suppression), god-object stubs (GameMgr/EffectMgr/UIManager with faithfully-extracted nested enums), View/UI/Touch tree, LitJson+BetterList+Tuple copied, third-party stubs. Discovered Roslyn header-error masking: fixing class-header type errors unmasks body references, so the true copy closure is ~2570 files (was 782 under masking). Errors: masked-25720 -> 268; our shim files compile clean. Remaining: ~50 residual shim/external types, 24 NGUI UI-base overrides, static-type fixes, plus likely 1-2 more unmask waves.

SVSim.BattleEngine/Engine/BetterList.cs

@@ -0,0 +1,229 @@
+using System.Collections.Generic;
+using System.Diagnostics;
+using UnityEngine;
+
+public class BetterList<T>
+{
+	public delegate int CompareFunc(T left, T right);
+
+	public T[] buffer;
+
+	public int size;
+
+	[DebuggerHidden]
+	public T this[int i]
+	{
+		get
+		{
+			return buffer[i];
+		}
+		set
+		{
+			buffer[i] = value;
+		}
+	}
+
+	[DebuggerHidden]
+	[DebuggerStepThrough]
+	public IEnumerator<T> GetEnumerator()
+	{
+		if (buffer != null)
+		{
+			int i = 0;
+			while (i < size)
+			{
+				yield return buffer[i];
+				int num = i + 1;
+				i = num;
+			}
+		}
+	}
+
+	private void AllocateMore()
+	{
+		T[] array = ((buffer != null) ? new T[Mathf.Max(buffer.Length << 1, 32)] : new T[32]);
+		if (buffer != null && size > 0)
+		{
+			buffer.CopyTo(array, 0);
+		}
+		buffer = array;
+	}
+
+	private void Trim()
+	{
+		if (size > 0)
+		{
+			if (size < buffer.Length)
+			{
+				T[] array = new T[size];
+				for (int i = 0; i < size; i++)
+				{
+					array[i] = buffer[i];
+				}
+				buffer = array;
+			}
+		}
+		else
+		{
+			buffer = null;
+		}
+	}
+
+	public void Clear()
+	{
+		size = 0;
+	}
+
+	public void Release()
+	{
+		size = 0;
+		buffer = null;
+	}
+
+	public void Add(T item)
+	{
+		if (buffer == null || size == buffer.Length)
+		{
+			AllocateMore();
+		}
+		buffer[size++] = item;
+	}
+
+	public void Insert(int index, T item)
+	{
+		if (buffer == null || size == buffer.Length)
+		{
+			AllocateMore();
+		}
+		if (index > -1 && index < size)
+		{
+			for (int num = size; num > index; num--)
+			{
+				buffer[num] = buffer[num - 1];
+			}
+			buffer[index] = item;
+			size++;
+		}
+		else
+		{
+			Add(item);
+		}
+	}
+
+	public bool Contains(T item)
+	{
+		if (buffer == null)
+		{
+			return false;
+		}
+		for (int i = 0; i < size; i++)
+		{
+			ref readonly T reference = ref buffer[i];
+			object obj = item;
+			if (reference.Equals(obj))
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public int IndexOf(T item)
+	{
+		if (buffer == null)
+		{
+			return -1;
+		}
+		for (int i = 0; i < size; i++)
+		{
+			ref readonly T reference = ref buffer[i];
+			object obj = item;
+			if (reference.Equals(obj))
+			{
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	public bool Remove(T item)
+	{
+		if (buffer != null)
+		{
+			EqualityComparer<T> equalityComparer = EqualityComparer<T>.Default;
+			for (int i = 0; i < size; i++)
+			{
+				if (equalityComparer.Equals(buffer[i], item))
+				{
+					size--;
+					buffer[i] = default(T);
+					for (int j = i; j < size; j++)
+					{
+						buffer[j] = buffer[j + 1];
+					}
+					buffer[size] = default(T);
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	public void RemoveAt(int index)
+	{
+		if (buffer != null && index > -1 && index < size)
+		{
+			size--;
+			buffer[index] = default(T);
+			for (int i = index; i < size; i++)
+			{
+				buffer[i] = buffer[i + 1];
+			}
+			buffer[size] = default(T);
+		}
+	}
+
+	public T Pop()
+	{
+		if (buffer != null && size != 0)
+		{
+			T result = buffer[--size];
+			buffer[size] = default(T);
+			return result;
+		}
+		return default(T);
+	}
+
+	public T[] ToArray()
+	{
+		Trim();
+		return buffer;
+	}
+
+	[DebuggerHidden]
+	[DebuggerStepThrough]
+	public void Sort(CompareFunc comparer)
+	{
+		int num = 0;
+		int num2 = size - 1;
+		bool flag = true;
+		while (flag)
+		{
+			flag = false;
+			for (int i = num; i < num2; i++)
+			{
+				if (comparer(buffer[i], buffer[i + 1]) > 0)
+				{
+					T val = buffer[i];
+					buffer[i] = buffer[i + 1];
+					buffer[i + 1] = val;
+					flag = true;
+				}
+				else if (!flag)
+				{
+					num = ((i != 0) ? (i - 1) : 0);
+				}
+			}
+		}
+	}
+}