using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using HowtoFishLocalizationAPI.Api;
using HowtoFishLocalizationAPI.Integrations.HTFModManager;
using HowtoFishLocalizationAPI.Integrations.ModMenu;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("HowtoFishLocalizationAPI")]
[assembly: AssemblyDescription("How to Fish Localization API by Ice Box Studio")]
[assembly: AssemblyCompany("Ice Box Studio")]
[assembly: AssemblyProduct("HowtoFishLocalizationAPI")]
[assembly: AssemblyCopyright("Copyright © 2026 Ice Box Studio All rights reserved.")]
[assembly: ComVisible(false)]
[assembly: Guid("79870812-2aca-43d5-b058-5844d23fb3b4")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace HowtoFishLocalizationAPI
{
[BepInPlugin("IceBoxStudio.HowToFish.LocalizationAPI", "HowtoFishLocalizationAPI", "1.0.0")]
public sealed class HowtoFishLocalizationAPI : BaseUnityPlugin
{
private Harmony _harmony;
internal static ManualLogSource Log { get; private set; }
private void Awake()
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
LocalizationApi.NotifyLanguageChanged();
_harmony = new Harmony("IceBoxStudio.HowToFish.LocalizationAPI");
_harmony.PatchAll(Assembly.GetExecutingAssembly());
ModMenuSupport.Init(_harmony);
Log.LogInfo((object)"HowtoFishLocalizationAPI 1.0.0 initialized.");
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "IceBoxStudio.HowToFish.LocalizationAPI";
public const string PLUGIN_NAME = "HowtoFishLocalizationAPI";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace HowtoFishLocalizationAPI.Patches
{
[HarmonyPatch(typeof(LocalizationManager), "SetLanguage")]
internal static class GameInitializationPatch
{
[HarmonyPostfix]
private static void Postfix(int __0)
{
LocalizationApi.NotifyLanguageChanged(__0);
}
}
}
namespace HowtoFishLocalizationAPI.Integrations.ModMenu
{
internal static class ModMenuPatch
{
private static void Row(Transform __0, ConfigEntryBase __1)
{
ModMenuSupport.LocalizeRow(__0, __1);
}
}
internal static class ModMenuSupport
{
private const string ModMenuAssembly = "HowToFish.ModMenu";
private const string ModMenuType = "HowToFish.ModMenu.NativeModMenu";
private const string ModMenuGuid = "community.howtofish.modmenu";
private const string LabelPrefix = "modmenu.config.";
private static readonly Dictionary<ConfigFile, string> Owners = new Dictionary<ConfigFile, string>();
private static Harmony _harmony;
private static bool _patched;
private static bool _initialized;
internal static void Init(Harmony harmony)
{
if (!_initialized)
{
_initialized = true;
_harmony = harmony;
LocalizationApi.LanguageChanged += LangChanged;
AppDomain.CurrentDomain.AssemblyLoad += Loaded;
Patch();
HTFModManagerSupport.Init(harmony);
}
}
internal static void LocalizeRow(Transform parent, ConfigEntryBase entry)
{
try
{
if ((Object)(object)parent == (Object)null || entry == null || !Owner(entry, out var guid))
{
return;
}
ConfigDefinition definition = entry.Definition;
string text = "modmenu.config." + definition.Section + "." + definition.Key;
ModLocalizer modLocalizer = Localizer(guid);
if (modLocalizer == null)
{
return;
}
string localizedText = modLocalizer.GetLocalizedText(text);
if (string.Equals(localizedText, text, StringComparison.Ordinal))
{
return;
}
string b = "SettingRow_" + definition.Key;
Transform val = null;
for (int num = parent.childCount - 1; num >= 0; num--)
{
Transform child = parent.GetChild(num);
if (!((Object)(object)child == (Object)null) && string.Equals(((Object)child).name, b, StringComparison.Ordinal))
{
val = child.Find("Label");
if ((Object)(object)val != (Object)null)
{
break;
}
}
}
if ((Object)(object)val == (Object)null)
{
return;
}
Component[] components = ((Component)val).GetComponents<Component>();
foreach (Component val2 in components)
{
if (!((Object)(object)val2 == (Object)null))
{
PropertyInfo property = ((object)val2).GetType().GetProperty("text", BindingFlags.Instance | BindingFlags.Public);
if (!(property == null) && property.CanWrite && !(property.PropertyType != typeof(string)))
{
property.SetValue(val2, localizedText, null);
break;
}
}
}
}
catch
{
}
}
private static void Patch()
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
if (_patched || _harmony == null)
{
return;
}
Type type = Find("HowToFish.ModMenu.NativeModMenu");
if (type == null)
{
return;
}
MethodInfo methodInfo = AccessTools.Method(type, "CreateConfigSettingRow", new Type[4]
{
typeof(Transform),
typeof(ConfigEntryBase),
typeof(string),
typeof(float)
}, (Type[])null);
MethodInfo methodInfo2 = AccessTools.Method(typeof(ModMenuPatch), "Row", (Type[])null, (Type[])null);
if (methodInfo == null || methodInfo2 == null)
{
return;
}
try
{
_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_patched = true;
AppDomain.CurrentDomain.AssemblyLoad -= Loaded;
}
catch
{
}
}
private static Type Find(string fullName)
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (string.Equals(assembly.GetName().Name, "HowToFish.ModMenu", StringComparison.OrdinalIgnoreCase))
{
return assembly.GetType(fullName, throwOnError: false);
}
}
return null;
}
private static void Loaded(object sender, AssemblyLoadEventArgs args)
{
if (args.LoadedAssembly.GetName().Name.Equals("HowToFish.ModMenu", StringComparison.OrdinalIgnoreCase))
{
Patch();
}
HTFModManagerSupport.Patch(args.LoadedAssembly);
}
private static void LangChanged(string language)
{
object obj = Menu();
if (obj == null)
{
return;
}
Type type = obj.GetType();
FieldInfo fieldInfo = AccessTools.Field(type, "_open");
if (!(fieldInfo == null))
{
object value = fieldInfo.GetValue(obj);
if (value is bool && (bool)value)
{
AccessTools.Method(type, "RenderSettings", (Type[])null, (Type[])null)?.Invoke(obj, null);
}
}
}
private static object Menu()
{
if (!Chainloader.PluginInfos.TryGetValue("community.howtofish.modmenu", out var value) || value == null || (Object)(object)value.Instance == (Object)null)
{
return null;
}
return AccessTools.Field(((object)value.Instance).GetType(), "_menu")?.GetValue(value.Instance);
}
private static bool Owner(ConfigEntryBase entry, out string guid)
{
guid = null;
ConfigFile configFile = entry.ConfigFile;
if (configFile == null)
{
return false;
}
if (Owners.TryGetValue(configFile, out guid))
{
return true;
}
foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
{
PluginInfo value = pluginInfo.Value;
if (value != null && !((Object)(object)value.Instance == (Object)null) && value.Instance.Config != null && value.Instance.Config == configFile)
{
guid = pluginInfo.Key;
Owners[configFile] = guid;
return true;
}
}
return false;
}
internal static bool OwnerFor(ConfigFile config, out string guid)
{
guid = null;
if (config == null)
{
return false;
}
if (Owners.TryGetValue(config, out guid))
{
return true;
}
foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
{
PluginInfo value = pluginInfo.Value;
if (value != null && !((Object)(object)value.Instance == (Object)null) && value.Instance.Config != null && value.Instance.Config == config)
{
guid = pluginInfo.Key;
Owners[config] = guid;
return true;
}
}
return false;
}
private static ModLocalizer Localizer(string guid)
{
object obj = AccessTools.Field(typeof(LocalizationApi), "Localizers")?.GetValue(null);
if (obj == null)
{
return null;
}
MethodInfo methodInfo = AccessTools.Method(obj.GetType(), "TryGetValue", (Type[])null, (Type[])null);
if (methodInfo == null)
{
return null;
}
object[] array = new object[2] { guid, null };
object obj2 = methodInfo.Invoke(obj, array);
if (!(obj2 is bool) || !(bool)obj2)
{
return null;
}
return array[1] as ModLocalizer;
}
internal static ModLocalizer GetLocalizer(string guid)
{
return Localizer(guid);
}
}
}
namespace HowtoFishLocalizationAPI.Integrations.HTFModManager
{
internal static class HTFModManagerPatch
{
private static void Row(Transform __0, ConfigDefinition __1, ConfigEntryBase __2)
{
HTFModManagerSupport.LocalizeRow(__0, __1, __2);
}
}
internal static class HTFModManagerSupport
{
private const string AssemblyName = "HTFModManager";
private const string TypeName = "HTFModManager.Plugin";
private const string PluginGuid = "com.howtofish.htfmodmanager";
private const string LabelPrefix = "modmenu.config.";
private static Harmony _harmony;
private static bool _patched;
private static bool _initialized;
internal static void Init(Harmony harmony)
{
if (!_initialized)
{
_initialized = true;
_harmony = harmony;
LocalizationApi.LanguageChanged += LangChanged;
Patch();
}
}
internal static void Patch(Assembly loaded = null)
{
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Expected O, but got Unknown
if (_patched || _harmony == null || (loaded != null && !string.Equals(loaded.GetName().Name, "HTFModManager", StringComparison.OrdinalIgnoreCase)))
{
return;
}
Type type = Find();
if (type == null)
{
return;
}
MethodInfo methodInfo = AccessTools.Method(type, "AddGenericConfigRow", new Type[4]
{
typeof(Transform),
typeof(ConfigDefinition),
typeof(ConfigEntryBase),
typeof(ConfigFile)
}, (Type[])null);
MethodInfo methodInfo2 = AccessTools.Method(typeof(HTFModManagerPatch), "Row", (Type[])null, (Type[])null);
if (methodInfo == null || methodInfo2 == null)
{
return;
}
try
{
_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_patched = true;
}
catch
{
}
}
internal static void LocalizeRow(Transform layout, ConfigDefinition definition, ConfigEntryBase entry)
{
try
{
if ((Object)(object)layout == (Object)null || entry == null || !Owner(entry, out var guid))
{
return;
}
ModLocalizer modLocalizer = Localizer(guid);
if (modLocalizer == null)
{
return;
}
string text = "modmenu.config." + definition.Section + "." + definition.Key;
string localizedText = modLocalizer.GetLocalizedText(text);
if (string.Equals(localizedText, text, StringComparison.Ordinal))
{
return;
}
string[] array = new string[4] { "CfgBool_", "CfgNumber_", "CfgText_", "CfgChoice_" };
Transform val = null;
for (int i = 0; i < array.Length; i++)
{
string b = array[i] + Sanitize(definition.Key);
for (int num = layout.childCount - 1; num >= 0; num--)
{
Transform child = layout.GetChild(num);
if ((Object)(object)child != (Object)null && string.Equals(((Object)child).name, b, StringComparison.Ordinal))
{
val = child;
break;
}
}
if ((Object)(object)val != (Object)null)
{
break;
}
}
if ((Object)(object)val == (Object)null)
{
return;
}
Component[] componentsInChildren = ((Component)val).GetComponentsInChildren<Component>(true);
Component val2 = null;
foreach (Component val3 in componentsInChildren)
{
if ((Object)(object)val3 == (Object)null)
{
continue;
}
PropertyInfo property = ((object)val3).GetType().GetProperty("text", BindingFlags.Instance | BindingFlags.Public);
if (!(property == null) && property.CanWrite && !(property.PropertyType != typeof(string)))
{
if ((Object)(object)val2 == (Object)null)
{
val2 = val3;
}
string name = ((Object)val3.gameObject).name;
if (name.IndexOf("Text", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Title", StringComparison.OrdinalIgnoreCase) >= 0)
{
property.SetValue(val3, localizedText, null);
return;
}
}
}
if ((Object)(object)val2 != (Object)null)
{
((object)val2).GetType().GetProperty("text", BindingFlags.Instance | BindingFlags.Public)?.SetValue(val2, localizedText, null);
}
}
catch
{
}
}
private static Type Find()
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (string.Equals(assembly.GetName().Name, "HTFModManager", StringComparison.OrdinalIgnoreCase))
{
return assembly.GetType("HTFModManager.Plugin", throwOnError: false);
}
}
return null;
}
private static void LangChanged(string language)
{
if (!Chainloader.PluginInfos.TryGetValue("com.howtofish.htfmodmanager", out var value) || value == null || (Object)(object)value.Instance == (Object)null)
{
return;
}
try
{
Type type = ((object)value.Instance).GetType();
FieldInfo fieldInfo = AccessTools.Field(type, "_configViewOpen");
if (fieldInfo == null)
{
return;
}
object value2 = fieldInfo.GetValue(value.Instance);
if (!(value2 is bool) || !(bool)value2)
{
return;
}
FieldInfo fieldInfo2 = AccessTools.Field(type, "_selectedPlugin");
FieldInfo fieldInfo3 = AccessTools.Field(type, "_modsContent");
object? obj = fieldInfo2?.GetValue(value.Instance);
PluginInfo val = (PluginInfo)((obj is PluginInfo) ? obj : null);
object? obj2 = fieldInfo3?.GetValue(value.Instance);
Transform val2 = (Transform)((obj2 is Transform) ? obj2 : null);
object obj3;
if (val == null)
{
obj3 = null;
}
else
{
BaseUnityPlugin instance = val.Instance;
obj3 = ((instance != null) ? instance.Config : null);
}
ConfigFile val3 = (ConfigFile)obj3;
if ((Object)(object)val2 == (Object)null || val3 == null)
{
return;
}
foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in val3)
{
LocalizeRow(val2, item.Key, item.Value);
}
}
catch
{
}
}
private static bool Owner(ConfigEntryBase entry, out string guid)
{
guid = null;
ConfigFile configFile = entry.ConfigFile;
if (configFile == null)
{
return false;
}
return ModMenuSupport.OwnerFor(configFile, out guid);
}
private static ModLocalizer Localizer(string guid)
{
return ModMenuSupport.GetLocalizer(guid);
}
private static string Sanitize(string value)
{
if (string.IsNullOrEmpty(value))
{
return "Unknown";
}
char[] array = value.ToCharArray();
for (int i = 0; i < array.Length; i++)
{
if (!char.IsLetterOrDigit(array[i]))
{
array[i] = '_';
}
}
return new string(array);
}
}
}
namespace HowtoFishLocalizationAPI.Api
{
public static class LocalizationApi
{
[Serializable]
private sealed class LocalSave
{
public int SavedLanguage = -1;
}
public const string DefaultLanguage = "en";
private static readonly Dictionary<string, ModLocalizer> Localizers = new Dictionary<string, ModLocalizer>(StringComparer.OrdinalIgnoreCase);
private static string _currentLanguage = "en";
public static string CurrentLanguage => _currentLanguage;
public static event Action<string> LanguageChanged;
public static ModLocalizer For(string pluginGuid)
{
if (string.IsNullOrWhiteSpace(pluginGuid))
{
throw new ArgumentException("Plugin GUID cannot be empty.", "pluginGuid");
}
if (!Localizers.TryGetValue(pluginGuid, out var value))
{
value = new ModLocalizer();
Localizers.Add(pluginGuid, value);
}
return value;
}
public static bool TryGetCurrentGameLanguage(out string language)
{
language = CurrentLanguage;
return true;
}
internal static void NotifyLanguageChanged(int? languageIndex = null)
{
_currentLanguage = (languageIndex.HasValue ? (Lang(languageIndex.Value) ?? "en") : Read());
Action<string> languageChanged = LocalizationApi.LanguageChanged;
if (languageChanged == null)
{
return;
}
Delegate[] invocationList = languageChanged.GetInvocationList();
foreach (Delegate obj in invocationList)
{
try
{
((Action<string>)obj)(_currentLanguage);
}
catch (Exception ex)
{
ManualLogSource log = HowtoFishLocalizationAPI.Log;
if (log != null)
{
log.LogError((object)("Language callback failed: " + ex));
}
}
}
}
private static string Read()
{
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
string text = ReadSave();
if (!string.IsNullOrEmpty(text))
{
return text;
}
switch (LocalizationManager.CurLanguage)
{
case 0:
return "en";
case 1:
return "sv";
case 2:
return "zh-CN";
case 3:
return "zh-TW";
case 4:
return "fr";
case 5:
return "de";
case 6:
return "it";
case 7:
return "ja";
case 8:
return "ko";
case 9:
return "pl";
case 10:
return "pt-BR";
case 11:
return "ru";
case 12:
return "es-MX";
case 13:
return "es-ES";
case 14:
return "tr";
case 15:
return "uk";
default:
if (LocalizationSettings.InitializationOperation.IsDone && (Object)(object)LocalizationSettings.SelectedLocale != (Object)null)
{
LocaleIdentifier identifier = LocalizationSettings.SelectedLocale.Identifier;
string code = ((LocaleIdentifier)(ref identifier)).Code;
if (!string.IsNullOrWhiteSpace(code))
{
if (code.StartsWith("zh", StringComparison.OrdinalIgnoreCase))
{
if (code.IndexOf("TW", StringComparison.OrdinalIgnoreCase) < 0 && code.IndexOf("HK", StringComparison.OrdinalIgnoreCase) < 0)
{
return "zh-CN";
}
return "zh-TW";
}
return code;
}
}
return "en";
}
}
private static string ReadSave()
{
string path = Path.Combine(Application.persistentDataPath, "Saves", "local.txt");
if (!File.Exists(path))
{
return null;
}
try
{
LocalSave localSave = JsonConvert.DeserializeObject<LocalSave>(File.ReadAllText(path));
return (localSave == null) ? null : Lang(localSave.SavedLanguage);
}
catch
{
return null;
}
}
private static string Lang(int index)
{
return index switch
{
0 => "en",
1 => "sv",
2 => "zh-CN",
3 => "zh-TW",
4 => "fr",
5 => "de",
6 => "it",
7 => "ja",
8 => "ko",
9 => "pl",
10 => "pt-BR",
11 => "ru",
12 => "es-MX",
13 => "es-ES",
14 => "tr",
15 => "uk",
_ => null,
};
}
}
public sealed class ModLocalizer
{
private readonly Dictionary<string, Dictionary<string, string>> _localizations = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);
internal ModLocalizer()
{
}
public void RegisterJson(string jsonPath)
{
if (string.IsNullOrWhiteSpace(jsonPath))
{
throw new ArgumentException("Localization file path cannot be empty.", "jsonPath");
}
if (!File.Exists(jsonPath))
{
throw new FileNotFoundException("Localization file not found.", jsonPath);
}
Dictionary<string, Dictionary<string, string>> dictionary = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>(File.ReadAllText(jsonPath));
if (dictionary == null || !dictionary.ContainsKey("en"))
{
throw new InvalidDataException("Localization file must contain a en section.");
}
_localizations.Clear();
foreach (KeyValuePair<string, Dictionary<string, string>> item in dictionary)
{
if (!string.IsNullOrWhiteSpace(item.Key) && item.Value != null)
{
_localizations[item.Key] = item.Value;
}
}
}
public string GetLocalizedText(string key, params object[] args)
{
if (string.IsNullOrEmpty(key))
{
return string.Empty;
}
if (TryText(LocalizationApi.CurrentLanguage, key, out var text) || TryText("en", key, out text))
{
return Fmt(text, args);
}
return key;
}
private bool TryText(string language, string key, out string text)
{
text = null;
if (_localizations.TryGetValue(language, out var value))
{
return value.TryGetValue(key, out text);
}
return false;
}
private static string Fmt(string text, object[] args)
{
if (args == null || args.Length == 0)
{
return text;
}
try
{
return string.Format(text, args);
}
catch (FormatException)
{
return text;
}
}
}
}
