using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using CosmeticResync.Patches;
using HarmonyLib;
using Newtonsoft.Json;
using UnityEngine;
using Zorro.Core;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("CosmeticResync")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CosmeticResync")]
[assembly: AssemblyCopyright("Copyright © BlueAmulet 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("eb3c5a88-48ff-431d-9961-15eee8223f66")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace CosmeticResync
{
[BepInPlugin("BlueAmulet.CosmeticResync", "CosmeticResync", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class CosmeticResync : BaseUnityPlugin
{
internal const string Name = "CosmeticResync";
internal const string Author = "BlueAmulet";
internal const string ID = "BlueAmulet.CosmeticResync";
internal const string Version = "1.0.0";
internal static ManualLogSource Logger;
public void Awake()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Expected O, but got Unknown
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
Harmony val = new Harmony("BlueAmulet.CosmeticResync");
Logger.LogInfo((object)"Applying Harmony patches");
val.PatchAll(Assembly.GetExecutingAssembly());
if (Chainloader.PluginInfos.TryGetValue("com.github.Spider-XD-Gaming.Multi-Cosmetic", out var value))
{
MultiCosmeticPatch.MultiCosmetic = value.Instance;
if (MultiCosmeticPatch.GetCurrentDataField())
{
Type type = ((object)value.Instance).GetType();
MethodInfo methodInfo = AccessTools.Method(type, "dataFromString", (Type[])null, (Type[])null);
if (methodInfo != null)
{
val.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(MultiCosmeticPatch), "PrefixMCDataFromString", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
else
{
Logger.LogError((object)"Failed to find Multi_Cosmetic.Plugin.dataFromString()");
}
methodInfo = AccessTools.Method(type, "UpdateCustomPropertiesValue", (Type[])null, (Type[])null);
if (methodInfo != null)
{
val.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(MultiCosmeticPatch), "PostfixUpdateCustomPropertiesValue", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
else
{
Logger.LogError((object)"Failed to find Multi_Cosmetic.Plugin.UpdateCustomPropertiesValue()");
}
}
}
int num = 0;
foreach (MethodBase patchedMethod in val.GetPatchedMethods())
{
Logger.LogInfo((object)("Patched " + patchedMethod.DeclaringType.FullName + "." + patchedMethod.Name));
num++;
}
Logger.LogInfo((object)(num + " patches applied"));
}
}
}
namespace CosmeticResync.Patches
{
[HarmonyPatch(typeof(CharacterCustomization))]
internal static class CosmeticPatch
{
[HarmonyPrefix]
[HarmonyPatch("TryGetCosmeticsFromSteam")]
private static bool PrefixTryGetCosmeticsFromSteam(ref CharacterCustomization __instance)
{
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized? Cannot Resync cosmetics");
return true;
}
int cosmeticFromPrefsOrSteam = GetCosmeticFromPrefsOrSteam("CosmeticResync_Skin", (STEAMSTATTYPE)7, instance.skins);
if (cosmeticFromPrefsOrSteam > 0)
{
CharacterCustomization.SetCharacterSkinColor(cosmeticFromPrefsOrSteam);
}
else
{
__instance.SetRandomSkinColor();
}
int cosmeticFromPrefsOrSteam2 = GetCosmeticFromPrefsOrSteam("CosmeticResync_Eyes", (STEAMSTATTYPE)8, instance.eyes);
if (cosmeticFromPrefsOrSteam2 > 0)
{
CharacterCustomization.SetCharacterEyes(cosmeticFromPrefsOrSteam2);
}
else
{
__instance.SetRandomEyes();
}
int cosmeticFromPrefsOrSteam3 = GetCosmeticFromPrefsOrSteam("CosmeticResync_Mouth", (STEAMSTATTYPE)9, instance.mouths);
if (cosmeticFromPrefsOrSteam3 > 0)
{
CharacterCustomization.SetCharacterMouth(cosmeticFromPrefsOrSteam3);
}
else
{
__instance.SetRandomMouth();
}
int cosmeticFromPrefsOrSteam4 = GetCosmeticFromPrefsOrSteam("CosmeticResync_Accessory", (STEAMSTATTYPE)10, instance.accessories);
if (cosmeticFromPrefsOrSteam4 > 0)
{
CharacterCustomization.SetCharacterAccessory(cosmeticFromPrefsOrSteam4);
}
else
{
__instance.SetRandomAccessory();
}
int cosmeticFromPrefsOrSteam5 = GetCosmeticFromPrefsOrSteam("CosmeticResync_Outfit", (STEAMSTATTYPE)11, instance.fits);
if (cosmeticFromPrefsOrSteam5 > 0)
{
CharacterCustomization.SetCharacterOutfit(cosmeticFromPrefsOrSteam5);
}
else
{
__instance.SetRandomOutfit();
}
int cosmeticFromPrefsOrSteam6 = GetCosmeticFromPrefsOrSteam("CosmeticResync_Hat", (STEAMSTATTYPE)12, instance.hats);
if (cosmeticFromPrefsOrSteam6 > 0)
{
CharacterCustomization.SetCharacterHat(cosmeticFromPrefsOrSteam6);
}
else
{
__instance.SetRandomHat();
}
int cosmeticFromPrefsOrSteam7 = GetCosmeticFromPrefsOrSteam("CosmeticResync_Sash", (STEAMSTATTYPE)17, instance.sashes);
if (cosmeticFromPrefsOrSteam7 > 0)
{
CharacterCustomization.SetCharacterSash(cosmeticFromPrefsOrSteam7);
}
else
{
CharacterCustomization.SetCharacterSash(0);
}
return false;
}
[HarmonyPostfix]
[HarmonyPatch("SetCharacterSkinColor")]
private static void PostfixSetCharacterSkinColor(int index)
{
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized? Cannot save skin color");
}
else
{
ValidateAndSaveCosmetic(index, "CosmeticResync_Skin", instance.skins);
}
}
[HarmonyPostfix]
[HarmonyPatch("SetCharacterEyes")]
private static void PostfixSetCharacterEyes(int index)
{
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized? Cannot save eyes");
}
else
{
ValidateAndSaveCosmetic(index, "CosmeticResync_Eyes", instance.eyes);
}
}
[HarmonyPostfix]
[HarmonyPatch("SetCharacterMouth")]
private static void PostfixSetCharacterMouth(int index)
{
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized? Cannot save mouth");
}
else
{
ValidateAndSaveCosmetic(index, "CosmeticResync_Mouth", instance.mouths);
}
}
[HarmonyPostfix]
[HarmonyPatch("SetCharacterAccessory")]
private static void PostfixSetCharacterAccessory(int index)
{
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized? Cannot save accessory name");
}
else
{
ValidateAndSaveCosmetic(index, "CosmeticResync_Accessory", instance.accessories);
}
}
[HarmonyPostfix]
[HarmonyPatch("SetCharacterOutfit")]
private static void PostfixSetCharacterOutfit(int index)
{
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized? Cannot save outfit name");
}
else
{
ValidateAndSaveCosmetic(index, "CosmeticResync_Outfit", instance.fits);
}
}
[HarmonyPostfix]
[HarmonyPatch("SetCharacterHat")]
private static void PostfixSetCharacterHat(int index)
{
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized? Cannot save hat name");
}
else
{
ValidateAndSaveCosmetic(index, "CosmeticResync_Hat", instance.hats);
}
}
[HarmonyPostfix]
[HarmonyPatch("SetCharacterSash")]
private static void PostfixSetCharacterSash(int index)
{
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized? Cannot save sash name");
}
else
{
ValidateAndSaveCosmetic(index, "CosmeticResync_Sash", instance.sashes);
}
}
private static int GetCosmeticFromPrefsOrSteam(string prefKey, STEAMSTATTYPE steamStatType, CustomizationOption[] options)
{
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: 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)
int num = -1;
if (PlayerPrefs.HasKey(prefKey))
{
string @string = PlayerPrefs.GetString(prefKey);
if (!string.IsNullOrWhiteSpace(@string))
{
for (int i = 0; i < options.Length; i++)
{
if (((Object)options[i]).name == @string)
{
num = i;
break;
}
}
if (num != -1)
{
Debug.Log((object)$"[CosmeticResync] Detected {steamStatType} {@string} as #{num}");
}
else
{
CosmeticResync.Logger.LogWarning((object)$"{steamStatType} {@string} is no longer available, picking a random option");
}
}
}
else if (Singleton<AchievementManager>.Instance.GetSteamStatInt(steamStatType, ref num))
{
if (num >= options.Length)
{
num = -1;
}
}
else
{
num = -1;
}
return num;
}
private static void ValidateAndSaveCosmetic(int index, string prefKey, CustomizationOption[] options)
{
if (index < 0 || index >= options.Length)
{
CosmeticResync.Logger.LogError((object)$"Customization index #{index} invalid? Cannot save customization for {prefKey}");
}
else
{
PlayerPrefs.SetString(prefKey, ((Object)options[index]).name);
}
}
}
[HarmonyPatch]
internal static class MultiCosmeticPatch
{
internal static BaseUnityPlugin MultiCosmetic;
private static FieldInfo _currentData;
internal static bool GetCurrentDataField()
{
if ((Object)(object)MultiCosmetic == (Object)null)
{
CosmeticResync.Logger.LogError((object)"Missing MultiCosmetic instance");
return false;
}
FieldInfo fieldInfo = AccessTools.Field(((object)MultiCosmetic).GetType(), "currentData");
if (fieldInfo == null)
{
CosmeticResync.Logger.LogError((object)"MultiCosmetic missing currentData field");
return false;
}
if (fieldInfo.FieldType != typeof(int[][]))
{
CosmeticResync.Logger.LogError((object)"MultiCosmetic.currentData is no longer an int[][]");
return false;
}
_currentData = fieldInfo;
return true;
}
internal static bool PrefixMCDataFromString()
{
if ((Object)(object)MultiCosmetic == (Object)null)
{
CosmeticResync.Logger.LogError((object)"Missing MultiCosmetic instance, cannot resync MultiCosmetic");
return true;
}
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized, cannot resync MultiCosmetic");
return true;
}
if (!PlayerPrefs.HasKey("CosmeticResync_MultiCosmetic"))
{
return true;
}
string @string = PlayerPrefs.GetString("CosmeticResync_MultiCosmetic");
if (string.IsNullOrWhiteSpace(@string))
{
CosmeticResync.Logger.LogWarning((object)"CosmeticResync_MultiCosmetic has no data, nothing to resync");
return true;
}
try
{
string[][] array = JsonConvert.DeserializeObject<string[][]>(@string);
if (array.Length != 2)
{
CosmeticResync.Logger.LogWarning((object)$"CosmeticResync_MultiCosmetic is malformed, expected 2 arrays, got {array.Length}");
return true;
}
int[] cosmeticIndices = GetCosmeticIndices(instance.accessories, array[0], "Accessory");
int[] cosmeticIndices2 = GetCosmeticIndices(instance.hats, array[1], "Hat");
CosmeticResync.Logger.LogInfo((object)$"Loaded {cosmeticIndices.Length} accessories and {cosmeticIndices2.Length} hats");
_currentData.SetValue(MultiCosmetic, new int[2][] { cosmeticIndices, cosmeticIndices2 });
return false;
}
catch (JsonException)
{
CosmeticResync.Logger.LogWarning((object)"Failed to deserialize CosmeticResync_MultiCosmetic");
return true;
}
}
internal static void PostfixUpdateCustomPropertiesValue()
{
if ((Object)(object)MultiCosmetic == (Object)null)
{
CosmeticResync.Logger.LogError((object)"Missing MultiCosmetic instance? Cannot save MultiCosmetic names");
return;
}
Customization instance = Singleton<Customization>.Instance;
if (!Object.op_Implicit((Object)(object)instance))
{
CosmeticResync.Logger.LogError((object)"Customization not initialized? Cannot save MultiCosmetic names");
return;
}
int[][] array = (int[][])_currentData.GetValue(MultiCosmetic);
if (array.Length != 2)
{
CosmeticResync.Logger.LogError((object)$"Expected MultiCosmetic.Plugin.currentData to contain 2 int[], not {array.Length}");
return;
}
string[] cosmeticNames = GetCosmeticNames(instance.accessories, array[0], "Accessory");
string[] cosmeticNames2 = GetCosmeticNames(instance.hats, array[1], "Hat");
string text = JsonConvert.SerializeObject((object)new string[2][] { cosmeticNames, cosmeticNames2 });
PlayerPrefs.SetString("CosmeticResync_MultiCosmetic", text);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PassportManager), "Awake")]
internal static void Awake(PassportManager __instance)
{
Customization component = ((Component)__instance).GetComponent<Customization>();
if (Object.op_Implicit((Object)(object)component))
{
Singleton<Customization>._instance = component;
CosmeticResync.Logger.LogInfo((object)"Manually updating MultiCosmetic");
PrefixMCDataFromString();
}
else
{
CosmeticResync.Logger.LogError((object)"PassportManager not with Customization? Cannot resync MultiCosmetic");
}
}
private static int[] GetCosmeticIndices(CustomizationOption[] options, string[] names, string cosmeticType)
{
Dictionary<string, int> dictionary = new Dictionary<string, int>(0);
for (int i = 0; i < options.Length; i++)
{
CustomizationOption val = options[i];
dictionary[((Object)val).name] = i;
}
List<int> list = new List<int>();
foreach (string text in names)
{
if (dictionary.TryGetValue(text, out var value))
{
list.Add(value);
}
else
{
CosmeticResync.Logger.LogWarning((object)(cosmeticType + " " + text + " is no longer available"));
}
}
return list.ToArray();
}
private static string[] GetCosmeticNames(CustomizationOption[] options, int[] indices, string cosmeticType)
{
List<string> list = new List<string>();
int num = options.Length;
foreach (int num2 in indices)
{
if (num2 >= 0 && num2 < num)
{
list.Add(((Object)options[num2]).name);
}
else
{
CosmeticResync.Logger.LogWarning((object)$"{cosmeticType} #{num2} is out of range");
}
}
return list.ToArray();
}
}
}
