+1.57

1 files changed, 464 insertions, 0 deletions

diff --git a/Thronefall_1_57/Decompile/I2.Loc/Localize.cs b/Thronefall_1_57/Decompile/I2.Loc/Localize.cs
new file mode 100644
index 0000000..5fc8fac
--- /dev/null
+++ b/Thronefall_1_57/Decompile/I2.Loc/Localize.cs
@@ -0,0 +1,464 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace I2.Loc;
+
+[AddComponentMenu("I2/Localization/I2 Localize")]
+public class Localize : MonoBehaviour
+{
+	public enum TermModification
+	{
+		DontModify,
+		ToUpper,
+		ToLower,
+		ToUpperFirst,
+		ToTitle
+	}
+
+	public string mTerm = string.Empty;
+
+	public string mTermSecondary = string.Empty;
+
+	[NonSerialized]
+	public string FinalTerm;
+
+	[NonSerialized]
+	public string FinalSecondaryTerm;
+
+	public TermModification PrimaryTermModifier;
+
+	public TermModification SecondaryTermModifier;
+
+	public string TermPrefix;
+
+	public string TermSuffix;
+
+	public bool LocalizeOnAwake = true;
+
+	private string LastLocalizedLanguage;
+
+	public bool IgnoreRTL;
+
+	public int MaxCharactersInRTL;
+
+	public bool IgnoreNumbersInRTL = true;
+
+	public bool CorrectAlignmentForRTL = true;
+
+	public bool AddSpacesToJoinedLanguages;
+
+	public bool AllowLocalizedParameters = true;
+
+	public bool AllowParameters = true;
+
+	public List<UnityEngine.Object> TranslatedObjects = new List<UnityEngine.Object>();
+
+	[NonSerialized]
+	public Dictionary<string, UnityEngine.Object> mAssetDictionary = new Dictionary<string, UnityEngine.Object>(StringComparer.Ordinal);
+
+	public UnityEvent LocalizeEvent = new UnityEvent();
+
+	public static string MainTranslation;
+
+	public static string SecondaryTranslation;
+
+	public static string CallBackTerm;
+
+	public static string CallBackSecondaryTerm;
+
+	public static Localize CurrentLocalizeComponent;
+
+	public bool AlwaysForceLocalize;
+
+	[SerializeField]
+	public EventCallback LocalizeCallBack = new EventCallback();
+
+	public bool mGUI_ShowReferences;
+
+	public bool mGUI_ShowTems = true;
+
+	public bool mGUI_ShowCallback;
+
+	public ILocalizeTarget mLocalizeTarget;
+
+	public string mLocalizeTargetName;
+
+	public string Term
+	{
+		get
+		{
+			return mTerm;
+		}
+		set
+		{
+			SetTerm(value);
+		}
+	}
+
+	public string SecondaryTerm
+	{
+		get
+		{
+			return mTermSecondary;
+		}
+		set
+		{
+			SetTerm(null, value);
+		}
+	}
+
+	private void Awake()
+	{
+		UpdateAssetDictionary();
+		FindTarget();
+		if (LocalizeOnAwake)
+		{
+			OnLocalize();
+		}
+	}
+
+	private void OnEnable()
+	{
+		OnLocalize();
+	}
+
+	public bool HasCallback()
+	{
+		if (LocalizeCallBack.HasCallback())
+		{
+			return true;
+		}
+		return LocalizeEvent.GetPersistentEventCount() > 0;
+	}
+
+	public void OnLocalize(bool Force = false)
+	{
+		if ((!Force && (!base.enabled || base.gameObject == null || !base.gameObject.activeInHierarchy)) || string.IsNullOrEmpty(LocalizationManager.CurrentLanguage) || (!AlwaysForceLocalize && !Force && !HasCallback() && LastLocalizedLanguage == LocalizationManager.CurrentLanguage))
+		{
+			return;
+		}
+		LastLocalizedLanguage = LocalizationManager.CurrentLanguage;
+		if (string.IsNullOrEmpty(FinalTerm) || string.IsNullOrEmpty(FinalSecondaryTerm))
+		{
+			GetFinalTerms(out FinalTerm, out FinalSecondaryTerm);
+		}
+		bool flag = I2Utils.IsPlaying() && HasCallback();
+		if (!flag && string.IsNullOrEmpty(FinalTerm) && string.IsNullOrEmpty(FinalSecondaryTerm))
+		{
+			return;
+		}
+		CurrentLocalizeComponent = this;
+		CallBackTerm = FinalTerm;
+		CallBackSecondaryTerm = FinalSecondaryTerm;
+		MainTranslation = ((string.IsNullOrEmpty(FinalTerm) || FinalTerm == "-") ? null : LocalizationManager.GetTranslation(FinalTerm, FixForRTL: false));
+		SecondaryTranslation = ((string.IsNullOrEmpty(FinalSecondaryTerm) || FinalSecondaryTerm == "-") ? null : LocalizationManager.GetTranslation(FinalSecondaryTerm, FixForRTL: false));
+		if (!flag && string.IsNullOrEmpty(FinalTerm) && string.IsNullOrEmpty(SecondaryTranslation))
+		{
+			return;
+		}
+		LocalizeCallBack.Execute(this);
+		LocalizeEvent.Invoke();
+		if (AllowParameters)
+		{
+			LocalizationManager.ApplyLocalizationParams(ref MainTranslation, base.gameObject, AllowLocalizedParameters);
+		}
+		if (!FindTarget())
+		{
+			return;
+		}
+		bool flag2 = LocalizationManager.IsRight2Left && !IgnoreRTL;
+		if (MainTranslation != null)
+		{
+			switch (PrimaryTermModifier)
+			{
+			case TermModification.ToUpper:
+				MainTranslation = MainTranslation.ToUpper();
+				break;
+			case TermModification.ToLower:
+				MainTranslation = MainTranslation.ToLower();
+				break;
+			case TermModification.ToUpperFirst:
+				MainTranslation = GoogleTranslation.UppercaseFirst(MainTranslation);
+				break;
+			case TermModification.ToTitle:
+				MainTranslation = GoogleTranslation.TitleCase(MainTranslation);
+				break;
+			}
+			if (!string.IsNullOrEmpty(TermPrefix))
+			{
+				MainTranslation = (flag2 ? (MainTranslation + TermPrefix) : (TermPrefix + MainTranslation));
+			}
+			if (!string.IsNullOrEmpty(TermSuffix))
+			{
+				MainTranslation = (flag2 ? (TermSuffix + MainTranslation) : (MainTranslation + TermSuffix));
+			}
+			if (AddSpacesToJoinedLanguages && LocalizationManager.HasJoinedWords && !string.IsNullOrEmpty(MainTranslation))
+			{
+				StringBuilder stringBuilder = new StringBuilder();
+				stringBuilder.Append(MainTranslation[0]);
+				int i = 1;
+				for (int length = MainTranslation.Length; i < length; i++)
+				{
+					stringBuilder.Append(' ');
+					stringBuilder.Append(MainTranslation[i]);
+				}
+				MainTranslation = stringBuilder.ToString();
+			}
+			if (flag2 && mLocalizeTarget.AllowMainTermToBeRTL() && !string.IsNullOrEmpty(MainTranslation))
+			{
+				MainTranslation = LocalizationManager.ApplyRTLfix(MainTranslation, MaxCharactersInRTL, IgnoreNumbersInRTL);
+			}
+		}
+		if (SecondaryTranslation != null)
+		{
+			switch (SecondaryTermModifier)
+			{
+			case TermModification.ToUpper:
+				SecondaryTranslation = SecondaryTranslation.ToUpper();
+				break;
+			case TermModification.ToLower:
+				SecondaryTranslation = SecondaryTranslation.ToLower();
+				break;
+			case TermModification.ToUpperFirst:
+				SecondaryTranslation = GoogleTranslation.UppercaseFirst(SecondaryTranslation);
+				break;
+			case TermModification.ToTitle:
+				SecondaryTranslation = GoogleTranslation.TitleCase(SecondaryTranslation);
+				break;
+			}
+			if (flag2 && mLocalizeTarget.AllowSecondTermToBeRTL() && !string.IsNullOrEmpty(SecondaryTranslation))
+			{
+				SecondaryTranslation = LocalizationManager.ApplyRTLfix(SecondaryTranslation);
+			}
+		}
+		if (LocalizationManager.HighlightLocalizedTargets)
+		{
+			MainTranslation = "LOC:" + FinalTerm;
+		}
+		mLocalizeTarget.DoLocalize(this, MainTranslation, SecondaryTranslation);
+		CurrentLocalizeComponent = null;
+	}
+
+	public bool FindTarget()
+	{
+		if (mLocalizeTarget != null && mLocalizeTarget.IsValid(this))
+		{
+			return true;
+		}
+		if (mLocalizeTarget != null)
+		{
+			UnityEngine.Object.DestroyImmediate(mLocalizeTarget);
+			mLocalizeTarget = null;
+			mLocalizeTargetName = null;
+		}
+		if (!string.IsNullOrEmpty(mLocalizeTargetName))
+		{
+			foreach (ILocalizeTargetDescriptor mLocalizeTarget in LocalizationManager.mLocalizeTargets)
+			{
+				if (mLocalizeTargetName == mLocalizeTarget.GetTargetType().ToString())
+				{
+					if (mLocalizeTarget.CanLocalize(this))
+					{
+						this.mLocalizeTarget = mLocalizeTarget.CreateTarget(this);
+					}
+					if (this.mLocalizeTarget != null)
+					{
+						return true;
+					}
+				}
+			}
+		}
+		foreach (ILocalizeTargetDescriptor mLocalizeTarget2 in LocalizationManager.mLocalizeTargets)
+		{
+			if (mLocalizeTarget2.CanLocalize(this))
+			{
+				this.mLocalizeTarget = mLocalizeTarget2.CreateTarget(this);
+				mLocalizeTargetName = mLocalizeTarget2.GetTargetType().ToString();
+				if (this.mLocalizeTarget != null)
+				{
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	public void GetFinalTerms(out string primaryTerm, out string secondaryTerm)
+	{
+		primaryTerm = string.Empty;
+		secondaryTerm = string.Empty;
+		if (FindTarget())
+		{
+			if (mLocalizeTarget != null)
+			{
+				mLocalizeTarget.GetFinalTerms(this, mTerm, mTermSecondary, out primaryTerm, out secondaryTerm);
+				primaryTerm = I2Utils.GetValidTermName(primaryTerm);
+			}
+			if (!string.IsNullOrEmpty(mTerm))
+			{
+				primaryTerm = mTerm;
+			}
+			if (!string.IsNullOrEmpty(mTermSecondary))
+			{
+				secondaryTerm = mTermSecondary;
+			}
+			if (primaryTerm != null)
+			{
+				primaryTerm = primaryTerm.Trim();
+			}
+			if (secondaryTerm != null)
+			{
+				secondaryTerm = secondaryTerm.Trim();
+			}
+		}
+	}
+
+	public string GetMainTargetsText()
+	{
+		string primaryTerm = null;
+		string secondaryTerm = null;
+		if (mLocalizeTarget != null)
+		{
+			mLocalizeTarget.GetFinalTerms(this, null, null, out primaryTerm, out secondaryTerm);
+		}
+		if (!string.IsNullOrEmpty(primaryTerm))
+		{
+			return primaryTerm;
+		}
+		return mTerm;
+	}
+
+	public void SetFinalTerms(string Main, string Secondary, out string primaryTerm, out string secondaryTerm, bool RemoveNonASCII)
+	{
+		primaryTerm = (RemoveNonASCII ? I2Utils.GetValidTermName(Main) : Main);
+		secondaryTerm = Secondary;
+	}
+
+	public void SetTerm(string primary)
+	{
+		if (!string.IsNullOrEmpty(primary))
+		{
+			FinalTerm = (mTerm = primary);
+		}
+		OnLocalize(Force: true);
+	}
+
+	public void SetTerm(string primary, string secondary)
+	{
+		if (!string.IsNullOrEmpty(primary))
+		{
+			FinalTerm = (mTerm = primary);
+		}
+		FinalSecondaryTerm = (mTermSecondary = secondary);
+		OnLocalize(Force: true);
+	}
+
+	internal T GetSecondaryTranslatedObj<T>(ref string mainTranslation, ref string secondaryTranslation) where T : UnityEngine.Object
+	{
+		DeserializeTranslation(mainTranslation, out var value, out var secondary);
+		T val = null;
+		if (!string.IsNullOrEmpty(secondary))
+		{
+			val = GetObject<T>(secondary);
+			if ((UnityEngine.Object)val != (UnityEngine.Object)null)
+			{
+				mainTranslation = value;
+				secondaryTranslation = secondary;
+			}
+		}
+		if ((UnityEngine.Object)val == (UnityEngine.Object)null)
+		{
+			val = GetObject<T>(secondaryTranslation);
+		}
+		return val;
+	}
+
+	public void UpdateAssetDictionary()
+	{
+		TranslatedObjects.RemoveAll((UnityEngine.Object x) => x == null);
+		mAssetDictionary = (from o in TranslatedObjects.Distinct()
+			group o by o.name).ToDictionary((IGrouping<string, UnityEngine.Object> g) => g.Key, (IGrouping<string, UnityEngine.Object> g) => g.First());
+	}
+
+	internal T GetObject<T>(string Translation) where T : UnityEngine.Object
+	{
+		if (string.IsNullOrEmpty(Translation))
+		{
+			return null;
+		}
+		return GetTranslatedObject<T>(Translation);
+	}
+
+	private T GetTranslatedObject<T>(string Translation) where T : UnityEngine.Object
+	{
+		return FindTranslatedObject<T>(Translation);
+	}
+
+	private void DeserializeTranslation(string translation, out string value, out string secondary)
+	{
+		if (!string.IsNullOrEmpty(translation) && translation.Length > 1 && translation[0] == '[')
+		{
+			int num = translation.IndexOf(']');
+			if (num > 0)
+			{
+				secondary = translation.Substring(1, num - 1);
+				value = translation.Substring(num + 1);
+				return;
+			}
+		}
+		value = translation;
+		secondary = string.Empty;
+	}
+
+	public T FindTranslatedObject<T>(string value) where T : UnityEngine.Object
+	{
+		if (string.IsNullOrEmpty(value))
+		{
+			return null;
+		}
+		if (mAssetDictionary == null || mAssetDictionary.Count != TranslatedObjects.Count)
+		{
+			UpdateAssetDictionary();
+		}
+		foreach (KeyValuePair<string, UnityEngine.Object> item in mAssetDictionary)
+		{
+			if (item.Value is T && value.EndsWith(item.Key, StringComparison.OrdinalIgnoreCase) && string.Compare(value, item.Key, StringComparison.OrdinalIgnoreCase) == 0)
+			{
+				return (T)item.Value;
+			}
+		}
+		T val = LocalizationManager.FindAsset(value) as T;
+		if ((bool)(UnityEngine.Object)val)
+		{
+			return val;
+		}
+		return ResourceManager.pInstance.GetAsset<T>(value);
+	}
+
+	public bool HasTranslatedObject(UnityEngine.Object Obj)
+	{
+		if (TranslatedObjects.Contains(Obj))
+		{
+			return true;
+		}
+		return ResourceManager.pInstance.HasAsset(Obj);
+	}
+
+	public void AddTranslatedObject(UnityEngine.Object Obj)
+	{
+		if (!TranslatedObjects.Contains(Obj))
+		{
+			TranslatedObjects.Add(Obj);
+			UpdateAssetDictionary();
+		}
+	}
+
+	public void SetGlobalLanguage(string Language)
+	{
+		LocalizationManager.CurrentLanguage = Language;
+	}
+}