using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("BoplTranslator")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Custom translation support for Bopl Battle")]
[assembly: AssemblyFileVersion("2.0.1.0")]
[assembly: AssemblyInformationalVersion("2.0.1+91ea9bba8bc487602bef1d62c569cc140e497ae5")]
[assembly: AssemblyProduct("BoplTranslator")]
[assembly: AssemblyTitle("BoplTranslator")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace BoplTranslator
{
public enum GameFont
{
English,
Japanese,
Korean,
Russian,
Chinese,
Polish
}
public class CustomLanguage
{
internal Dictionary<string, string> translationPairs = new Dictionary<string, string>();
public string Name { get; internal set; }
public GameFont Font { get; set; }
public bool IsReferenced { get; private set; }
public string this[string guid]
{
get
{
return GetTranslation(guid);
}
set
{
EditTranslation(guid, value);
}
}
public CustomLanguage(string name, GameFont font = GameFont.English)
: this(name, font, copyFallback: true)
{
}
public string GetTranslation(string guid)
{
return translationPairs[guid];
}
public void EditTranslation(string guid, string newTranslation)
{
translationPairs[guid] = newTranslation.ToLower();
}
public void EditTranslations(Dictionary<string, string> guidTranslationPair)
{
foreach (KeyValuePair<string, string> item in guidTranslationPair)
{
translationPairs[item.Key] = item.Value.ToLower();
}
}
internal CustomLanguage(string name, GameFont font, bool copyFallback)
{
name = name.ToLower();
CustomLanguage customLanguage = BoplTranslator.GetCustomLanguage(name);
if (customLanguage != null)
{
Name = customLanguage.Name;
Font = customLanguage.Font;
translationPairs = customLanguage.translationPairs;
IsReferenced = true;
return;
}
Name = name;
Font = font;
if (copyFallback)
{
CustomLanguage fallbackLanguage = LanguagePatch.fallbackLanguage;
translationPairs = new Dictionary<string, string>(fallbackLanguage.translationPairs) { ["name"] = name };
LanguagePatch.customLanguages.Add(this);
}
}
}
public static class BoplTranslator
{
private static readonly FieldInfo textToLocalize2Field = typeof(LocalizedText).GetField("textToLocalize2", AccessTools.all);
public static void UpdateTexts()
{
LocalizedText[] array = Resources.FindObjectsOfTypeAll<LocalizedText>();
foreach (LocalizedText val in array)
{
try
{
val.UpdateText();
}
catch (Exception arg)
{
if (textToLocalize2Field.GetValue(val) != null)
{
Plugin.logger.LogFatal((object)$"Error at updateText: {arg}");
Plugin.logger.LogFatal((object)("name: " + ((Object)val).name + ", enText: " + ((LanguagePatch.textField.GetValue(val) as string) ?? "null")));
}
}
}
}
public static bool IsCustomLanguage(this Language lang)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Invalid comparison between Unknown and I4
return (int)lang > LanguagePatch.OGLanguagesCount;
}
public static CustomLanguage GetCustomLanguage(Language lang)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected I4, but got Unknown
if (!lang.IsCustomLanguage())
{
return LanguagePatch.ogLanguages[(int)lang];
}
return LanguagePatch.GetCustomLanguage(lang);
}
public static CustomLanguage GetCustomLanguage(string langName)
{
langName = langName.ToLower();
CustomLanguage customLanguage = LanguagePatch.ogLanguages.Find((CustomLanguage e) => e.Name == langName);
if (customLanguage != null)
{
return customLanguage;
}
return LanguagePatch.customLanguages.Find((CustomLanguage e) => e.Name == langName);
}
public static CustomLanguage GetCurrentLanguage()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
return GetCustomLanguage(Settings.Get().Language);
}
public static LocalizedText AttachLocalizedText(GameObject textObject, string translationGUID, bool stroke = false)
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)textObject == (Object)null)
{
throw new ArgumentNullException("textObject");
}
LocalizedText component = textObject.GetComponent<LocalizedText>();
LocalizedText val = component ?? textObject.AddComponent<LocalizedText>();
Traverse val2 = new Traverse((object)val);
LanguagePatch.textField.SetValue(val, translationGUID);
val.useFontWithStroke = stroke;
val2.Field("textToLocalize").SetValue((object)textObject.GetComponent<TextMeshProUGUI>());
val2.Field("textToLocalize2").SetValue((object)textObject.GetComponent<TextMesh>());
if (component != null)
{
component.UpdateText();
}
return val;
}
}
internal static class LanguagePatch
{
private static readonly Dictionary<string, string> _translationLookUp = new Dictionary<string, string>
{
{ "name", "en" },
{ "menu_play", "play" },
{ "play_start", "start!" },
{ "menu_online", "online" },
{ "menu_settings", "settings" },
{ "menu_exit", "exit" },
{ "settings_sfx_vol", "sfx\nvol" },
{ "settings_music_vol", "music\nvol" },
{ "settings_abilities", "abilities" },
{ "settings_screen_shake", "screen shake" },
{ "settings_rumble", "rumble" },
{ "settings_resolution", "resolution" },
{ "settings_save", "save" },
{ "general_on", "on" },
{ "general_off", "off" },
{ "general_high", "high" },
{ "screen_fullscreen", "fullscreen" },
{ "screen_windowed", "windowed" },
{ "screen_borderless", "borderless" },
{ "settings_screen", "screen" },
{ "play_click", "click to join!" },
{ "play_ready", "ready!" },
{ "play_color", "color" },
{ "play_team", "team" },
{ "rebind_keys", "rebind keys" },
{ "rebind_jump", "click jump" },
{ "rebind_ability_left", "click ability_left" },
{ "rebind_ability_right", "click ability_right" },
{ "rebind_ability_top", "click ability_top" },
{ "rebind_move_left", "click move_left" },
{ "rebind_move_down", "click move_down" },
{ "rebind_move_right", "click move_right" },
{ "rebind_move_up", "click move_up" },
{ "settings_vsync", "vsync" },
{ "hide_nothing", "nothing" },
{ "settings_hide", "hide" },
{ "hide_names", "names" },
{ "hide_names_avatars", "names and avatars" },
{ "undefined_mouse_only", "mouse only" },
{ "play_local_game", "local game" },
{ "undefined_click_start", "click to start!" },
{ "end_next_level", "next level" },
{ "end_ability_select", "ability select" },
{ "end_winner", "winner!!" },
{ "end_winners", "winners!!" },
{ "end_draw", "draw!" },
{ "undefined_whishlist", "wishlist bopl battle!" },
{ "play_choosing", "choosing..." },
{ "pause_leave", "leave game?" },
{ "menu_invite", "invite friend" },
{ "undefined_practice", "practice" },
{ "tutorial_hold_dow", "hold down" },
{ "tutorial_aim", "to aim" },
{ "tutorial_throw_greneade", "to throw grenade" },
{ "tutorial_dash", "to dash" },
{ "tutorial_click", "click" },
{ "menu_credits", "credits" },
{ "credits_back", "back" },
{ "menu_tutorial", "tutorial" },
{ "play_empty_lobby", "your lobby is empty" },
{ "play_invite", "invite a friend to play online" },
{ "play_not_abailable_demo", "not available in demo" },
{ "play_find_players", "find players" },
{ "play_stop_player_search", "stop search" },
{ "item_bow", "bow" },
{ "item_tesla_coil", "tesla coil" },
{ "item_engine", "engine" },
{ "item_smoke", "smoke" },
{ "item_invisibility", "invisibility" },
{ "item_platform", "platform" },
{ "item_meteor", "meteor" },
{ "item_random", "random" },
{ "item_missile", "missile" },
{ "item_black_hole", "black hole" },
{ "item_rock", "rock" },
{ "item_push", "push" },
{ "item_dash", "dash" },
{ "item_grenade", "grenade" },
{ "item_roll", "roll" },
{ "item_time_stop", "time stop" },
{ "item_blink_gun", "blink gun" },
{ "item_gust", "gust" },
{ "item_mine", "mine" },
{ "item_revival", "revival" },
{ "item_spike", "spike" },
{ "item_shrink_ray", "shrink ray" },
{ "item_growth_ray", "growth ray" },
{ "item_chain", "chain" },
{ "item_time_lock", "time lock" },
{ "item_throw", "throw" },
{ "item_teleport", "teleport" },
{ "item_grappling_hook", "grappling hook" },
{ "item_drill", "drill" },
{ "item_beam", "beam" }
};
internal static readonly List<CustomLanguage> ogLanguages = new List<CustomLanguage>();
internal static readonly List<CustomLanguage> customLanguages = new List<CustomLanguage>();
internal static CustomLanguage fallbackLanguage;
internal static readonly FieldInfo textField = typeof(LocalizedText).GetField("enText", AccessTools.all);
internal static int OGLanguagesCount { get; private set; }
internal static void Init()
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Expected O, but got Unknown
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Expected O, but got Unknown
//IL_024f: Unknown result type (might be due to invalid IL or missing references)
Plugin.harmony.Patch((MethodBase)AccessTools.Method(typeof(LocalizationTable), "GetText", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LanguagePatch), "GetText_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Plugin.harmony.Patch((MethodBase)AccessTools.Method(typeof(LocalizedText), "Start", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LanguagePatch), "TextStart_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Plugin.harmony.Patch((MethodBase)AccessTools.Method(typeof(LocalizationTable), "GetFont", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LanguagePatch), "GetFont_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
OGLanguagesCount = Utils.MaxOfEnum<Language>();
Dictionary<string, string>.KeyCollection keys = _translationLookUp.Keys;
int num = 0;
string[] array = new string[keys.Count];
foreach (string item in keys)
{
array[num] = item;
num++;
}
string[] translationKeys = array;
Dictionary<string, string>.ValueCollection values = _translationLookUp.Values;
List<string> list = new List<string>(values.Count);
list.AddRange(values);
List<string> translationValues = list;
LocalizationTable table = Resources.FindObjectsOfTypeAll<LocalizationTable>()[0];
MakeCustomFromBuiltIn(table.en, GameFont.English);
MakeCustomFromBuiltIn(table.de, GameFont.English);
MakeCustomFromBuiltIn(table.es, GameFont.English);
MakeCustomFromBuiltIn(table.fr, GameFont.English);
MakeCustomFromBuiltIn(table.it, GameFont.English);
MakeCustomFromBuiltIn(table.jp, GameFont.Japanese);
MakeCustomFromBuiltIn(table.ko, GameFont.Korean);
MakeCustomFromBuiltIn(table.pl, GameFont.Polish);
MakeCustomFromBuiltIn(table.ptbr, GameFont.Polish);
MakeCustomFromBuiltIn(table.ru, GameFont.Russian);
MakeCustomFromBuiltIn(table.se, GameFont.English);
MakeCustomFromBuiltIn(table.tr, GameFont.Polish);
MakeCustomFromBuiltIn(table.zhcn, GameFont.Chinese);
MakeCustomFromBuiltIn(table.zhtw, GameFont.Chinese);
fallbackLanguage = BoplTranslator.GetCustomLanguage(Plugin.fallbackLanguage.Value);
foreach (FileInfo item2 in Plugin.translationsDir.EnumerateFiles())
{
Plugin.logger.LogInfo((object)("Reading \"" + item2.Name + "\""));
Dictionary<string, string> dictionary = new Dictionary<string, string>();
foreach (string item3 in File.ReadLines(item2.FullName))
{
string text = item3;
int num2 = text.IndexOf('#');
if (num2 != -1)
{
text = text.Remove(num2);
}
string[] array2 = text.Split(new char[1] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries);
if (array2.Length >= 2)
{
string key = array2[0].Trim();
string value = array2[1].Trim().Replace("\\n", "\n");
dictionary[key] = value;
}
}
if (!dictionary.TryGetValue("name", out var value2))
{
if (dictionary.ContainsKey("menu_language"))
{
Plugin.logger.LogError((object)"Use 'name' instead of 'menu_language'!");
}
else
{
Plugin.logger.LogError((object)"No 'name' entry!");
}
continue;
}
GameFont result = fallbackLanguage.Font;
if (dictionary.TryGetValue("font", out var value3) && Enum.TryParse<GameFont>(value3, out result))
{
dictionary.Remove("font");
}
CustomLanguage customLanguage = new CustomLanguage(value2, result, copyFallback: false);
customLanguage.EditTranslations(dictionary);
array = translationKeys;
foreach (string text2 in array)
{
if (!customLanguage.translationPairs.ContainsKey(text2))
{
string translation = fallbackLanguage.GetTranslation(text2);
customLanguage.translationPairs.Add(text2, translation);
if (!text2.StartsWith("undefined"))
{
Plugin.logger.LogWarning((object)("No translation for \"" + text2 + "\" in \"" + item2.Name + "\""));
}
}
}
if (!customLanguage.IsReferenced)
{
customLanguages.Add(customLanguage);
}
Plugin.logger.LogInfo((object)("Successfully read \"" + item2.Name + "\""));
}
void MakeCustomFromBuiltIn(string[] translations, GameFont font)
{
CustomLanguage customLanguage2 = new CustomLanguage(translations[0], font, copyFallback: false);
for (int i = 0; i < translations.Length; i++)
{
string text3 = table.en[i];
int num3 = translationValues.FindIndex((string e) => e == text3);
if (num3 != -1)
{
customLanguage2.translationPairs.Add(translationKeys[num3], translations[i]);
}
}
ogLanguages.Add(customLanguage2);
}
}
internal static bool GetText_Prefix(LocalizationTable __instance, ref string __result, string enText, Language lang)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
if (enText == null)
{
return false;
}
__result = enText;
CustomLanguage customLanguage = BoplTranslator.GetCustomLanguage(lang);
if (customLanguage == null)
{
return false;
}
if (customLanguage.translationPairs.TryGetValue(enText, out var value))
{
__result = value;
return false;
}
foreach (KeyValuePair<string, string> item in _translationLookUp)
{
if (!(item.Value != enText))
{
__result = customLanguage.translationPairs[item.Key];
return false;
}
}
return false;
}
internal static void TextStart_Prefix(LocalizedText __instance)
{
string ogText = textField.GetValue(__instance) as string;
if (ogText == null)
{
return;
}
try
{
string key = _translationLookUp.First((KeyValuePair<string, string> e) => e.Value == ogText).Key;
textField.SetValue(__instance, key);
}
catch (InvalidOperationException)
{
}
}
internal static void GetFont_Prefix(ref Language lang)
{
if (lang.IsCustomLanguage())
{
switch (GetCustomLanguage(lang)?.Font ?? fallbackLanguage.Font)
{
case GameFont.English:
lang = (Language)0;
break;
case GameFont.Japanese:
lang = (Language)5;
break;
case GameFont.Korean:
lang = (Language)6;
break;
case GameFont.Russian:
lang = (Language)9;
break;
case GameFont.Chinese:
lang = (Language)12;
break;
case GameFont.Polish:
lang = (Language)7;
break;
}
}
}
internal static CustomLanguage GetCustomLanguage(Language lang)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected I4, but got Unknown
return customLanguages.ElementAtOrDefault(lang - OGLanguagesCount - 1);
}
}
[BepInPlugin("com.almafa64.BoplTranslator", "BoplTranslator", "2.0.1")]
[BepInProcess("BoplBattle.exe")]
public class Plugin : BaseUnityPlugin
{
internal static Harmony harmony;
internal static DirectoryInfo translationsDir;
internal static ConfigFile config;
internal static ConfigEntry<string> lastCustomLanguageCode;
internal static ConfigEntry<Language> fallbackLanguage;
internal static ManualLogSource logger;
private void Awake()
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Expected O, but got Unknown
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Expected O, but got Unknown
translationsDir = new DirectoryInfo(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "translations"));
translationsDir.Create();
harmony = new Harmony("BoplTranslator");
logger = ((BaseUnityPlugin)this).Logger;
config = ((BaseUnityPlugin)this).Config;
lastCustomLanguageCode = ((BaseUnityPlugin)this).Config.Bind<string>("store", "last_custom_language_code", "", "dont modify pls");
fallbackLanguage = ((BaseUnityPlugin)this).Config.Bind<Language>("settings", "fallback language", (Language)0, new ConfigDescription("The built-in language to use when translation is not found", (AcceptableValueBase)(object)new AcceptableLanguageRange(), Array.Empty<object>()));
SceneManager.sceneLoaded += OnSceneLoaded;
try
{
LanguagePatch.Init();
}
catch (Exception arg)
{
((BaseUnityPlugin)this).Logger.LogFatal((object)$"Error at Language: {Environment.NewLine}{arg}");
}
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
if (((Scene)(ref scene)).name == "MainMenu")
{
((MonoBehaviour)this).StartCoroutine(TimeoutSceneLoad());
}
}
private IEnumerator TimeoutSceneLoad()
{
if (LanguagePatch.customLanguages.Count == 0)
{
if ((int)Settings.Get().Language > LanguagePatch.OGLanguagesCount)
{
Settings.Get().Language = fallbackLanguage.Value;
BoplTranslator.UpdateTexts();
}
yield break;
}
yield return (object)new WaitForSeconds(0.05f);
GameObject val = GameObject.Find("LanguageMenu_leaveACTIVE");
int index = val.transform.childCount - 1;
GameObject val2 = Object.Instantiate<GameObject>(GameObject.Find("Resolution"));
GameObject val3 = Object.Instantiate<GameObject>(GameObject.Find("en"), val.transform);
Button[] componentsInChildren = val2.GetComponentsInChildren<Button>();
val3.GetComponentInChildren<SelectionBorder>().ButtonsWithTextColors = componentsInChildren;
Button[] array = componentsInChildren;
foreach (Button obj in array)
{
((Component)obj).transform.SetParent(val3.transform);
((Component)obj).transform.localScale = new Vector3(1f, 1f, 1f);
}
((Component)componentsInChildren[0]).transform.localPosition = new Vector3(370f, 35f, 0f);
((Component)componentsInChildren[1]).transform.localPosition = new Vector3(-300f, 35f, 0f);
Object.Destroy((Object)(object)val2);
Object.Destroy((Object)(object)val3.GetComponent<OptionsButton>());
LanguageSelector selector = val3.AddComponent<LanguageSelector>();
foreach (CustomLanguage customLanguage in LanguagePatch.customLanguages)
{
selector.languageNames.Add(customLanguage.Name);
}
if (lastCustomLanguageCode.Value == "")
{
lastCustomLanguageCode.Value = selector.languageNames[0];
}
selector.langMenu = val;
selector.Init();
MainMenu menu = val.GetComponent<MainMenu>();
menu.ConfiguredMenuItems.Add(val3);
Traverse obj2 = Traverse.Create((object)menu);
obj2.Field("Indices").GetValue<List<int>>().Add(0);
obj2.Field("MenuItemTransforms").GetValue<List<RectTransform>>().Add(val3.GetComponent<RectTransform>());
obj2.Field("MenuItems").GetValue<List<IMenuItem>>().Add((IMenuItem)(object)val3.GetComponent<OptionsButton>());
List<Vector2> value = obj2.Field("originalMenuItemPositions").GetValue<List<Vector2>>();
float num = value[0].y - value[2].y;
value.Add(new Vector2(0f, value[index].y - num));
((Object)val3).name = "Custom Languages";
CallOnHover component = val3.GetComponent<CallOnHover>();
UnityEvent onHover = component.onHover;
((UnityEventBase)onHover).RemoveAllListeners();
onHover.AddListener((UnityAction)delegate
{
menu.Select(14);
selector.InputActive = true;
});
component.onExitHover.AddListener((UnityAction)delegate
{
selector.InputActive = false;
});
UnityEvent onClick = component.onClick;
((UnityEventBase)onClick).RemoveAllListeners();
onClick.AddListener(new UnityAction(selector.Click));
}
}
public class LanguageSelector : MonoBehaviour, IMenuItem
{
private BindInputAxisToButton[] InputArrows;
public TextMeshProUGUI textMesh;
public List<string> languageNames = new List<string>();
public GameObject langMenu;
public bool InputActive { get; set; }
public int OptionIndex { get; private set; }
private void TryFindLastLanguage()
{
int num = languageNames.IndexOf(Plugin.lastCustomLanguageCode.Value);
if (num != -1)
{
OptionIndex = num;
langMenu.GetComponent<LanguageMenu>().SetLanguage(num + LanguagePatch.OGLanguagesCount + 1);
Plugin.logger.LogInfo((object)("Found last used language \"" + Plugin.lastCustomLanguageCode.Value + "\""));
}
else
{
langMenu.GetComponent<LanguageMenu>().SetLanguage(0);
OptionIndex = 0;
Plugin.lastCustomLanguageCode.Value = languageNames[0];
Plugin.logger.LogError((object)("Couldn't find last used language \"" + Plugin.lastCustomLanguageCode.Value + "\""));
}
}
public void Init()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected I4, but got Unknown
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
//IL_0148: Expected O, but got Unknown
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_0176: Expected O, but got Unknown
OptionIndex = (int)Settings.Get().Language;
if (OptionIndex <= LanguagePatch.OGLanguagesCount)
{
OptionIndex = 0;
}
else
{
OptionIndex -= LanguagePatch.OGLanguagesCount + 1;
if (OptionIndex >= languageNames.Count)
{
Plugin.logger.LogWarning((object)$"Language number {OptionIndex} was selected, but no language with that number exists");
TryFindLastLanguage();
}
else if (languageNames[OptionIndex] != Plugin.lastCustomLanguageCode.Value)
{
Plugin.logger.LogWarning((object)("last language wasn't \"" + languageNames[OptionIndex] + "\", it was \"" + Plugin.lastCustomLanguageCode.Value + "\""));
TryFindLastLanguage();
}
}
InputArrows = ((Component)this).GetComponentsInChildren<BindInputAxisToButton>();
textMesh = ((Component)this).GetComponentInChildren<TextMeshProUGUI>();
((TMP_Text)textMesh).font = LocalizedText.localizationTable.enFontAsset;
Button component = ((Component)InputArrows[1]).GetComponent<Button>();
((UnityEventBase)component.onClick).RemoveAllListeners();
((UnityEvent)component.onClick).AddListener(new UnityAction(Previous));
Button component2 = ((Component)InputArrows[0]).GetComponent<Button>();
((UnityEventBase)component2.onClick).RemoveAllListeners();
((UnityEvent)component2.onClick).AddListener(new UnityAction(Next));
}
private void Update()
{
((TMP_Text)textMesh).text = languageNames[OptionIndex];
for (int i = 0; i < InputArrows.Length; i++)
{
((Behaviour)InputArrows[i]).enabled = InputActive;
}
}
public void Next()
{
OptionIndex = (OptionIndex + 1) % languageNames.Count;
Update();
}
public void Previous()
{
OptionIndex = (OptionIndex - 1 + languageNames.Count) % languageNames.Count;
Update();
}
public void Click()
{
if (InputActive && ((Behaviour)this).isActiveAndEnabled)
{
langMenu.GetComponent<LanguageMenu>().SetLanguage(LanguagePatch.OGLanguagesCount + 1 + OptionIndex);
GameObject.Find("mainMenu_leaveACTIVE").GetComponent<MainMenu>().EnableAll();
langMenu.GetComponent<MainMenu>().DisableAll();
AudioManager.Get().Play("return3");
Plugin.lastCustomLanguageCode.Value = languageNames[OptionIndex];
}
}
}
internal class AcceptableLanguageRange : AcceptableValueRange<Language>
{
public AcceptableLanguageRange()
: base((Language)Utils.MinOfEnum<Language>(), (Language)Utils.MaxOfEnum<Language>())
{
}
public override string ToDescriptionString()
{
return "# Acceptable langauges: " + string.Join(", ", Enum.GetNames(typeof(Language)));
}
}
public static class Utils
{
public static int MaxOfEnum<T>()
{
return Enum.GetValues(typeof(T)).Cast<int>().Max();
}
public static int MinOfEnum<T>()
{
return Enum.GetValues(typeof(T)).Cast<int>().Min();
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "BoplTranslator";
public const string PLUGIN_NAME = "BoplTranslator";
public const string PLUGIN_VERSION = "2.0.1";
}
}
