1 files changed, 284 insertions, 0 deletions
diff --git a/Thronefall_v1.0/Decompile/ScreenMarkerManager.cs b/Thronefall_v1.0/Decompile/ScreenMarkerManager.cs
new file mode 100644
index 0000000..155aae9
--- /dev/null
+++ b/Thronefall_v1.0/Decompile/ScreenMarkerManager.cs
@@ -0,0 +1,284 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ScreenMarkerManager : MonoBehaviour
+{
+	public enum MarkerMode
+	{
+		Direction,
+		ClampedPos
+	}
+
+	private class ComparePositionX : IComparer<ScreenMarker>
+	{
+		public int Compare(ScreenMarker a, ScreenMarker b)
+		{
+			if (!object.Equals(a.UnclampedScreenPos.x, b.UnclampedScreenPos.x))
+			{
+				return Comparer<float>.Default.Compare(a.UnclampedScreenPos.x, b.UnclampedScreenPos.x);
+			}
+			return Comparer<float>.Default.Compare(a.MyRandomVal - (float)a.Number, b.MyRandomVal - (float)b.Number);
+		}
+	}
+
+	private class ComparePositionY : IComparer<ScreenMarker>
+	{
+		public int Compare(ScreenMarker a, ScreenMarker b)
+		{
+			if (!object.Equals(a.UnclampedScreenPos.y, b.UnclampedScreenPos.y))
+			{
+				return Comparer<float>.Default.Compare(a.UnclampedScreenPos.y, b.UnclampedScreenPos.y);
+			}
+			return Comparer<float>.Default.Compare(a.MyRandomVal - (float)a.Number, b.MyRandomVal - (float)b.Number);
+		}
+	}
+
+	public static ScreenMarkerManager instance;
+
+	private List<ScreenMarker> screenMarkersActive = new List<ScreenMarker>();
+
+	private List<ScreenMarker> screenMarkersToShow = new List<ScreenMarker>();
+
+	private Dictionary<ScreenMarker, int> screenMarkerInGroup = new Dictionary<ScreenMarker, int>();
+
+	private List<List<ScreenMarker>> screenMarkerGroups = new List<List<ScreenMarker>>();
+
+	private Camera cam;
+
+	private float ratio;
+
+	private float clampY;
+
+	private float clampX;
+
+	private int frame;
+
+	[SerializeField]
+	private MarkerMode markerMode;
+
+	private float FIXED_CANVAS_HEIGHT => ScreenMarkerCanvasHelper.instance.Height;
+
+	private void Awake()
+	{
+		instance = this;
+	}
+
+	private void Start()
+	{
+		cam = Camera.main;
+		UpdateCam();
+	}
+
+	private void UpdateCam()
+	{
+		ratio = cam.pixelRect.width / cam.pixelRect.height;
+		clampY = FIXED_CANVAS_HEIGHT / 2f;
+		clampX = FIXED_CANVAS_HEIGHT / 2f * ratio;
+	}
+
+	public void RegisterScreenMarker(ScreenMarker _sm)
+	{
+		if (!screenMarkersActive.Contains(_sm))
+		{
+			screenMarkersActive.Add(_sm);
+		}
+	}
+
+	public void UnregisterScreenMarker(ScreenMarker _sm)
+	{
+		if (screenMarkersActive.Contains(_sm))
+		{
+			screenMarkersActive.Remove(_sm);
+		}
+	}
+
+	private void Update()
+	{
+		frame++;
+		if (frame < 2)
+		{
+			return;
+		}
+		UpdateCam();
+		screenMarkersToShow.Clear();
+		for (int num = screenMarkersActive.Count - 1; num >= 0; num--)
+		{
+			UpdateMarkerPosition(screenMarkersActive[num]);
+		}
+		for (int i = 0; i < screenMarkerGroups.Count; i++)
+		{
+			screenMarkerGroups[i].Clear();
+		}
+		screenMarkerInGroup.Clear();
+		while (screenMarkerGroups.Count < screenMarkersToShow.Count)
+		{
+			screenMarkerGroups.Add(new List<ScreenMarker>());
+		}
+		for (int j = 0; j < screenMarkersToShow.Count; j++)
+		{
+			screenMarkerGroups[j].Add(screenMarkersToShow[j]);
+			screenMarkerInGroup.Add(screenMarkersToShow[j], j);
+		}
+		bool flag = true;
+		int num2 = 30;
+		while (flag && num2 > 0)
+		{
+			num2--;
+			bool flag2 = false;
+			for (int k = 0; k < screenMarkersToShow.Count; k++)
+			{
+				ScreenMarker screenMarker = screenMarkersToShow[k];
+				for (int l = k + 1; l < screenMarkersToShow.Count; l++)
+				{
+					ScreenMarker screenMarker2 = screenMarkersToShow[l];
+					if (!CheckOverlap(screenMarker, screenMarker2))
+					{
+						continue;
+					}
+					int num3 = screenMarkerInGroup[screenMarker];
+					int num4 = screenMarkerInGroup[screenMarker2];
+					if (num3 != num4)
+					{
+						flag2 = true;
+						for (int m = 0; m < screenMarkerGroups[num4].Count; m++)
+						{
+							ScreenMarker screenMarker3 = screenMarkerGroups[num4][m];
+							screenMarkerGroups[num4].Remove(screenMarker3);
+							screenMarkerGroups[num3].Add(screenMarker3);
+							screenMarkerInGroup[screenMarker3] = num3;
+						}
+					}
+				}
+			}
+			flag = flag2;
+			if (flag2)
+			{
+				for (int n = 0; n < screenMarkerGroups.Count; n++)
+				{
+					FormatGroup(screenMarkerGroups[n]);
+				}
+			}
+		}
+		for (int num5 = 0; num5 < screenMarkersToShow.Count; num5++)
+		{
+			ScreenMarker screenMarker4 = screenMarkersToShow[num5];
+			if (screenMarker4.rotateTowardsTargetWhenOffscreen)
+			{
+				if (screenMarker4.OnScreen)
+				{
+					screenMarker4.ImageRotation = 0f;
+				}
+				else
+				{
+					screenMarker4.ImageRotation = Vector2.SignedAngle(Vector2.down, screenMarker4.UnclampedScreenPos - screenMarker4.Position);
+				}
+			}
+		}
+	}
+
+	private bool CheckOverlap(ScreenMarker _sm1, ScreenMarker _sm2)
+	{
+		if (_sm1.Rect != _sm2.Rect)
+		{
+			return false;
+		}
+		if (_sm1.UnclampedScreenPos == _sm2.UnclampedScreenPos)
+		{
+			return true;
+		}
+		Rect rect = _sm1.Rect;
+		Rect rect2 = _sm2.Rect;
+		if (Mathf.Abs(_sm1.Position.x - _sm2.Position.x) > Mathf.Abs(rect.width + rect2.width) / 2f)
+		{
+			return false;
+		}
+		if (Mathf.Abs(_sm1.Position.y - _sm2.Position.y) > Mathf.Abs(rect.height + rect2.height) / 2f)
+		{
+			return false;
+		}
+		return true;
+	}
+
+	private void FormatGroup(List<ScreenMarker> _group)
+	{
+		if (_group.Count <= 0)
+		{
+			return;
+		}
+		Vector2 zero = Vector2.zero;
+		float num = 0f;
+		float num2 = 0f;
+		float num3 = 0f;
+		float num4 = 0f;
+		for (int i = 0; i < _group.Count; i++)
+		{
+			zero += _group[i].ClampedScreenPos;
+			num3 += _group[i].Rect.width;
+			num4 += _group[i].Rect.height;
+			if (i > 0)
+			{
+				num -= _group[i].Rect.width / 2f;
+				num2 -= _group[i].Rect.height / 2f;
+			}
+		}
+		zero /= (float)_group.Count;
+		if (Mathf.Abs(zero.x / clampX) < Mathf.Abs(zero.y / clampY))
+		{
+			zero = new Vector2(Mathf.Clamp(zero.x, 0f - clampX + num3 / 2f, clampX - num3 / 2f), zero.y);
+			_group.Sort(new ComparePositionX());
+			for (int j = 0; j < _group.Count; j++)
+			{
+				_group[j].Position = zero + Vector2.right * (_group[j].Rect.width * (float)j + num);
+			}
+		}
+		else
+		{
+			zero = new Vector2(zero.x, Mathf.Clamp(zero.y, 0f - clampY + num4 / 2f, clampY - num4 / 2f));
+			_group.Sort(new ComparePositionY());
+			for (int k = 0; k < _group.Count; k++)
+			{
+				_group[k].Position = zero + Vector2.down * (_group[k].Rect.height * (float)k + num2);
+			}
+		}
+	}
+
+	public void UpdateMarkerPosition(ScreenMarker _sm)
+	{
+		float num = cam.pixelRect.height / FIXED_CANVAS_HEIGHT;
+		Vector3 vector = cam.WorldToScreenPoint(_sm.transform.position);
+		Vector2 vector3 = (_sm.UnclampedScreenPos = new Vector2(vector.x - cam.pixelRect.width * 0.5f, vector.y - cam.pixelRect.height * 0.5f) / num);
+		bool flag = true;
+		if (Mathf.Abs(vector3.y) > clampY - _sm.checkOnScreenRect.height / 2f)
+		{
+			flag = false;
+		}
+		else if (Mathf.Abs(vector3.x) > clampX - _sm.checkOnScreenRect.width / 2f)
+		{
+			flag = false;
+		}
+		_sm.OnScreen = flag;
+		if ((flag && _sm.showWhenOnScreen) || (!flag && _sm.showWhenOffScreen))
+		{
+			screenMarkersToShow.Add(_sm);
+			_sm.Show(_show: true);
+			if (markerMode == MarkerMode.Direction)
+			{
+				float num2 = (clampX - _sm.Rect.width / 2f) / Mathf.Abs(vector3.x);
+				float num3 = (clampY - _sm.Rect.height / 2f) / Mathf.Abs(vector3.y);
+				float num4 = Mathf.Min(num2, num3, 1f);
+				vector3 = new Vector2(vector3.x, vector3.y) * num4;
+			}
+			else
+			{
+				Rect rect = _sm.Rect;
+				vector3 = new Vector2(Mathf.Clamp(vector3.x, 0f - clampX + rect.width / 2f, clampX - rect.width / 2f), Mathf.Clamp(vector3.y, 0f - clampY + rect.height / 2f, clampY - rect.height / 2f));
+			}
+			_sm.Position = vector3;
+			_sm.ClampedScreenPos = vector3;
+		}
+		else
+		{
+			_sm.Show(_show: false);
+		}
+	}
+}