using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Xml;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GlobalEnums;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using TeamCherry.Localization;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SimpleSilksongLocalizer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+9037140b01be5b0bad4d9e3f007d5c35de03136c")]
[assembly: AssemblyProduct("SimpleSilksongLocalizer")]
[assembly: AssemblyTitle("SimpleSilksongLocalizer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace SimpleSilksongLocalizer
{
public static class Extensions
{
public static TValue GetOrInsertNew<TKey, TValue>(this Dictionary<TKey, TValue> dict, TKey key) where TValue : new()
{
if (dict.TryGetValue(key, out TValue value))
{
return value;
}
return dict[key] = new TValue();
}
}
public static class LanguagePatch
{
[HarmonyPatch(typeof(Language), "DoSwitch")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> SlackenXmlReader(IEnumerable<CodeInstruction> instructions)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(XmlReader), "Create", new Type[1] { typeof(TextReader) }, (Type[])null), (string)null)
});
CodeInstruction val2 = Transpilers.EmitDelegate<Func<StringReader, XmlReader>>((Func<StringReader, XmlReader>)delegate(StringReader reader)
{
XmlReaderSettings settings = new XmlReaderSettings
{
ConformanceLevel = ConformanceLevel.Fragment
};
return XmlReader.Create(reader, settings);
});
val.Set(val2.opcode, val2.operand);
return val.InstructionEnumeration();
}
[HarmonyPatch(typeof(Language), "DoSwitch")]
[HarmonyPostfix]
private static void InsertCurrentLanguageExtraStrings()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
if (!SimpleSilksongLocalizerPlugin.ModExtraEntries.TryGetValue(Language._currentLanguage, out Dictionary<string, Dictionary<string, string>> value))
{
return;
}
foreach (KeyValuePair<string, Dictionary<string, string>> item in value)
{
item.Deconstruct(out var key, out var value2);
string key2 = key;
Dictionary<string, string> dictionary = value2;
Dictionary<string, string> orInsertNew = Language._currentEntrySheets.GetOrInsertNew(key2);
foreach (KeyValuePair<string, string> item2 in dictionary)
{
item2.Deconstruct(out key, out var value3);
string key3 = key;
string value4 = value3;
orInsertNew[key3] = value4;
}
}
}
[HarmonyPatch(typeof(Language), "HasLanguageFile")]
[HarmonyPostfix]
private static void HasModdedLanguageFile(ref bool __result, string lang, string sheetTitle)
{
if (__result)
{
return;
}
foreach (KeyValuePair<string, LocalizationSettings> modLocalizationDirectory in SimpleSilksongLocalizerPlugin.ModLocalizationDirectories)
{
modLocalizationDirectory.Deconstruct(out var key, out var value);
string path = key;
LocalizationSettings localizationSettings = value;
string path2 = Path.Combine(path, lang, sheetTitle);
if (File.Exists(path2))
{
__result = true;
break;
}
string text = ((object)(LanguageCode)(ref Language._currentLanguage)).ToString();
string text2 = localizationSettings?.GetFallbackLang(text);
if (string.IsNullOrEmpty(text2) || text2 == text || !File.Exists(Path.Combine(path, text2, sheetTitle)))
{
continue;
}
__result = true;
break;
}
}
[HarmonyPatch(typeof(Language), "GetLanguageFileContents")]
[HarmonyPostfix]
private static void AddModdedLanguageFileContents(ref string __result, string sheetTitle)
{
string text = string.Empty;
string key;
LocalizationSettings value;
foreach (KeyValuePair<string, LocalizationSettings> modLocalizationDirectory in SimpleSilksongLocalizerPlugin.ModLocalizationDirectories)
{
modLocalizationDirectory.Deconstruct(out key, out value);
string path = key;
LocalizationSettings localizationSettings = value;
string text2 = ((object)(LanguageCode)(ref Language._currentLanguage)).ToString();
string text3 = localizationSettings?.GetFallbackLang(text2);
if (!string.IsNullOrEmpty(text3) && !(text3 == text2))
{
string path2 = Path.Combine(path, text3, sheetTitle);
if (File.Exists(path2))
{
text += File.ReadAllText(path2);
}
}
}
text += __result;
foreach (KeyValuePair<string, LocalizationSettings> modLocalizationDirectory2 in SimpleSilksongLocalizerPlugin.ModLocalizationDirectories)
{
modLocalizationDirectory2.Deconstruct(out key, out value);
string path3 = key;
string path4 = Path.Combine(path3, ((object)(LanguageCode)(ref Language._currentLanguage)).ToString(), sheetTitle);
if (File.Exists(path4))
{
text += File.ReadAllText(path4);
}
}
__result = text;
}
}
internal class LocalizationSettings
{
internal class FallbackSettings
{
[JsonProperty(/*Could not decode attribute arguments.*/)]
[JsonConverter(typeof(StringEnumConverter))]
public LanguageCode Language { get; set; }
[JsonProperty(/*Could not decode attribute arguments.*/)]
public string[]? Excluded { get; set; }
}
[JsonProperty(/*Could not decode attribute arguments.*/)]
public string[]? CustomSheets { get; set; }
[JsonProperty(/*Could not decode attribute arguments.*/)]
public LanguageCode[]? CustomLanguages { get; set; }
[JsonProperty(/*Could not decode attribute arguments.*/)]
public FallbackSettings? Fallback { get; set; }
public string GetFallbackLang(string sourceLanguage)
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
if (!SimpleSilksongLocalizerPlugin.EnableFallbacks.Value || Fallback == null || (Fallback.Excluded != null && Fallback.Excluded.Contains(sourceLanguage)))
{
return string.Empty;
}
LanguageCode language = Fallback.Language;
return ((int)language != 0) ? string.Empty : ((object)(LanguageCode)(ref language)).ToString();
}
}
public class MenuLanguageSettingPatch
{
[HarmonyPatch(typeof(MenuLanguageSetting), "RefreshAvailableLanguages")]
[HarmonyTranspiler]
public static IEnumerable<CodeInstruction> SupportAllAvailableLanguages(IEnumerable<CodeInstruction> instructions)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Expected O, but got Unknown
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Expected O, but got Unknown
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Expected O, but got Unknown
CodeInstruction del = Transpilers.EmitDelegate<Func<SupportedLanguages[]>>((Func<SupportedLanguages[]>)delegate
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
List<SupportedLanguages> list = new List<SupportedLanguages>();
foreach (string availableLanguage in Language._availableLanguages)
{
if (Enum.TryParse<LanguageCode>(availableLanguage, out LanguageCode result))
{
list.Add((SupportedLanguages)result);
}
}
return list.ToArray();
});
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
{
new CodeMatch((OpCode?)OpCodes.Ldtoken, (object)typeof(SupportedLanguages), (string)null),
new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Type), "GetTypeFromHandle", new Type[1] { typeof(RuntimeTypeHandle) }, (Type[])null), (string)null),
new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Enum), "GetValues", new Type[1] { typeof(Type) }, (Type[])null), (string)null)
}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
{
matcher.RemoveInstructions(2).SetAndAdvance(del.opcode, del.operand);
}, (Action<string>)null);
return val.InstructionEnumeration();
}
[HarmonyPatch(typeof(MenuLanguageSetting), "UpdateLangsArray")]
[HarmonyPostfix]
public static void UpdateLangsArrayStrings(ref string[] ___optionList, SupportedLanguages[] ___langs)
{
___optionList = ___langs.Select(delegate(SupportedLanguages opt)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
LanguageCode val = (LanguageCode)opt;
return ((object)(LanguageCode)(ref val)).ToString();
}).ToArray();
}
}
[BepInPlugin("capitalistspz.simplesilksonglocalizer", "SimpleSilksongLocalizer", "0.1.0")]
public class SimpleSilksongLocalizerPlugin : BaseUnityPlugin
{
internal static Dictionary<string, LocalizationSettings?> ModLocalizationDirectories = new Dictionary<string, LocalizationSettings>();
internal static List<string> ModCustomSheets = new List<string>();
internal static List<LanguageCode> ModCustomLanguages = new List<LanguageCode>();
internal static Dictionary<LanguageCode, Dictionary<string, Dictionary<string, string>>> ModExtraEntries = new Dictionary<LanguageCode, Dictionary<string, Dictionary<string, string>>>();
internal static ConfigEntry<bool> EnableFallbacks;
public static ManualLogSource Logger;
private Harmony harmony;
private string[] originalSheetTitles;
public const string Id = "capitalistspz.simplesilksonglocalizer";
public static string Name => "SimpleSilksongLocalizer";
public static string Version => "0.1.0";
public void RegisterSheet(string sheetTitle)
{
ModCustomSheets.Add(sheetTitle);
}
public static void AddLocalizationDirectory(string localizationDirectory)
{
//IL_0066: Expected O, but got Unknown
DirectoryInfo directoryInfo = new DirectoryInfo(localizationDirectory);
FileInfo fileInfo = directoryInfo.EnumerateFiles("LocalizationSettings.json").FirstOrDefault();
if (fileInfo == null)
{
ModLocalizationDirectories.Add(localizationDirectory, null);
return;
}
string fullName = fileInfo.FullName;
try
{
LocalizationSettings localizationSettings = JsonConvert.DeserializeObject<LocalizationSettings>(File.ReadAllText(fullName));
if (localizationSettings != null)
{
ModLocalizationDirectories.Add(localizationDirectory, localizationSettings);
}
}
catch (JsonSerializationException val)
{
JsonSerializationException arg = val;
Logger.LogError((object)$"Failed to parse language settings at '{fullName}': {arg}");
}
catch (Exception arg2)
{
Logger.LogError((object)$"Unexpected exception: {arg2}");
}
}
public static void AddSheet(LanguageCode languageCode, string sheet, Dictionary<string, string> entries)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Dictionary<string, string> orInsertNew = ModExtraEntries.GetOrInsertNew(languageCode).GetOrInsertNew(sheet);
foreach (KeyValuePair<string, string> entry in entries)
{
entry.Deconstruct(out var key, out var value);
string key2 = key;
string value2 = value;
orInsertNew[key2] = value2;
}
}
public static void AddSheetEntry(LanguageCode languageCode, string sheet, string key, string value)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Dictionary<string, string> orInsertNew = ModExtraEntries.GetOrInsertNew(languageCode).GetOrInsertNew(sheet);
orInsertNew[key] = value;
}
private void Awake()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
harmony = new Harmony("capitalistspz.simplesilksonglocalizer");
EnableFallbacks = ((BaseUnityPlugin)this).Config.Bind<bool>("Fallbacks", "Enable", false, "Enable fallback strings for untranslated text, if the source has them enabled");
Logger.LogInfo((object)("Plugin " + Name + " (capitalistspz.simplesilksonglocalizer) has loaded!"));
}
private void FindDirectories()
{
DirectoryInfo directoryInfo = new DirectoryInfo(Paths.PluginPath);
foreach (DirectoryInfo item in directoryInfo.EnumerateDirectories("*", SearchOption.TopDirectoryOnly))
{
foreach (DirectoryInfo item2 in item.EnumerateDirectories("SSL.Localization", SearchOption.TopDirectoryOnly))
{
AddLocalizationDirectory(item2.FullName);
}
}
}
private void Start()
{
FindDirectories();
Apply();
}
private void OnEnable()
{
if (((MonoBehaviour)this).didStart && !harmony.GetPatchedMethods().Any())
{
Apply();
}
}
private void OnDisable()
{
Unapply();
}
private void Apply()
{
foreach (LocalizationSettings value in ModLocalizationDirectories.Values)
{
if (value != null)
{
if (value.CustomSheets != null)
{
ModCustomSheets.AddRange(value.CustomSheets);
}
if (value.CustomLanguages != null)
{
ModCustomLanguages.AddRange(value.CustomLanguages);
}
}
}
originalSheetTitles = Language._settings.sheetTitles;
Language._settings.sheetTitles = Language._settings.sheetTitles.Union(ModCustomSheets).ToArray();
harmony.PatchAll(typeof(LanguagePatch));
harmony.PatchAll(typeof(MenuLanguageSettingPatch));
Language.LoadAvailableLanguages();
Language.LoadLanguage();
}
private void Unapply()
{
harmony.UnpatchSelf();
Language._settings.sheetTitles = originalSheetTitles;
Language.LoadAvailableLanguages();
Language.LoadLanguage();
}
}
}
