using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using GWYF_NewClothing.Patches;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.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 GWYF_NewClothing
{
internal static class AssetBundleLoader
{
public static GameObject LoadModel(string bundlePath, string assetName)
{
try
{
if (!File.Exists(bundlePath))
{
Debug.LogError((object)("[GWYF] Bundle file not found: " + bundlePath));
return null;
}
AssetBundle val = AssetBundle.LoadFromFile(bundlePath);
if ((Object)(object)val == (Object)null)
{
Debug.LogError((object)("[GWYF] Failed to load bundle: " + bundlePath));
return null;
}
GameObject val2 = val.LoadAsset<GameObject>(assetName);
val.Unload(false);
if ((Object)(object)val2 == (Object)null)
{
Debug.LogError((object)("[GWYF] Asset '" + assetName + "' not found in bundle: " + bundlePath));
return null;
}
GameObject obj = Object.Instantiate<GameObject>(val2);
((Object)obj).hideFlags = (HideFlags)61;
obj.SetActive(false);
Object.DontDestroyOnLoad((Object)(object)obj);
return obj;
}
catch (Exception ex)
{
Debug.LogError((object)("[GWYF] Bundle load failed: " + bundlePath + " — " + ex.Message));
return null;
}
}
}
public static class CosmeticRegistry
{
private static CosmeticData[] _allCosmetics = Array.Empty<CosmeticData>();
private static readonly List<CosmeticEntry> _pendingVanilla = new List<CosmeticEntry>();
private static int _nextId;
private static readonly List<string> _registeredDirs = new List<string>();
private static string _lastModelsDir = "";
private static string _lastTexDir = "";
private static string _lastBundlesDir = "";
public static CosmeticData[] AllCosmetics
{
get
{
ResolvePending();
return _allCosmetics;
}
}
public static void RegisterFrom(string pluginDir)
{
if (string.IsNullOrEmpty(pluginDir) || _registeredDirs.Contains(pluginDir))
{
return;
}
_registeredDirs.Add(pluginDir);
string path = Path.Combine(pluginDir, "cosmetics.json");
if (!File.Exists(path))
{
Debug.Log((object)("[MoreCosmetics] No cosmetics.json in " + pluginDir + ", skipping."));
return;
}
try
{
List<CosmeticEntry> list = ParseFromJson(File.ReadAllText(path));
string text = Path.Combine(pluginDir, "models");
string text2 = Path.Combine(pluginDir, "textures");
string text3 = Path.Combine(pluginDir, "bundles");
try
{
Directory.CreateDirectory(text);
}
catch
{
}
try
{
Directory.CreateDirectory(text2);
}
catch
{
}
try
{
Directory.CreateDirectory(text3);
}
catch
{
}
List<CosmeticData> list2 = new List<CosmeticData>();
foreach (CosmeticEntry item in list)
{
CosmeticData val = CreateCosmetic(item, list2.Count, text, text2, text3);
if ((Object)(object)val != (Object)null)
{
list2.Add(val);
}
else if (item != null && (item.model?.IsVanilla).GetValueOrDefault())
{
_pendingVanilla.Add(item);
}
}
if (_allCosmetics.Length == 0)
{
_allCosmetics = list2.ToArray();
}
else
{
List<CosmeticData> list3 = new List<CosmeticData>(_allCosmetics);
list3.AddRange(list2);
_allCosmetics = list3.ToArray();
}
Debug.Log((object)$"[MoreCosmetics] Registered {list2.Count} cosmetics from {Path.GetFileName(pluginDir)}");
if (_pendingVanilla.Count > 0)
{
Debug.Log((object)$"[MoreCosmetics] {_pendingVanilla.Count} vanilla-model entries deferred (not in cache yet)");
}
}
catch (Exception ex)
{
Debug.LogError((object)("[MoreCosmetics] Failed to register cosmetics from " + pluginDir + ": " + ex.Message));
}
}
internal static void ResolvePending()
{
if (_pendingVanilla.Count == 0 || !IsCacheReady())
{
return;
}
List<CosmeticData> list = new List<CosmeticData>();
List<CosmeticEntry> list2 = new List<CosmeticEntry>();
foreach (CosmeticEntry item in _pendingVanilla)
{
CosmeticData val = CreateCosmetic(item, list.Count, _lastModelsDir, _lastTexDir, _lastBundlesDir);
if ((Object)(object)val != (Object)null)
{
list.Add(val);
}
else
{
list2.Add(item);
}
}
if (list.Count > 0)
{
List<CosmeticData> list3 = new List<CosmeticData>(_allCosmetics);
list3.AddRange(list);
_allCosmetics = list3.ToArray();
}
_pendingVanilla.Clear();
_pendingVanilla.AddRange(list2);
}
private static bool IsCacheReady()
{
try
{
object obj = typeof(CosmeticDataManager).GetField("_isInitialized", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null);
return obj is bool && (bool)obj;
}
catch
{
return false;
}
}
private static CosmeticData? CreateCosmetic(CosmeticEntry entry, int index, string modelsDir, string texturesDir, string bundlesDir)
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Expected O, but got Unknown
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
//IL_019c: Unknown result type (might be due to invalid IL or missing references)
//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
_lastModelsDir = modelsDir;
_lastTexDir = texturesDir;
_lastBundlesDir = bundlesDir;
if (string.IsNullOrEmpty(entry.name) || string.IsNullOrEmpty(entry.type))
{
return null;
}
if (!Enum.TryParse<CosmeticType>(entry.type, ignoreCase: true, out CosmeticType result))
{
return null;
}
CosmeticRarity result2 = (CosmeticRarity)0;
if (!string.IsNullOrEmpty(entry.rarity))
{
Enum.TryParse<CosmeticRarity>(entry.rarity, ignoreCase: true, out result2);
}
if (entry.model == null)
{
return null;
}
GameObject val = ResolveModel(entry, modelsDir, bundlesDir);
if ((Object)(object)val == (Object)null)
{
return null;
}
Material val2 = new Material(Shader.Find((!string.IsNullOrEmpty(entry.shader)) ? entry.shader : "01_GWYF/GlobalShader") ?? Shader.Find("Standard") ?? Shader.Find("Diffuse"));
((Object)val2).name = entry.name + "_Mat";
if (!string.IsNullOrEmpty(entry.texture))
{
Texture2D val3 = TextureLoader.Load(Path.Combine(texturesDir, entry.texture));
if ((Object)(object)val3 != (Object)null)
{
val2.SetTexture("_MainTex", (Texture)(object)val3);
val2.SetTexture("_BaseMap", (Texture)(object)val3);
val2.color = Color.white;
}
else
{
val2.color = GetTintColor(entry.tint);
}
}
else
{
val2.color = GetTintColor(entry.tint);
}
CosmeticData obj = ScriptableObject.CreateInstance<CosmeticData>();
((Object)obj).name = entry.name;
obj.cosmeticId = PluginConfig.CosmeticIdStart.Value + _nextId++;
obj.cosmeticName = entry.name;
obj.description = entry.description ?? "";
obj.cosmeticType = result;
obj.rarity = result2;
obj.cosmeticModel = val;
obj.cosmeticMaterial = val2;
return obj;
}
private static GameObject? ResolveModel(CosmeticEntry entry, string modelsDir, string bundlesDir)
{
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Expected O, but got Unknown
if (entry.model.IsVanilla)
{
return CloneVanillaModel(entry.model.vanilla);
}
if (entry.model.IsObj)
{
Mesh val = ObjImporter.Import(Path.Combine(modelsDir, entry.model.obj));
if ((Object)(object)val == (Object)null)
{
return null;
}
GameObject val2 = new GameObject(entry.name + "_Model")
{
hideFlags = (HideFlags)61
};
Object.DontDestroyOnLoad((Object)val2);
val2.AddComponent<MeshFilter>().sharedMesh = val;
val2.AddComponent<MeshRenderer>();
return val2;
}
if (entry.model.IsBundle)
{
return AssetBundleLoader.LoadModel(Path.Combine(bundlesDir, entry.model.bundle), entry.model.asset);
}
return null;
}
private static GameObject? CloneVanillaModel(string cosmeticName)
{
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Expected O, but got Unknown
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Expected O, but got Unknown
try
{
if (!(typeof(CosmeticDataManager).GetField("_cosmeticCache", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null) is Dictionary<int, CosmeticData> dictionary))
{
return null;
}
foreach (KeyValuePair<int, CosmeticData> item in dictionary)
{
CosmeticData value = item.Value;
if (!((Object)(object)value == (Object)null) && !((Object)(object)value.cosmeticModel == (Object)null) && string.Equals(value.cosmeticName, cosmeticName, StringComparison.OrdinalIgnoreCase))
{
MeshFilter component = value.cosmeticModel.GetComponent<MeshFilter>();
if (!((Object)(object)component == (Object)null) && !((Object)(object)component.sharedMesh == (Object)null))
{
GameObject val = new GameObject(cosmeticName + "_Clone")
{
hideFlags = (HideFlags)61
};
Object.DontDestroyOnLoad((Object)val);
val.AddComponent<MeshFilter>().sharedMesh = Object.Instantiate<Mesh>(component.sharedMesh);
val.AddComponent<MeshRenderer>();
return val;
}
}
}
return null;
}
catch
{
return null;
}
}
private static Color GetTintColor(float[] tint)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
if (tint == null || tint.Length < 3)
{
return Color.white;
}
return new Color(Mathf.Clamp01(tint[0]), Mathf.Clamp01(tint[1]), Mathf.Clamp01(tint[2]));
}
private static List<CosmeticEntry> ParseFromJson(string json)
{
List<CosmeticEntry> list = new List<CosmeticEntry>();
try
{
json = json.Trim();
if (json.StartsWith("{"))
{
if (!TinyJson.ParseObject(json).TryGetValue("cosmetics", out object value) || !(value is string text))
{
return list;
}
json = text.Trim();
}
if (!json.StartsWith("["))
{
return list;
}
foreach (Dictionary<string, object> item in TinyJson.ParseArray(json))
{
CosmeticEntry cosmeticEntry = new CosmeticEntry();
if (item.TryGetValue("name", out var value2) && value2 is string name)
{
cosmeticEntry.name = name;
}
if (item.TryGetValue("type", out var value3) && value3 is string type)
{
cosmeticEntry.type = type;
}
if (item.TryGetValue("rarity", out var value4) && value4 is string rarity)
{
cosmeticEntry.rarity = rarity;
}
if (item.TryGetValue("description", out var value5) && value5 is string description)
{
cosmeticEntry.description = description;
}
if (item.TryGetValue("texture", out var value6) && value6 is string texture)
{
cosmeticEntry.texture = texture;
}
if (item.TryGetValue("shader", out var value7) && value7 is string shader)
{
cosmeticEntry.shader = shader;
}
if (item.TryGetValue("tint", out var value8))
{
if (value8 is float[] tint)
{
cosmeticEntry.tint = tint;
}
else if (value8 is List<float> list2)
{
cosmeticEntry.tint = list2.ToArray();
}
}
if (item.TryGetValue("model", out var value9))
{
cosmeticEntry.model = new ModelRef();
if (value9 is string vanilla)
{
cosmeticEntry.model.vanilla = vanilla;
}
else if (value9 is Dictionary<string, object> dictionary)
{
if (dictionary.TryGetValue("vanilla", out var value10) && value10 is string vanilla2)
{
cosmeticEntry.model.vanilla = vanilla2;
}
if (dictionary.TryGetValue("obj", out var value11) && value11 is string obj)
{
cosmeticEntry.model.obj = obj;
}
if (dictionary.TryGetValue("bundle", out var value12) && value12 is string bundle)
{
cosmeticEntry.model.bundle = bundle;
}
if (dictionary.TryGetValue("asset", out var value13) && value13 is string asset)
{
cosmeticEntry.model.asset = asset;
}
}
}
if (!string.IsNullOrEmpty(cosmeticEntry.name))
{
list.Add(cosmeticEntry);
}
}
}
catch (Exception ex)
{
Debug.LogError((object)("[MoreCosmetics] JSON parse error: " + ex.Message));
}
return list;
}
}
[Serializable]
public class CosmeticEntry
{
public string name;
public string type;
public string rarity;
public string description;
public ModelRef model;
public string texture;
public float[] tint;
public string shader;
}
[Serializable]
public class ModelRef
{
public string vanilla;
public string obj;
public string bundle;
public string asset;
public bool IsVanilla => !string.IsNullOrEmpty(vanilla);
public bool IsObj => !string.IsNullOrEmpty(obj);
public bool IsBundle => !string.IsNullOrEmpty(bundle);
}
internal static class ObjImporter
{
private readonly struct VertexTriplet
{
public readonly int posIndex;
public readonly int uvIndex;
public readonly int nrmIndex;
public VertexTriplet(int pos, int uv, int nrm)
{
posIndex = pos;
uvIndex = uv;
nrmIndex = nrm;
}
public override bool Equals(object obj)
{
if (obj is VertexTriplet vertexTriplet && posIndex == vertexTriplet.posIndex && uvIndex == vertexTriplet.uvIndex)
{
return nrmIndex == vertexTriplet.nrmIndex;
}
return false;
}
public override int GetHashCode()
{
return HashCode.Combine(posIndex, uvIndex, nrmIndex);
}
}
public static Mesh Import(string path)
{
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
//IL_01f7: Expected O, but got Unknown
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
if (!File.Exists(path))
{
Debug.LogError((object)("[GWYF] OBJ file not found: " + path));
return null;
}
string[] array = File.ReadAllLines(path);
List<Vector3> list = new List<Vector3>();
List<Vector2> list2 = new List<Vector2>();
List<Vector3> list3 = new List<Vector3>();
List<VertexTriplet> list4 = new List<VertexTriplet>();
List<(int, int, int)> list5 = new List<(int, int, int)>();
string[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
string text = array2[i].Trim();
if (text.Length == 0 || text[0] == '#')
{
continue;
}
string[] array3 = text.Split(new char[2] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (array3.Length >= 2)
{
switch (array3[0])
{
case "v":
list.Add(ParseVector3(array3, 1));
break;
case "vt":
list2.Add(ParseVector2(array3, 1));
break;
case "vn":
list3.Add(ParseVector3(array3, 1));
break;
case "f":
ParseFace(array3, list4, list5);
break;
}
}
}
Dictionary<VertexTriplet, int> dict = new Dictionary<VertexTriplet, int>();
List<Vector3> list6 = new List<Vector3>();
List<Vector2> list7 = new List<Vector2>();
List<Vector3> list8 = new List<Vector3>();
List<int> list9 = new List<int>();
foreach (var item4 in list5)
{
int item = item4.Item1;
int item2 = item4.Item2;
int item3 = item4.Item3;
VertexTriplet vt = list4[item];
VertexTriplet vt2 = list4[item2];
VertexTriplet vt3 = list4[item3];
list9.Add(GetOrAdd(vt, dict, list6, list7, list8, list, list2, list3));
list9.Add(GetOrAdd(vt2, dict, list6, list7, list8, list, list2, list3));
list9.Add(GetOrAdd(vt3, dict, list6, list7, list8, list, list2, list3));
}
Mesh val = new Mesh();
((Object)val).name = Path.GetFileNameWithoutExtension(path);
val.indexFormat = (IndexFormat)(list6.Count > 65535);
val.SetVertices(list6);
val.SetTriangles(list9, 0);
if (list7.Count == list6.Count)
{
val.SetUVs(0, list7);
}
if (list8.Count == list6.Count)
{
val.SetNormals(list8);
}
else
{
val.RecalculateNormals();
}
val.RecalculateBounds();
val.RecalculateTangents();
Debug.Log((object)$"[GWYF] Imported OBJ '{Path.GetFileName(path)}': {list6.Count} verts, {list9.Count / 3} tris.");
return val;
}
private static int GetOrAdd(VertexTriplet vt, Dictionary<VertexTriplet, int> dict, List<Vector3> verts, List<Vector2> uvs, List<Vector3> norms, List<Vector3> posSrc, List<Vector2> uvSrc, List<Vector3> nrmSrc)
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
if (dict.TryGetValue(vt, out var value))
{
return value;
}
int result = (dict[vt] = verts.Count);
verts.Add((vt.posIndex > 0 && vt.posIndex <= posSrc.Count) ? posSrc[vt.posIndex - 1] : Vector3.zero);
if (vt.uvIndex > 0 && vt.uvIndex <= uvSrc.Count)
{
uvs.Add(uvSrc[vt.uvIndex - 1]);
}
if (vt.nrmIndex > 0 && vt.nrmIndex <= nrmSrc.Count)
{
norms.Add(nrmSrc[vt.nrmIndex - 1]);
}
return result;
}
private static Vector3 ParseVector3(string[] parts, int start)
{
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
float result = 0f;
float result2 = 0f;
float result3 = 0f;
if (parts.Length > start)
{
float.TryParse(parts[start], NumberStyles.Float, CultureInfo.InvariantCulture, out result);
}
if (parts.Length > start + 1)
{
float.TryParse(parts[start + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out result2);
}
if (parts.Length > start + 2)
{
float.TryParse(parts[start + 2], NumberStyles.Float, CultureInfo.InvariantCulture, out result3);
}
return new Vector3(result, result2, result3);
}
private static Vector2 ParseVector2(string[] parts, int start)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
float result = 0f;
float result2 = 0f;
if (parts.Length > start)
{
float.TryParse(parts[start], NumberStyles.Float, CultureInfo.InvariantCulture, out result);
}
if (parts.Length > start + 1)
{
float.TryParse(parts[start + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out result2);
}
return new Vector2(result, result2);
}
private static void ParseFace(string[] parts, List<VertexTriplet> vertices, List<(int, int, int)> faces)
{
List<int> list = new List<int>();
for (int i = 1; i < parts.Length; i++)
{
list.Add(vertices.Count);
vertices.Add(ParseVertexTriplet(parts[i]));
}
for (int j = 1; j < list.Count - 1; j++)
{
faces.Add((list[0], list[j], list[j + 1]));
}
}
private static VertexTriplet ParseVertexTriplet(string part)
{
string[] array = part.Split('/');
int result = 0;
int result2 = 0;
int result3 = 0;
if (array.Length != 0)
{
int.TryParse(array[0], out result);
}
if (array.Length > 1 && !string.IsNullOrEmpty(array[1]))
{
int.TryParse(array[1], out result2);
}
if (array.Length > 2)
{
int.TryParse(array[2], out result3);
}
return new VertexTriplet(result, result2, result3);
}
}
[BepInPlugin("com.morecosmetics.injector", "More Cosmetics", "0.2.0")]
public class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "com.morecosmetics.injector";
public const string PluginName = "More Cosmetics";
public const string PluginVersion = "0.2.0";
internal static Plugin Instance { get; private set; }
private void Awake()
{
Instance = this;
try
{
PluginConfig.Bind(((BaseUnityPlugin)this).Config);
if (!PluginConfig.Enabled.Value)
{
return;
}
string item = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location) ?? Path.Combine(Paths.PluginPath, "More-Cosmetics");
HashSet<string> hashSet = new HashSet<string> { item };
if (PluginConfig.AutoDiscover.Value)
{
string pluginPath = Paths.PluginPath;
if (Directory.Exists(pluginPath))
{
string[] directories = Directory.GetDirectories(pluginPath);
foreach (string text in directories)
{
if (File.Exists(Path.Combine(text, "cosmetics.json")))
{
hashSet.Add(text);
}
}
}
}
Debug.Log((object)$"[MoreCosmetics] Scanning {hashSet.Count} directories for cosmetics...");
foreach (string item2 in hashSet)
{
if (File.Exists(Path.Combine(item2, "cosmetics.json")))
{
CosmeticRegistry.RegisterFrom(item2);
}
}
Harmony.CreateAndPatchAll(typeof(Plugin).Assembly, (string)null);
CosmeticDataManagerPatches.InjectCustomCosmeticsOnce();
((BaseUnityPlugin)this).Logger.LogInfo((object)"More Cosmetics 0.2.0 loaded.");
}
catch (Exception arg)
{
((BaseUnityPlugin)this).Logger.LogError((object)string.Format("{0} failed: {1}", "More Cosmetics", arg));
}
}
}
internal static class PluginConfig
{
public static ConfigEntry<bool> Enabled { get; private set; }
public static ConfigEntry<bool> AutoDiscover { get; private set; }
public static ConfigEntry<bool> AutoUnlockModCosmetics { get; private set; }
public static ConfigEntry<int> CosmeticIdStart { get; private set; }
public static void Bind(ConfigFile config)
{
Enabled = config.Bind<bool>("General", "Enabled", true, "Globally enables or disables the library and all loaded cosmetics.");
AutoDiscover = config.Bind<bool>("General", "AutoDiscover", true, "When true, automatically scans all plugin folders for cosmetics.json files.");
AutoUnlockModCosmetics = config.Bind<bool>("General", "AutoUnlockModCosmetics", true, "When true, all loaded cosmetics are automatically unlocked on game start.");
CosmeticIdStart = config.Bind<int>("General", "CosmeticIdStart", 10000, "Starting ID for auto-assigned cosmetic IDs.");
}
}
internal static class TextureLoader
{
public static Texture2D Load(string path)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
if (!File.Exists(path))
{
Debug.LogError((object)("[GWYF] Texture file not found: " + path));
return null;
}
byte[] array = File.ReadAllBytes(path);
Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
if (!ImageConversion.LoadImage(val, array))
{
Debug.LogError((object)("[GWYF] Failed to load texture: " + path));
Object.Destroy((Object)(object)val);
return null;
}
((Texture)val).filterMode = (FilterMode)0;
((Texture)val).wrapMode = (TextureWrapMode)1;
return val;
}
}
internal static class TinyJson
{
public static List<Dictionary<string, object>> ParseArray(string json)
{
List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();
json = json.Trim();
if (!json.StartsWith("[") || !json.EndsWith("]"))
{
return list;
}
int num = 0;
int num2 = 0;
bool flag = false;
for (int i = 1; i < json.Length - 1; i++)
{
char c = json[i];
if (c == '"' && (i == 0 || json[i - 1] != '\\'))
{
flag = !flag;
}
if (flag)
{
continue;
}
switch (c)
{
case '{':
num++;
break;
case '}':
num--;
break;
case ',':
if (num == 0)
{
Dictionary<string, object> dictionary = ParseObject(json.Substring(num2 + 1, i - num2 - 1));
if (dictionary != null)
{
list.Add(dictionary);
}
num2 = i;
}
break;
}
}
if (num2 + 1 < json.Length - 1)
{
Dictionary<string, object> dictionary2 = ParseObject(json.Substring(num2 + 1, json.Length - num2 - 2));
if (dictionary2 != null)
{
list.Add(dictionary2);
}
}
return list;
}
public static Dictionary<string, object> ParseObject(string segment)
{
Dictionary<string, object> dictionary = new Dictionary<string, object>();
segment = segment.Trim();
if (!segment.StartsWith("{") || !segment.EndsWith("}"))
{
return dictionary;
}
int i = 1;
while (i < segment.Length - 1)
{
SkipWhitespace(segment, ref i);
if (i >= segment.Length - 1)
{
break;
}
string text = ReadString(segment, ref i);
SkipWhitespace(segment, ref i);
if (i >= segment.Length - 1 || segment[i] != ':')
{
break;
}
i++;
SkipWhitespace(segment, ref i);
object value = ReadValue(segment, ref i);
if (text != null)
{
dictionary[text] = value;
}
SkipWhitespace(segment, ref i);
if (i < segment.Length - 1 && segment[i] == ',')
{
i++;
}
}
return dictionary;
}
private static object ReadValue(string s, ref int i)
{
SkipWhitespace(s, ref i);
if (i >= s.Length)
{
return null;
}
if (s[i] == '"')
{
return ReadString(s, ref i);
}
if (s[i] == '{')
{
return ParseObject(ReadBraced(s, ref i));
}
if (s[i] == '[')
{
return ReadArray(s, ref i);
}
return ReadLiteral(s, ref i);
}
private static string ReadString(string s, ref int i)
{
if (i >= s.Length || s[i] != '"')
{
return "";
}
int num = ++i;
while (i < s.Length)
{
if (s[i] == '\\')
{
i += 2;
continue;
}
if (s[i] == '"')
{
break;
}
i++;
}
string result = s.Substring(num, i - num);
i++;
return result;
}
private static string ReadBraced(string s, ref int i)
{
if (i >= s.Length || s[i] != '{')
{
return "{}";
}
int num = i;
int num2 = 0;
bool flag = false;
while (i < s.Length)
{
char c = s[i];
if (c == '"' && (i == 0 || s[i - 1] != '\\'))
{
flag = !flag;
}
if (!flag)
{
if (c == '{')
{
num2++;
}
else if (c == '}')
{
num2--;
i++;
if (num2 == 0)
{
break;
}
continue;
}
}
i++;
}
return s.Substring(num, i - num);
}
private static object ReadArray(string s, ref int i)
{
if (i >= s.Length || s[i] != '[')
{
return Array.Empty<float>();
}
List<float> list = new List<float>();
i++;
while (i < s.Length && s[i] != ']')
{
SkipWhitespace(s, ref i);
if (i < s.Length && s[i] != ']' && ReadLiteral(s, ref i) is float item)
{
list.Add(item);
}
SkipWhitespace(s, ref i);
if (i < s.Length && s[i] == ',')
{
i++;
}
}
if (i < s.Length && s[i] == ']')
{
i++;
}
return list.ToArray();
}
private static object ReadLiteral(string s, ref int i)
{
int num = i;
while (i < s.Length && !IsDelimiter(s[i]))
{
i++;
}
string text = s.Substring(num, i - num).Trim().ToLowerInvariant();
switch (text)
{
case "null":
return null;
case "true":
return true;
case "false":
return false;
default:
{
if (float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
return result;
}
return text;
}
}
}
private static bool IsDelimiter(char c)
{
if (c != ',' && c != '}' && c != ']' && c != ':')
{
return char.IsWhiteSpace(c);
}
return true;
}
private static void SkipWhitespace(string s, ref int i)
{
while (i < s.Length && char.IsWhiteSpace(s[i]))
{
i++;
}
}
}
}
namespace GWYF_NewClothing.Patches
{
[HarmonyPatch]
internal static class CosmeticDataManagerPatches
{
private static bool _injected;
private static bool IsEnabled => PluginConfig.Enabled.Value;
[HarmonyPostfix]
[HarmonyPatch(typeof(CosmeticDataManager), "Initialize")]
private static void Initialize_Postfix()
{
if (IsEnabled)
{
CosmeticRegistry.ResolvePending();
InjectCustomCosmeticsOnce();
}
}
internal static void InjectCustomCosmeticsOnce()
{
if (_injected)
{
return;
}
if (!(AccessTools.Field(typeof(CosmeticDataManager), "_cosmeticCache").GetValue(null) is Dictionary<int, CosmeticData> dictionary))
{
Debug.LogWarning((object)"[MoreCosmetics] _cosmeticCache is null. Aborting injection.");
return;
}
CosmeticData[] allCosmetics = CosmeticRegistry.AllCosmetics;
if (allCosmetics.Length == 0)
{
return;
}
int num = 0;
CosmeticData[] array = allCosmetics;
foreach (CosmeticData val in array)
{
if (!dictionary.ContainsKey(val.cosmeticId))
{
dictionary[val.cosmeticId] = val;
num++;
}
}
if (num > 0)
{
AccessTools.Method(typeof(CosmeticDataManager), "RebuildSortedCosmeticIds", (Type[])null, (Type[])null).Invoke(null, null);
Debug.Log((object)$"[MoreCosmetics] Injected {num} cosmetics. Cache has {dictionary.Count} total.");
}
_injected = true;
}
}
[HarmonyPatch]
internal static class CosmeticsUnlockManagerPatches
{
private static bool IsEnabled => PluginConfig.Enabled.Value;
[HarmonyPostfix]
[HarmonyPatch(typeof(CosmeticsUnlockManager), "OnAwake")]
private static void OnAwake_Postfix(CosmeticsUnlockManager __instance)
{
if (!IsEnabled || !PluginConfig.AutoUnlockModCosmetics.Value)
{
return;
}
CosmeticData[] allCosmetics = CosmeticRegistry.AllCosmetics;
foreach (CosmeticData val in allCosmetics)
{
if (__instance.UnlockCosmetic(val.cosmeticId))
{
Debug.Log((object)$"[MoreCosmetics] Unlocked: {val.cosmeticName} (ID:{val.cosmeticId})");
}
}
}
}
[HarmonyPatch(typeof(PlayerCustomization), "ApplyCosmetic")]
internal static class PlayerCustomizationApplyPatch
{
private static bool IsEnabled => PluginConfig.Enabled.Value;
[HarmonyPostfix]
private static void Postfix(PlayerCustomization __instance, int cosmeticId)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (!IsEnabled)
{
return;
}
CosmeticData cosmeticById = CosmeticDataManager.GetCosmeticById(cosmeticId);
if ((Object)(object)cosmeticById == (Object)null || (Object)(object)cosmeticById.cosmeticMaterial == (Object)null)
{
return;
}
MeshFilter meshFilterForType = GetMeshFilterForType(__instance, cosmeticById.cosmeticType);
if (!((Object)(object)meshFilterForType == (Object)null))
{
MeshRenderer component = ((Component)meshFilterForType).GetComponent<MeshRenderer>();
if ((Object)(object)component != (Object)null)
{
((Renderer)component).sharedMaterial = cosmeticById.cosmeticMaterial;
}
}
}
private static MeshFilter GetMeshFilterForType(PlayerCustomization instance, CosmeticType type)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected I4, but got Unknown
string text = (int)type switch
{
0 => "hat",
1 => "hair",
2 => "mustache",
3 => "beard",
4 => "neckwear",
5 => "clothing",
6 => "facewear",
_ => null,
};
if (text == null)
{
return null;
}
object? obj = typeof(PlayerCustomization).GetField(text, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(instance);
return (MeshFilter)((obj is MeshFilter) ? obj : null);
}
}
}
