From 8e13e7e2874adc8982e16d1d2ed2e28d7480b45f Mon Sep 17 00:00:00 2001 From: chai <215380520@qq.com> Date: Sun, 19 May 2024 16:05:58 +0800 Subject: +1.57 --- Thronefall_1_57/Decompile/I2.Loc/Localize.cs | 464 +++++++++++++++++++++++++++ 1 file changed, 464 insertions(+) create mode 100644 Thronefall_1_57/Decompile/I2.Loc/Localize.cs (limited to 'Thronefall_1_57/Decompile/I2.Loc/Localize.cs') 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 TranslatedObjects = new List(); + + [NonSerialized] + public Dictionary mAssetDictionary = new Dictionary(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(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(secondary); + if ((UnityEngine.Object)val != (UnityEngine.Object)null) + { + mainTranslation = value; + secondaryTranslation = secondary; + } + } + if ((UnityEngine.Object)val == (UnityEngine.Object)null) + { + val = GetObject(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 g) => g.Key, (IGrouping g) => g.First()); + } + + internal T GetObject(string Translation) where T : UnityEngine.Object + { + if (string.IsNullOrEmpty(Translation)) + { + return null; + } + return GetTranslatedObject(Translation); + } + + private T GetTranslatedObject(string Translation) where T : UnityEngine.Object + { + return FindTranslatedObject(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(string value) where T : UnityEngine.Object + { + if (string.IsNullOrEmpty(value)) + { + return null; + } + if (mAssetDictionary == null || mAssetDictionary.Count != TranslatedObjects.Count) + { + UpdateAssetDictionary(); + } + foreach (KeyValuePair 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(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; + } +} -- cgit v1.1-26-g67d0