using System;
using System.Collections.Generic;
using System.Diagnostics;
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 UnityEngine;
[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("EnemySkinManager")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A mod library for R.E.P.O. to manage enemy skin variations.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EnemySkinManager")]
[assembly: AssemblyTitle("EnemySkinManager")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace EnemySkinManager
{
public class SkinData
{
public string Identifier { get; set; }
public Material[] Materials { get; set; }
public Mesh SharedMesh { get; set; }
public Dictionary<string, Texture2D> TextureOverrides { get; set; }
public bool OverrideProtectedParts { get; set; } = false;
public SkinData(string id, Material[] materials = null, Mesh mesh = null, Dictionary<string, Texture2D> textures = null, bool overrideProtectedParts = false)
{
Identifier = id;
Materials = (Material[])(((object)materials) ?? ((object)new Material[0]));
SharedMesh = mesh;
TextureOverrides = textures ?? new Dictionary<string, Texture2D>();
OverrideProtectedParts = overrideProtectedParts;
}
}
public static class EnemySkinManager
{
internal static ManualLogSource Log;
internal static ConfigEntry<bool> MasterEnableConfig;
private static ConfigFile AppConfig;
public const string VanillaSkinIdentifier = "Vanilla";
internal static readonly Dictionary<string, List<SkinData>> RegisteredSkins = new Dictionary<string, List<SkinData>>();
private static readonly Dictionary<string, Dictionary<string, ConfigEntry<int>>> enemySkinWeightsConfigs = new Dictionary<string, Dictionary<string, ConfigEntry<int>>>();
public static Func<string, string, bool> IsSkinEnabledCheck = (string enemyId, string skinId) => true;
internal static void Initialize(ManualLogSource log, ConfigEntry<bool> masterEnableConfig, ConfigFile config)
{
Log = log;
MasterEnableConfig = masterEnableConfig;
AppConfig = config;
Log.LogInfo((object)"EnemySkinManager Initialized. Skins will be configured with weights per enemy.");
}
public static void RegisterSkin(string enemyId, SkinData newSkin, string? friendlyCategoryName = null)
{
//IL_02af: Unknown result type (might be due to invalid IL or missing references)
//IL_02b9: Expected O, but got Unknown
//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
//IL_01d6: Expected O, but got Unknown
if (string.IsNullOrEmpty(enemyId) || newSkin == null || string.IsNullOrEmpty(newSkin.Identifier))
{
Log.LogError((object)"Invalid parameters for RegisterSkin.");
return;
}
if (!RegisteredSkins.ContainsKey(enemyId))
{
RegisteredSkins[enemyId] = new List<SkinData>();
}
if (!RegisteredSkins[enemyId].Any((SkinData s) => s.Identifier == newSkin.Identifier))
{
RegisteredSkins[enemyId].Add(newSkin);
Log.LogInfo((object)("Registered skin '" + newSkin.Identifier + "' for enemy '" + enemyId + "'."));
}
string text = (string.IsNullOrEmpty(friendlyCategoryName) ? enemyId : friendlyCategoryName);
string text2 = text + " Skins";
if (!enemySkinWeightsConfigs.ContainsKey(enemyId))
{
Log.LogInfo((object)("Creating new weight configuration section for enemy: " + enemyId + " (displaying as '" + text2 + "')"));
enemySkinWeightsConfigs.Add(enemyId, new Dictionary<string, ConfigEntry<int>>());
if (!enemySkinWeightsConfigs[enemyId].ContainsKey("Vanilla"))
{
Log.LogInfo((object)("Creating weight config for 'Vanilla' skin in section '" + text2 + "'"));
ConfigEntry<int> value = AppConfig.Bind<int>(text2, "Vanilla", 10, new ConfigDescription("Spawn weight for 'Vanilla' (original game skin) on " + text + ". 0 = disabled. Higher values increase spawn chance relative to other enabled skins.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
enemySkinWeightsConfigs[enemyId].Add("Vanilla", value);
}
}
if (!enemySkinWeightsConfigs[enemyId].ContainsKey(newSkin.Identifier))
{
Log.LogInfo((object)("Creating weight config for skin '" + newSkin.Identifier + "' in section '" + text2 + "'"));
ConfigEntry<int> value2 = AppConfig.Bind<int>(text2, newSkin.Identifier, 10, new ConfigDescription("Spawn weight for '" + newSkin.Identifier + "' on " + text + ". 0 = disabled. Higher values increase spawn chance relative to other enabled skins.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
enemySkinWeightsConfigs[enemyId].Add(newSkin.Identifier, value2);
}
}
public static SkinData GetRandomSkinForEnemy(string enemyId)
{
if (MasterEnableConfig != null && !MasterEnableConfig.Value)
{
return null;
}
if (!enemySkinWeightsConfigs.TryGetValue(enemyId, out var value))
{
Log.LogWarning((object)("No weight configuration section found for enemy '" + enemyId + "'. Skins may be registered, but weights are missing. Using vanilla."));
return null;
}
RegisteredSkins.TryGetValue(enemyId, out var value2);
value2 = value2 ?? new List<SkinData>();
List<KeyValuePair<SkinData, int>> list = new List<KeyValuePair<SkinData, int>>();
int num = 0;
if (value.TryGetValue("Vanilla", out var value3) && value3.Value > 0)
{
list.Add(new KeyValuePair<SkinData, int>(null, value3.Value));
num += value3.Value;
}
foreach (SkinData item in value2)
{
if (value.TryGetValue(item.Identifier, out var value4) && value4.Value > 0)
{
list.Add(new KeyValuePair<SkinData, int>(item, value4.Value));
num += value4.Value;
}
}
if (list.Count == 0 || num == 0)
{
return null;
}
int num2 = Random.Range(0, num);
foreach (KeyValuePair<SkinData, int> item2 in list)
{
if (num2 < item2.Value)
{
return item2.Key;
}
num2 -= item2.Value;
}
if (list.Any((KeyValuePair<SkinData, int> opt) => opt.Key == null && opt.Value > 0))
{
return null;
}
return list.FirstOrDefault((KeyValuePair<SkinData, int> opt) => opt.Key != null).Key;
}
public static void ApplySkin(GameObject enemyInstance, SkinData skinData)
{
if ((Object)(object)enemyInstance == (Object)null || skinData == null)
{
Log.LogWarning((object)"ApplySkin called with null enemyInstance or skinData.");
return;
}
Renderer componentInChildren = enemyInstance.GetComponentInChildren<Renderer>();
if ((Object)(object)componentInChildren == (Object)null)
{
Log.LogWarning((object)("Could not find a Renderer component on '" + ((Object)enemyInstance).name + "' or its children to apply skin '" + (skinData.Identifier ?? "Unnamed") + "'."));
return;
}
if (skinData.Materials != null && skinData.Materials.Length != 0)
{
if (componentInChildren.sharedMaterials.Length != skinData.Materials.Length)
{
Log.LogWarning((object)("Skin '" + skinData.Identifier + "' for " + ((Object)enemyInstance).name + ": " + $"Provided material count ({skinData.Materials.Length}) " + $"differs from renderer's material slot count ({componentInChildren.sharedMaterials.Length}). " + "Applying materials anyway. This might lead to an incomplete or unexpected appearance if counts don't effectively match."));
}
componentInChildren.sharedMaterials = skinData.Materials;
if (Plugin.EnableDebugLogging.Value)
{
Log.LogDebug((object)$"Applied {skinData.Materials.Length} material(s) from skin '{skinData.Identifier}' to {((Object)enemyInstance).name}.");
}
}
else if (Plugin.EnableDebugLogging.Value)
{
Log.LogDebug((object)("Skin '" + (skinData.Identifier ?? "Unnamed") + "' has no materials defined."));
}
if (skinData.TextureOverrides != null && skinData.TextureOverrides.Count > 0)
{
foreach (KeyValuePair<string, Texture2D> textureOverride in skinData.TextureOverrides)
{
Material[] sharedMaterials = componentInChildren.sharedMaterials;
foreach (Material val in sharedMaterials)
{
if (val.HasProperty(textureOverride.Key))
{
val.SetTexture(textureOverride.Key, (Texture)(object)textureOverride.Value);
if (Plugin.EnableDebugLogging.Value)
{
Log.LogDebug((object)("Applied texture override '" + textureOverride.Key + "' to material '" + ((Object)val).name + "' on '" + ((Object)componentInChildren).name + "'."));
}
}
}
}
}
else if (Plugin.EnableDebugLogging.Value)
{
Log.LogDebug((object)("Skin '" + (skinData.Identifier ?? "Unnamed") + "' has no texture overrides defined."));
}
if ((Object)(object)skinData.SharedMesh != (Object)null)
{
MeshFilter component = ((Component)componentInChildren).GetComponent<MeshFilter>();
SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)(object)((componentInChildren is SkinnedMeshRenderer) ? componentInChildren : null);
if ((Object)(object)component != (Object)null)
{
component.sharedMesh = skinData.SharedMesh;
if (Plugin.EnableDebugLogging.Value)
{
Log.LogDebug((object)("Applied shared mesh '" + ((Object)skinData.SharedMesh).name + "' to MeshFilter on '" + ((Object)componentInChildren).name + "'."));
}
}
else if ((Object)(object)val2 != (Object)null)
{
val2.sharedMesh = skinData.SharedMesh;
if (Plugin.EnableDebugLogging.Value)
{
Log.LogDebug((object)("Applied shared mesh '" + ((Object)skinData.SharedMesh).name + "' to SkinnedMeshRenderer on '" + ((Object)componentInChildren).name + "'."));
}
}
else
{
Log.LogWarning((object)("Could not apply mesh '" + ((Object)skinData.SharedMesh).name + "'. No MeshFilter or SkinnedMeshRenderer found on '" + ((Object)componentInChildren).name + "'."));
}
}
Log.LogInfo((object)("Successfully applied skin '" + (skinData.Identifier ?? "Unnamed") + "' to '" + ((Object)enemyInstance).name + "'."));
}
}
[BepInPlugin("JustSomeDevGuy.EnemySkinManager.Alpha", "EnemySkinManager (ALPHA)", "0.1.0")]
public class Plugin : BaseUnityPlugin
{
private Harmony harmony;
private static ConfigEntry<bool> MasterEnableToggle;
internal static ManualLogSource Log { get; private set; }
public static ConfigEntry<bool> EnableDebugLogging { get; private set; }
private void Awake()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
harmony = new Harmony("JustSomeDevGuy.EnemySkinManager.Alpha");
MasterEnableToggle = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Master Enable", true, "Globally enable or disable all custom skins from this manager.");
EnableDebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enable Detailed Logging", false, "Enable detailed debug messages in the log, useful for troubleshooting skin application.");
EnemySkinManager.Initialize(Log, MasterEnableToggle, ((BaseUnityPlugin)this).Config);
harmony.PatchAll();
Log.LogInfo((object)"Registering default 'Vanilla' skins...");
string[] array = new string[19]
{
"Duck", "Animal", "Banger", "Bowtie", "Chef", "Clown", "Gnome", "Headman", "Hidden", "Huntsman",
"Peeper", "Mentalist", "Reaper", "Robe", "Rugrat", "Shadow Child", "Spewer", "Trudge", "Upscream"
};
string[] array2 = array;
foreach (string enemyId in array2)
{
EnemySkinManager.RegisterSkin(enemyId, new SkinData("Vanilla"));
}
Log.LogInfo((object)"Finished registering default 'Vanilla' skins.");
Log.LogInfo((object)"Plugin JustSomeDevGuy.EnemySkinManager.Alpha patched methods.");
Log.LogInfo((object)"Plugin JustSomeDevGuy.EnemySkinManager.Alpha is loaded!");
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "JustSomeDevGuy.EnemySkinManager.Alpha";
public const string PLUGIN_NAME = "EnemySkinManager (ALPHA)";
public const string PLUGIN_VERSION = "0.1.0";
}
}
namespace EnemySkinManager.Patches
{
[HarmonyPatch]
internal class EnemySpawnPatches
{
private const string LOG_PREFIX = "[EnemySkinMod] ";
private static ManualLogSource Log => Plugin.Log;
[HarmonyPatch(typeof(EnemyParent), "Spawn")]
[HarmonyPostfix]
private static void EnemyParent_Spawn_Postfix(EnemyParent __instance)
{
Plugin.Log.LogInfo((object)string.Format("{0}--- EnemyParent_Spawn_Postfix executing for instance {1} (Name: {2}) ---", "[EnemySkinMod] ", ((Object)__instance).GetInstanceID(), ((Object)((Component)__instance).gameObject).name));
if (!EnemySkinManager.MasterEnableConfig.Value)
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)"EnemySkinManager is disabled via config. Skipping skin application.");
}
return;
}
string name = ((Object)((Component)__instance).gameObject).name;
string text = name.Replace("(Clone)", "").Trim();
string text2 = text;
if (text.StartsWith("Enemy - "))
{
text2 = text.Substring("Enemy - ".Length).Trim();
}
if (string.IsNullOrEmpty(text2))
{
Plugin.Log.LogWarning((object)("Could not get valid Enemy ID from GameObject name: '" + name + "'. Cannot apply skin."));
return;
}
Plugin.Log.LogInfo((object)("Enemy ID derived from GameObject name: '" + text2 + "' (Original: '" + name + "')"));
if (!EnemySkinManager.RegisteredSkins.ContainsKey(text2) || EnemySkinManager.RegisteredSkins[text2].Count == 0)
{
Plugin.Log.LogInfo((object)("No skins registered for enemy ID '" + text2 + "'. Skipping."));
return;
}
Plugin.Log.LogInfo((object)("Getting random skin for enemy '" + text2 + "'..."));
SkinData randomSkinForEnemy = EnemySkinManager.GetRandomSkinForEnemy(text2);
if (randomSkinForEnemy == null || randomSkinForEnemy.Identifier == null)
{
Plugin.Log.LogInfo((object)("GetRandomSkinForEnemy returned no specific skin (maybe all disabled or only 'Vanilla' exists and was chosen). Enemy ID: '" + text2 + "'. No custom skin applied."));
return;
}
Plugin.Log.LogInfo((object)("Selected skin '" + randomSkinForEnemy.Identifier + "' for enemy '" + text2 + "'. Applying..."));
GameObject gameObject = ((Component)__instance).gameObject;
if ((Object)(object)gameObject == (Object)null)
{
Plugin.Log.LogError((object)"EnemyParent_Spawn_Postfix triggered on a null instance or GameObject.");
}
else
{
ApplySkinLogic(gameObject, randomSkinForEnemy);
}
}
private static bool IsSkinEnabledCheck(string enemyId, string skinId)
{
return EnemySkinManager.IsSkinEnabledCheck(enemyId, skinId);
}
private static void ApplySkinLogic(GameObject enemyInstance, SkinData skinData)
{
if ((Object)(object)enemyInstance == (Object)null || skinData.Identifier == null)
{
Plugin.Log.LogError((object)"ApplySkinLogic: Received null enemyInstance or skinData.Identifier.");
return;
}
if (skinData.TextureOverrides != null && skinData.TextureOverrides.Count > 0)
{
Plugin.Log.LogInfo((object)string.Format("{0}ApplySkinLogic: Attempting to apply {1} texture overrides using INSTANCED materials.", "[EnemySkinMod] ", skinData.TextureOverrides.Count));
bool flag = false;
Renderer[] componentsInChildren = enemyInstance.GetComponentsInChildren<Renderer>(true);
if (componentsInChildren == null || componentsInChildren.Length == 0)
{
Plugin.Log.LogWarning((object)("[EnemySkinMod] ApplySkinLogic: No Renderers found on '" + ((Object)enemyInstance).name + "' or its children."));
}
else
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)string.Format("{0}ApplySkinLogic: Found {1} renderers on '{2}'. Iterating...", "[EnemySkinMod] ", componentsInChildren.Length, ((Object)enemyInstance).name));
}
foreach (KeyValuePair<string, Texture2D> textureOverride in skinData.TextureOverrides)
{
string key = textureOverride.Key;
Texture2D value = textureOverride.Value;
Plugin.Log.LogInfo((object)("[EnemySkinMod] ApplySkinLogic: Processing override: Key='" + key + "', Texture='" + (((Object)(object)value != (Object)null) ? ((Object)value).name : "NULL") + "'"));
if (string.IsNullOrEmpty(key) || (Object)(object)value == (Object)null)
{
Plugin.Log.LogWarning((object)("[EnemySkinMod] ApplySkinLogic: Skipping invalid texture override entry (null key or value). Key: " + key));
continue;
}
bool flag2 = false;
Renderer[] array = componentsInChildren;
foreach (Renderer val in array)
{
Material[] materials = val.materials;
for (int j = 0; j < materials.Length; j++)
{
Material val2 = materials[j];
if (val2.HasProperty(key))
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)string.Format("{0}ApplySkinLogic: Found property '{1}' on material instance '{2}' (Index {3}) of renderer '{4}'. Applying texture '{5}'.", "[EnemySkinMod] ", key, ((Object)val2).name, j, ((Object)val).name, ((Object)value).name));
}
val2.SetTexture(key, (Texture)(object)value);
flag2 = true;
flag = true;
}
else if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)string.Format("{0}ApplySkinLogic: Material instance '{1}' (Index {2}) of renderer '{3}' does not have property '{4}'.", "[EnemySkinMod] ", ((Object)val2).name, j, ((Object)val).name, key));
}
}
val.materials = materials;
}
if (!flag2)
{
Plugin.Log.LogWarning((object)("[EnemySkinMod] ApplySkinLogic: Texture override key '" + key + "' was not found on ANY material instance of ANY renderer on '" + ((Object)enemyInstance).name + "'."));
}
}
}
if (flag)
{
Plugin.Log.LogInfo((object)("[EnemySkinMod] ApplySkinLogic: Finished applying texture overrides for '" + skinData.Identifier + "' on '" + ((Object)enemyInstance).name + "'."));
}
else
{
Plugin.Log.LogWarning((object)("[EnemySkinMod] ApplySkinLogic: Finished applying texture overrides for '" + skinData.Identifier + "' on '" + ((Object)enemyInstance).name + "', but no matching properties were found on any materials."));
}
}
else if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skin '" + skinData.Identifier + "' has no texture overrides defined."));
}
if (skinData.Materials != null && skinData.Materials.Length != 0)
{
Plugin.Log.LogInfo((object)string.Format("{0}ApplySkinLogic: Skin '{1}' has {2} material(s). Attempting to apply.", "[EnemySkinMod] ", skinData.Identifier, skinData.Materials.Length));
bool flag3 = false;
Renderer[] componentsInChildren2 = enemyInstance.GetComponentsInChildren<Renderer>(true);
if (componentsInChildren2 == null || componentsInChildren2.Length == 0)
{
Plugin.Log.LogWarning((object)("[EnemySkinMod] ApplySkinLogic: No Renderers found on '" + ((Object)enemyInstance).name + "' or its children for shared material application."));
}
else
{
string text = ((Object)enemyInstance).name;
if (text.EndsWith("(Clone)"))
{
text = text.Substring(0, text.Length - "(Clone)".Length);
}
if (text.StartsWith("Enemy - "))
{
text = text.Substring("Enemy - ".Length);
}
switch (text)
{
case "Head":
{
Plugin.Log.LogInfo((object)"[EnemySkinMod] ApplySkinLogic: Special handling for enemy 'Head'. Targeting 'Eye L Mesh' and 'Eye R Mesh'.");
Renderer[] array6 = componentsInChildren2;
foreach (Renderer val14 in array6)
{
if ((((Object)((Component)val14).gameObject).name == "Eye L Mesh" || ((Object)((Component)val14).gameObject).name == "Eye R Mesh") && skinData.Materials.Length != 0)
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Applying material '" + ((Object)skinData.Materials[0]).name + "' to '" + ((Object)((Component)val14).gameObject).name + "' on 'Head' enemy."));
}
val14.material = skinData.Materials[0];
flag3 = true;
}
}
break;
}
case "Upscream":
{
Plugin.Log.LogInfo((object)"[EnemySkinMod] ApplySkinLogic: Special handling for enemy 'Upscream'. Applying head/leg materials to specific parts.");
if (skinData.Materials == null || skinData.Materials.Length < 2)
{
ManualLogSource log = Plugin.Log;
string identifier = skinData.Identifier;
Material[] materials2 = skinData.Materials;
log.LogError((object)string.Format("{0}ApplySkinLogic: 'Upscream' skin '{1}' requires 2 materials (head, legs) but found {2}. Aborting skin application for this enemy.", "[EnemySkinMod] ", identifier, (materials2 != null) ? materials2.Length : 0));
break;
}
Material val7 = skinData.Materials[0];
Material val8 = skinData.Materials[1];
if ((Object)(object)val7 == (Object)null || (Object)(object)val8 == (Object)null)
{
Plugin.Log.LogError((object)string.Format("{0}ApplySkinLogic: One or both materials for 'Upscream' skin '{1}' are null. Head: {2}, Legs: {3}. Aborting.", "[EnemySkinMod] ", skinData.Identifier, (Object)(object)val7 == (Object)null, (Object)(object)val8 == (Object)null));
break;
}
Renderer[] array4 = componentsInChildren2;
foreach (Renderer val9 in array4)
{
string name3 = ((Object)((Component)val9).gameObject).name;
switch (name3)
{
default:
if (!(name3 == "eye_R"))
{
switch (name3)
{
default:
if (!(name3 == "leg front R3"))
{
goto end_IL_0747;
}
break;
case "leg back L1":
case "leg back L2":
case "leg back R1":
case "leg back R2":
case "leg front L1":
case "leg front L2":
case "leg front R1":
case "leg front R2":
case "leg back L3":
case "leg back R3":
case "leg front L3":
break;
}
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Applying LEGS material '" + ((Object)val8).name + "' to '" + name3 + "' on 'Upscream'."));
}
val9.material = val8;
flag3 = true;
break;
}
goto case "Upscream_Head - Mouth Closed";
case "Upscream_Head - Mouth Closed":
case "Upscream_Head - Mouth Open":
case "eye_L":
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Applying HEAD material '" + ((Object)val7).name + "' to '" + name3 + "' on 'Upscream'."));
}
val9.material = val7;
flag3 = true;
break;
}
end_IL_0747:
break;
}
}
break;
}
case "Duck":
{
Plugin.Log.LogInfo((object)"[EnemySkinMod] ApplySkinLogic: Special handling for enemy 'Duck'. Applying two materials to specified parts and preserving particles.");
if (skinData.Materials == null || skinData.Materials.Length < 2)
{
ManualLogSource log2 = Plugin.Log;
string identifier2 = skinData.Identifier;
Material[] materials3 = skinData.Materials;
log2.LogWarning((object)string.Format("{0}ApplySkinLogic: SkinData for '{1}' on 'Duck' requires 2 materials, but found {2}. No materials applied.", "[EnemySkinMod] ", identifier2, (materials3 != null) ? materials3.Length : 0));
break;
}
Material val10 = skinData.Materials[0];
Material val11 = skinData.Materials[1];
Renderer[] array5 = componentsInChildren2;
foreach (Renderer val12 in array5)
{
bool flag6 = false;
string name4 = ((Object)((Component)val12).gameObject).name;
switch (name4)
{
default:
if (!(name4 == "mesh Mon Mouth Bot"))
{
break;
}
goto case "mesh Eye R";
case "mesh Eye R":
case "mesh Eye L":
case "mesh Mon Eye L":
case "mesh Mon Eye R":
case "mesh Mon Mouth Top":
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + name4 + "' on 'Duck' to keep its material vanilla (eye or mouth part)."));
}
flag6 = true;
break;
}
if (!flag6)
{
string text4 = name4.ToLower();
if (text4.Contains("particle") || text4.Contains("effect") || text4.Contains("vfx"))
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + name4 + "' on 'Duck' due to name containing particle/effect keywords."));
}
flag6 = true;
}
if (!flag6 && val12.sharedMaterials != null)
{
Material[] sharedMaterials3 = val12.sharedMaterials;
foreach (Material val13 in sharedMaterials3)
{
if (!((Object)(object)val13 != (Object)null) || !((Object)(object)val13.shader != (Object)null))
{
continue;
}
string name5 = ((Object)val13.shader).name;
if (name5 == "Particles/Standard Unlit" || name5 == "Particles/Standard Surface")
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + name4 + "' on 'Duck' due to material '" + ((Object)val13).name + "' using shader '" + name5 + "'."));
}
flag6 = true;
break;
}
}
}
}
if (flag6)
{
continue;
}
switch (name4)
{
default:
if (!(name4 == "mesh Mon Head"))
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Applying main body material (" + ((Object)val10).name + ") to '" + name4 + "' on 'Duck'."));
}
val12.material = val10;
flag3 = true;
break;
}
goto case "mesh Mon Body";
case "mesh Mon Body":
case "mesh Mon Wing L":
case "mesh Mon Wing R":
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Applying 'Monster' material (" + ((Object)val11).name + ") to '" + name4 + "' on 'Duck'."));
}
val12.material = val11;
flag3 = true;
break;
}
}
break;
}
case "Animal":
{
Plugin.Log.LogInfo((object)"[EnemySkinMod] ApplySkinLogic: Special handling for enemy 'Animal'. Preserving 'Eyes' and particles.");
if (skinData.Materials == null || skinData.Materials.Length == 0 || (Object)(object)skinData.Materials[0] == (Object)null)
{
Plugin.Log.LogError((object)("[EnemySkinMod] ApplySkinLogic: Skin '" + skinData.Identifier + "' for 'Animal' has no valid material at index 0. Aborting skin application for this instance."));
return;
}
Material val15 = skinData.Materials[0];
Renderer[] array7 = componentsInChildren2;
foreach (Renderer val16 in array7)
{
bool flag7 = false;
string name6 = ((Object)((Component)val16).gameObject).name;
if (name6 == "Eyes")
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + name6 + "' on 'Animal' to keep its material vanilla."));
}
flag7 = true;
}
if (!flag7)
{
string text5 = name6.ToLower();
if (text5.Contains("particle") || text5.Contains("effect") || text5.Contains("vfx"))
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + name6 + "' on 'Animal' due to name containing particle/effect keywords."));
}
flag7 = true;
}
if (!flag7 && val16.sharedMaterials != null)
{
Material[] sharedMaterials4 = val16.sharedMaterials;
foreach (Material val17 in sharedMaterials4)
{
if (!((Object)(object)val17 != (Object)null) || !((Object)(object)val17.shader != (Object)null))
{
continue;
}
string name7 = ((Object)val17.shader).name;
if (name7 == "Particles/Standard Unlit" || name7 == "Particles/Standard Surface")
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + name6 + "' on 'Animal' due to material '" + ((Object)val17).name + "' using shader '" + name7 + "'."));
}
flag7 = true;
break;
}
}
}
}
if (!flag7)
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Applying skin material (" + ((Object)val15).name + ") to '" + name6 + "' on 'Animal'."));
}
val16.material = val15;
}
}
break;
}
case "Bowtie":
{
Plugin.Log.LogInfo((object)"[EnemySkinMod] ApplySkinLogic: Special handling for enemy 'Bowtie'. Preserving 'bend body' and particle effects.");
if (skinData.Materials == null || skinData.Materials.Length == 0)
{
Plugin.Log.LogWarning((object)("[EnemySkinMod] ApplySkinLogic: SkinData for '" + skinData.Identifier + "' on 'Bowtie' has no materials. No materials applied."));
break;
}
Renderer[] array3 = componentsInChildren2;
foreach (Renderer val5 in array3)
{
bool flag5 = false;
if (((Object)((Component)val5).gameObject).name == "bend body")
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)"[EnemySkinMod] ApplySkinLogic: Skipping renderer 'bend body' on 'Bowtie' to keep its material vanilla.");
}
flag5 = true;
}
if (!flag5)
{
string text3 = ((Object)((Component)val5).gameObject).name.ToLower();
if (text3.Contains("particle") || text3.Contains("effect") || text3.Contains("vfx"))
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + ((Object)((Component)val5).gameObject).name + "' on 'Bowtie' due to name containing particle/effect keywords."));
}
flag5 = true;
}
if (!flag5 && val5.sharedMaterials != null)
{
Material[] sharedMaterials2 = val5.sharedMaterials;
foreach (Material val6 in sharedMaterials2)
{
if (!((Object)(object)val6 != (Object)null) || !((Object)(object)val6.shader != (Object)null))
{
continue;
}
string name2 = ((Object)val6.shader).name;
if (name2 == "Particles/Standard Unlit" || name2 == "Particles/Standard Surface")
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + ((Object)((Component)val5).gameObject).name + "' on 'Bowtie' due to material '" + ((Object)val6).name + "' using shader '" + name2 + "'."));
}
flag5 = true;
break;
}
}
}
}
if (flag5)
{
continue;
}
if (val5.sharedMaterials == null || val5.sharedMaterials.Length == 0)
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Renderer '" + ((Object)((Component)val5).gameObject).name + "' on 'Bowtie' has no materials to replace. Skipping."));
}
continue;
}
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)string.Format("{0}ApplySkinLogic: Applying skin materials to renderer '{1}' on 'Bowtie'. Original material count: {2}, New material count: {3}", "[EnemySkinMod] ", ((Object)((Component)val5).gameObject).name, val5.sharedMaterials.Length, skinData.Materials.Length));
}
val5.materials = skinData.Materials;
flag3 = true;
}
break;
}
default:
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)string.Format("{0}ApplySkinLogic: Found {1} renderers on '{2}' ({3}). Applying shared materials, skipping particle systems if named appropriately.", "[EnemySkinMod] ", componentsInChildren2.Length, ((Object)enemyInstance).name, text));
}
if (skinData.Materials != null && skinData.Materials.Length != 0)
{
Renderer[] array2 = componentsInChildren2;
foreach (Renderer val3 in array2)
{
bool flag4 = false;
string text2 = ((Object)((Component)val3).gameObject).name.ToLower();
if (text2.Contains("particle") || text2.Contains("effect") || text2.Contains("vfx"))
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + ((Object)((Component)val3).gameObject).name + "' on '" + text + "' due to name containing particle/effect keywords."));
}
flag4 = true;
}
if (!flag4 && val3.sharedMaterials != null)
{
Material[] sharedMaterials = val3.sharedMaterials;
foreach (Material val4 in sharedMaterials)
{
if (!((Object)(object)val4 != (Object)null) || !((Object)(object)val4.shader != (Object)null))
{
continue;
}
string name = ((Object)val4.shader).name;
if (name == "Particles/Standard Unlit" || name == "Particles/Standard Surface")
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skipping renderer '" + ((Object)((Component)val3).gameObject).name + "' on '" + text + "' due to material '" + ((Object)val4).name + "' using shader '" + name + "'."));
}
flag4 = true;
break;
}
}
}
if (flag4)
{
continue;
}
if (val3.sharedMaterials == null || val3.sharedMaterials.Length == 0)
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Renderer '" + ((Object)((Component)val3).gameObject).name + "' on '" + text + "' has no materials to replace. Skipping."));
}
continue;
}
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)string.Format("{0}ApplySkinLogic: Applying skin materials to renderer '{1}' on '{2}'. Original material count: {3}, New material count: {4}", "[EnemySkinMod] ", ((Object)((Component)val3).gameObject).name, text, val3.sharedMaterials.Length, skinData.Materials.Length));
}
val3.materials = skinData.Materials;
flag3 = true;
}
}
else
{
Plugin.Log.LogWarning((object)("[EnemySkinMod] ApplySkinLogic: SkinData for '" + skinData.Identifier + "' on '" + text + "' has no materials. No general materials applied."));
}
break;
}
}
if (flag3)
{
Plugin.Log.LogInfo((object)("[EnemySkinMod] ApplySkinLogic: Finished applying shared materials for '" + skinData.Identifier + "' on '" + ((Object)enemyInstance).name + "'."));
}
else
{
Plugin.Log.LogWarning((object)("[EnemySkinMod] ApplySkinLogic: Finished applying shared materials for '" + skinData.Identifier + "' on '" + ((Object)enemyInstance).name + "', but no materials were actually applied (e.g., specific renderers not found for 'Head', or no renderers for others, or no materials in skinData)."));
}
}
else if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skin '" + skinData.Identifier + "' has no shared materials defined."));
}
if ((Object)(object)skinData.SharedMesh != (Object)null)
{
Plugin.Log.LogInfo((object)("[EnemySkinMod] ApplySkinLogic: Skin '" + skinData.Identifier + "' has a shared mesh defined. Attempting to apply."));
MeshFilter componentInChildren = enemyInstance.GetComponentInChildren<MeshFilter>(true);
if ((Object)(object)componentInChildren != (Object)null)
{
componentInChildren.mesh = skinData.SharedMesh;
Plugin.Log.LogInfo((object)("[EnemySkinMod] ApplySkinLogic: Successfully applied shared mesh '" + ((Object)skinData.SharedMesh).name + "' to MeshFilter on '" + ((Object)((Component)componentInChildren).gameObject).name + "'."));
}
else
{
Plugin.Log.LogWarning((object)("[EnemySkinMod] ApplySkinLogic: No MeshFilter found on '" + ((Object)enemyInstance).name + "' or its children to apply shared mesh."));
}
}
else if (Plugin.EnableDebugLogging.Value)
{
Plugin.Log.LogDebug((object)("[EnemySkinMod] ApplySkinLogic: Skin '" + skinData.Identifier + "' has no shared mesh defined."));
}
Plugin.Log.LogInfo((object)("[EnemySkinMod] ApplySkinLogic completed for '" + ((Object)enemyInstance).name + "' with skin '" + skinData.Identifier + "'. Check logs for details."));
}
[HarmonyPatch(typeof(EnemyDirector), "Awake")]
[HarmonyPostfix]
private static void EnemyDirector_Awake_Patch(EnemyDirector __instance)
{
Plugin.Log.LogInfo((object)$"--- EnemyDirector_Awake_Patch executing for instance {((Object)__instance).GetInstanceID()} ---");
string name = ((Object)((Component)__instance).gameObject).name;
string text = name.Replace("(Clone)", "").Trim();
string text2 = text;
if (text.StartsWith("Enemy - "))
{
text2 = text.Substring("Enemy - ".Length).Trim();
}
if (string.IsNullOrEmpty(text2))
{
Plugin.Log.LogWarning((object)(" Could not get valid Enemy ID from GameObject name: '" + name + "'. Cannot apply skin."));
return;
}
Plugin.Log.LogInfo((object)(" Enemy ID derived from GameObject name: '" + text2 + "' (Original: '" + name + "')"));
if (!EnemySkinManager.RegisteredSkins.ContainsKey(text2) || EnemySkinManager.RegisteredSkins[text2].Count == 0)
{
Plugin.Log.LogInfo((object)(" No skins registered for enemy ID '" + text2 + "'. Skipping."));
return;
}
SkinData randomSkinForEnemy = EnemySkinManager.GetRandomSkinForEnemy(text2);
if (randomSkinForEnemy.Identifier == null)
{
Plugin.Log.LogInfo((object)(" GetRandomSkinForEnemy returned no skin (likely all disabled or only Vanilla exists and was chosen). Enemy ID: '" + text2 + "'"));
return;
}
if (randomSkinForEnemy.Identifier == "Vanilla")
{
Plugin.Log.LogInfo((object)(" Selected skin is 'Vanilla'. No custom skin applied for enemy ID: '" + text2 + "'."));
return;
}
Plugin.Log.LogInfo((object)(" Selected skin '" + randomSkinForEnemy.Identifier + "' for enemy ID '" + text2 + "'. Applying..."));
GameObject gameObject = ((Component)__instance).gameObject;
ApplySkinLogic(gameObject, randomSkinForEnemy);
}
}
}
