using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
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 HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ProjectAshlands")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ProjectAshlands")]
[assembly: AssemblyCopyright("Copyright © 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("f405ea1c-ac25-47a3-9aa2-a8f56c14bfd6")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace BalrondFurRandomizer;
public class FxReplacment
{
private List<GameObject> allPrefabs;
private string projectName = "[BalrondFurRandomizer]";
public void setInstance(List<GameObject> gameObjects)
{
allPrefabs = gameObjects;
}
public void ReplaceOnObject(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
return;
}
SpawnArea component = gameObject.GetComponent<SpawnArea>();
if ((Object)(object)component != (Object)null)
{
EffectList spawnEffects = component.m_spawnEffects;
if (spawnEffects != null)
{
findEffectsAndChange(spawnEffects.m_effectPrefabs);
}
}
Destructible component2 = gameObject.GetComponent<Destructible>();
if ((Object)(object)component2 != (Object)null)
{
EffectList hitEffect = component2.m_hitEffect;
if (hitEffect != null)
{
findEffectsAndChange(hitEffect.m_effectPrefabs);
}
EffectList destroyedEffect = component2.m_destroyedEffect;
if (destroyedEffect != null)
{
findEffectsAndChange(destroyedEffect.m_effectPrefabs);
}
}
Projectile component3 = gameObject.GetComponent<Projectile>();
if ((Object)(object)component3 != (Object)null)
{
EffectList hitEffects = component3.m_hitEffects;
if (hitEffects != null)
{
findEffectsAndChange(hitEffects.m_effectPrefabs);
}
EffectList hitWaterEffects = component3.m_hitWaterEffects;
if (hitWaterEffects != null)
{
findEffectsAndChange(hitWaterEffects.m_effectPrefabs);
}
EffectList spawnOnHitEffects = component3.m_spawnOnHitEffects;
if (spawnOnHitEffects != null)
{
findEffectsAndChange(spawnOnHitEffects.m_effectPrefabs);
}
}
}
public void ReplaceOnVegetation(GameObject gameObject)
{
Pickable component = gameObject.GetComponent<Pickable>();
if ((Object)(object)component != (Object)null)
{
fixPlant(component);
}
Destructible component2 = gameObject.GetComponent<Destructible>();
if ((Object)(object)component2 != (Object)null)
{
fixPDestructable(component2);
}
MineRock5 component3 = gameObject.GetComponent<MineRock5>();
if ((Object)(object)component3 != (Object)null)
{
fixMineRock5(component3);
}
MineRock component4 = gameObject.GetComponent<MineRock>();
if ((Object)(object)component4 != (Object)null)
{
fixMineRock(component4);
}
}
private void fixPlant(Pickable pickable)
{
EffectList pickEffector = pickable.m_pickEffector;
if (pickEffector != null)
{
findEffectsAndChange(pickEffector.m_effectPrefabs);
}
}
private void fixPDestructable(Destructible minerock5)
{
EffectList hitEffect = minerock5.m_hitEffect;
if (hitEffect != null)
{
findEffectsAndChange(hitEffect.m_effectPrefabs);
}
EffectList destroyedEffect = minerock5.m_destroyedEffect;
if (destroyedEffect != null)
{
findEffectsAndChange(destroyedEffect.m_effectPrefabs);
}
}
private void fixMineRock5(MineRock5 minerock5)
{
EffectList hitEffect = minerock5.m_hitEffect;
if (hitEffect != null)
{
findEffectsAndChange(hitEffect.m_effectPrefabs);
}
EffectList destroyedEffect = minerock5.m_destroyedEffect;
if (destroyedEffect != null)
{
findEffectsAndChange(destroyedEffect.m_effectPrefabs);
}
}
private void fixMineRock(MineRock minerock5)
{
EffectList hitEffect = minerock5.m_hitEffect;
if (hitEffect != null)
{
findEffectsAndChange(hitEffect.m_effectPrefabs);
}
EffectList destroyedEffect = minerock5.m_destroyedEffect;
if (destroyedEffect != null)
{
findEffectsAndChange(destroyedEffect.m_effectPrefabs);
}
}
public void ReplaceOnMonster(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
Debug.LogWarning((object)(projectName + ":: GameObject not found"));
return;
}
Humanoid component = gameObject.GetComponent<Humanoid>();
if ((Object)(object)component == (Object)null)
{
Debug.LogWarning((object)(projectName + ":: GameObject not found"));
return;
}
EffectList dropEffects = component.m_dropEffects;
if (dropEffects != null)
{
findEffectsAndChange(dropEffects.m_effectPrefabs);
}
EffectList backstabHitEffects = ((Character)component).m_backstabHitEffects;
if (backstabHitEffects != null)
{
findEffectsAndChange(backstabHitEffects.m_effectPrefabs);
}
EffectList consumeItemEffects = component.m_consumeItemEffects;
if (consumeItemEffects != null)
{
findEffectsAndChange(consumeItemEffects.m_effectPrefabs);
}
EffectList critHitEffects = ((Character)component).m_critHitEffects;
if (critHitEffects != null)
{
findEffectsAndChange(critHitEffects.m_effectPrefabs);
}
EffectList deathEffects = ((Character)component).m_deathEffects;
if (deathEffects != null)
{
findEffectsAndChange(deathEffects.m_effectPrefabs);
}
EffectList hitEffects = ((Character)component).m_hitEffects;
if (hitEffects != null)
{
findEffectsAndChange(hitEffects.m_effectPrefabs);
}
EffectList jumpEffects = ((Character)component).m_jumpEffects;
if (jumpEffects != null)
{
findEffectsAndChange(jumpEffects.m_effectPrefabs);
}
EffectList perfectBlockEffect = component.m_perfectBlockEffect;
if (perfectBlockEffect != null)
{
findEffectsAndChange(perfectBlockEffect.m_effectPrefabs);
}
EffectList pickupEffects = component.m_pickupEffects;
if (pickupEffects != null)
{
findEffectsAndChange(pickupEffects.m_effectPrefabs);
}
EffectList slideEffects = ((Character)component).m_slideEffects;
if (slideEffects != null)
{
findEffectsAndChange(slideEffects.m_effectPrefabs);
}
EffectList tarEffects = ((Character)component).m_tarEffects;
if (tarEffects != null)
{
findEffectsAndChange(tarEffects.m_effectPrefabs);
}
EffectList waterEffects = ((Character)component).m_waterEffects;
if (waterEffects != null)
{
findEffectsAndChange(waterEffects.m_effectPrefabs);
}
FootStep component2 = gameObject.GetComponent<FootStep>();
if (!((Object)(object)component2 != (Object)null))
{
return;
}
List<StepEffect> effects = component2.m_effects;
foreach (StepEffect item in effects)
{
GameObject[] effectPrefabs = item.m_effectPrefabs;
List<GameObject> list = new List<GameObject>();
list.AddRange(effectPrefabs);
for (int i = 0; i < list.Count; i++)
{
if ((Object)(object)list[i] != (Object)null)
{
string name = ((Object)list[i]).name;
GameObject val = allPrefabs.Find((GameObject x) => ((Object)x).name == name);
if (!((Object)(object)val == (Object)null))
{
list[i] = val;
}
}
}
}
}
public void ReplaceOnItem(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
return;
}
ItemDrop component = gameObject.GetComponent<ItemDrop>();
if (!((Object)(object)component == (Object)null))
{
EffectList hitEffect = component.m_itemData.m_shared.m_hitEffect;
if (hitEffect != null)
{
findEffectsAndChange(hitEffect.m_effectPrefabs);
}
EffectList hitTerrainEffect = component.m_itemData.m_shared.m_hitTerrainEffect;
if (hitTerrainEffect != null)
{
findEffectsAndChange(hitTerrainEffect.m_effectPrefabs);
}
EffectList holdStartEffect = component.m_itemData.m_shared.m_holdStartEffect;
if (holdStartEffect != null)
{
findEffectsAndChange(holdStartEffect.m_effectPrefabs);
}
EffectList trailStartEffect = component.m_itemData.m_shared.m_trailStartEffect;
if (trailStartEffect != null)
{
findEffectsAndChange(trailStartEffect.m_effectPrefabs);
}
EffectList blockEffect = component.m_itemData.m_shared.m_blockEffect;
if (blockEffect != null)
{
findEffectsAndChange(blockEffect.m_effectPrefabs);
}
}
}
public void ReplaceFxOnPiece(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
return;
}
Piece component = gameObject.GetComponent<Piece>();
if ((Object)(object)component != (Object)null)
{
EffectList placeEffect = component.m_placeEffect;
if (placeEffect != null)
{
findEffectsAndChange(placeEffect.m_effectPrefabs);
}
}
WearNTear component2 = gameObject.GetComponent<WearNTear>();
if ((Object)(object)component2 != (Object)null)
{
EffectList hitEffect = component2.m_hitEffect;
if (hitEffect != null)
{
findEffectsAndChange(hitEffect.m_effectPrefabs);
}
}
}
private void findEffectsAndChange(EffectData[] effects)
{
if (effects == null || effects.Length == 0)
{
return;
}
foreach (EffectData val in effects)
{
if ((Object)(object)val.m_prefab != (Object)null)
{
string name = ((Object)val.m_prefab).name;
GameObject val2 = allPrefabs.Find((GameObject x) => ((Object)x).name == name);
if (!((Object)(object)val2 == (Object)null))
{
val.m_prefab = val2;
}
}
}
}
}
public class ShaderReplacment
{
public static List<GameObject> prefabsToReplaceShader = new List<GameObject>();
public static List<Material> materialsInPrefabs = new List<Material>();
public string[] shaderlist = new string[49]
{
"Custom/AlphaParticle", "Custom/Blob", "Custom/Bonemass", "Custom/Clouds", "Custom/Creature", "Custom/Decal", "Custom/Distortion", "Custom/Flow", "Custom/FlowOpaque", "Custom/Grass",
"Custom/GuiScroll", "Custom/Heightmap", "Custom/icon", "Custom/InteriorSide", "Custom/LitGui", "Custom/LitParticles", "Custom/mapshader", "Custom/ParticleDecal", "Custom/Piece", "Custom/Player",
"Custom/Rug", "Custom/ShadowBlob", "Custom/SkyboxProcedural", "Custom/SkyObject", "Custom/StaticRock", "Custom/Tar", "Custom/Trilinearmap", "Custom/UI/BGBlur", "Custom/Vegetation", "Custom/Water",
"Custom/WaterBottom", "Custom/WaterMask", "Custom/Yggdrasil", "Custom/Yggdrasil/root", "Hidden/BlitCopyHDRTonemap", "Hidden/Dof/DepthOfFieldHdr", "Hidden/Dof/DX11Dof", "Hidden/Internal-Loading", "Hidden/Internal-UIRDefaultWorld", "Hidden/SimpleClear",
"Hidden/SunShaftsComposite", "Lux Lit Particles/ Bumped", "Lux Lit Particles/ Tess Bumped", "Particles/Standard Surface2", "Particles/Standard Unlit2", "Standard TwoSided", "ToonDeferredShading2017", "Unlit/DepthWrite", "Unlit/Lighting"
};
public static List<Shader> shaders = new List<Shader>();
private static readonly HashSet<Shader> CachedShaders = new HashSet<Shader>();
public static bool debug = true;
public static Shader findShader(string name)
{
Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
if (array.Length == 0)
{
Debug.LogWarning((object)"SHADER LIST IS EMPTY!");
return null;
}
if (debug)
{
}
return shaders.Find((Shader x) => ((Object)x).name == name);
}
public static void ReplaceMaterial(Material material)
{
if ((Object)(object)material == (Object)null)
{
Debug.LogWarning((object)"Material is empty !");
}
else
{
materialsInPrefabs.Add(material);
}
}
public static Shader GetShaderByName(string name)
{
return shaders.Find((Shader x) => ((Object)x).name == name.Trim());
}
public static void debugShaderList(List<Shader> shadersRes)
{
foreach (Shader shadersRe in shadersRes)
{
Debug.LogWarning((object)("SHADER NAME IS: " + ((Object)shadersRe).name));
}
debug = false;
}
public static void Replace(GameObject gameObject)
{
prefabsToReplaceShader.Add(gameObject);
GetMaterialsInPrefab(gameObject);
}
public static void GetMaterialsInPrefab(GameObject gameObject)
{
Renderer[] componentsInChildren = gameObject.GetComponentsInChildren<Renderer>(true);
Renderer[] array = componentsInChildren;
foreach (Renderer val in array)
{
Material[] sharedMaterials = val.sharedMaterials;
if (sharedMaterials == null || sharedMaterials.Length == 0)
{
continue;
}
Material[] array2 = sharedMaterials;
foreach (Material val2 in array2)
{
if ((Object)(object)val2 != (Object)null)
{
materialsInPrefabs.Add(val2);
}
}
}
}
public static void getMeShaders()
{
AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
AssetBundle[] array2 = array;
foreach (AssetBundle val in array2)
{
IEnumerable<Shader> enumerable3;
try
{
IEnumerable<Shader> enumerable2;
if (!val.isStreamedSceneAssetBundle || !Object.op_Implicit((Object)(object)val))
{
IEnumerable<Shader> enumerable = val.LoadAllAssets<Shader>();
enumerable2 = enumerable;
}
else
{
enumerable2 = from shader in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Shader>)val.LoadAsset<Shader>)
where (Object)(object)shader != (Object)null
select shader;
}
enumerable3 = enumerable2;
}
catch (Exception)
{
continue;
}
if (enumerable3 == null)
{
continue;
}
foreach (Shader item in enumerable3)
{
CachedShaders.Add(item);
}
}
}
public static void runMaterialFix()
{
getMeShaders();
shaders.AddRange(CachedShaders);
foreach (Material materialsInPrefab in materialsInPrefabs)
{
if ((Object)(object)materialsInPrefab == (Object)null)
{
Debug.Log((object)"I had a null in list");
continue;
}
Shader shader = materialsInPrefab.shader;
if (!((Object)(object)shader == (Object)null))
{
string name = ((Object)shader).name;
if (!(name == "Standard") && name.Contains("Balrond"))
{
setProperValue(materialsInPrefab, name);
}
}
}
}
private static void setProperValue(Material material, string shaderName)
{
string name = shaderName.Replace("Balrond", "Custom");
name = checkNaming(name);
Shader shaderByName = GetShaderByName(name);
if ((Object)(object)shaderByName == (Object)null)
{
Debug.LogWarning((object)("Shader not found " + name));
}
else
{
material.shader = shaderByName;
}
}
private static string checkNaming(string name)
{
string result = name;
if (name.Contains("Bumped"))
{
result = name.Replace("Custom", "Lux Lit Particles");
}
if (name.Contains("Tess Bumped"))
{
result = name.Replace("Custom", "Lux Lit Particles");
}
if (name.Contains("Standard Surface"))
{
result = name.Replace("Custom", "Particles");
result = result.Replace("Standard Surface2", "Standard Surface");
}
if (name.Contains("Standard Unlit"))
{
result = name.Replace("Custom", "Particles");
result = result.Replace("Standard Unlit", "Standard Unlit2");
result = result.Replace("Standard Unlit22", "Standard Unlit2");
}
return result;
}
}
public class BaseLevelEffectSetupValue
{
public float scale = 1.1f;
public float saturation = 0.5f;
public float hue = -0.1f;
public float value = -0.1f;
public LevelSetup setup = null;
public GameObject enabledObject = null;
public GameObject enabledObjectLevel2 = null;
public GameObject enabledObjectLevel3 = null;
public bool setEmmisive = false;
public Color emissive = Color.white;
public float sumValue = 0.05f;
public void getSetup(LevelEffects levelEffects)
{
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)levelEffects == (Object)null)
{
Debug.LogWarning((object)"I should not be here i am null");
return;
}
int num = 0;
if (levelEffects.m_levelSetups != null && levelEffects.m_levelSetups.Count > 0)
{
num = levelEffects.m_levelSetups.Count;
setup = levelEffects.m_levelSetups.Last();
}
if (num != 0 && setup != null)
{
scale = setup.m_scale;
saturation = setup.m_saturation;
hue = setup.m_hue;
value = setup.m_value;
enabledObject = setup.m_enableObject;
emissive = setup.m_emissiveColor;
setEmmisive = setup.m_setEmissiveColor;
enabledObjectLevel2 = enabledObject;
enabledObjectLevel3 = enabledObject;
}
else
{
setValues(num, levelEffects);
}
if ((Object)(object)levelEffects.m_character != (Object)null)
{
if (((Object)((Component)levelEffects.m_character).gameObject).name == "Deer")
{
EditDeer(levelEffects);
}
if (((Object)((Component)levelEffects.m_character).gameObject).name == "Boar")
{
EditBoar(levelEffects);
}
}
}
private void EditDeer(LevelEffects levelEffects)
{
GameObject enableObject = levelEffects.m_levelSetups[0].m_enableObject;
GameObject enableObject2 = levelEffects.m_levelSetups[1].m_enableObject;
enabledObjectLevel2 = enableObject;
enabledObjectLevel3 = enableObject2;
Transform parent = enableObject.transform.parent;
GameObject enableObject3 = (enabledObject = ((Component)parent.Find("Antler1")).gameObject);
levelEffects.m_levelSetups[0].m_enableObject = enableObject3;
levelEffects.m_levelSetups[1].m_enableObject = enableObject3;
}
private void EditBoar(LevelEffects gameObject)
{
}
private void setValues(int levels, LevelEffects levelEffects)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
float y = ((Component)levelEffects).transform.localScale.y;
if (levels == 0)
{
scale = y;
saturation = 0f;
hue = 0f;
value = 0f;
}
if (levels == 1)
{
scale = y + 0.05f;
saturation = 0.5f;
hue = -0.05f;
value = -0.05f;
}
if (levels == 2)
{
scale = y + 0.1f;
saturation = 0.5f;
hue = -0.1f;
value = -0.1f;
}
}
}
public class ItemSetBuilder
{
public List<ItemSet> itemSets = new List<ItemSet>();
public List<GameObject> prefabs = new List<GameObject>();
public ModResourceLoader modResourceLoader;
public static readonly List<MaterialPack> materialPacks = new List<MaterialPack>();
public void Setup(List<GameObject> prefabs)
{
this.prefabs = prefabs ?? new List<GameObject>();
}
public void CreateMaterialPacks(ModResourceLoader loader)
{
if (loader == null)
{
Debug.LogWarning((object)"ModResourceLoader is null");
return;
}
modResourceLoader = loader;
if (materialPacks.Count <= 0)
{
BuildPack(loader.loxFace_Default, loader.loxtBody_Default, loader.loxFur_Default, "Lox", "Default");
BuildPack(loader.loxFace_Albino, loader.loxtBody_Albino, loader.loxFur_Albino, "Lox", "Albino");
BuildPack(loader.loxFace_Black, loader.loxtBody_Black, loader.loxFur_Black, "Lox", "Black");
BuildPack(loader.loxFace_Blond, loader.loxtBody_Blond, loader.loxFur_Blond, "Lox", "Blond");
BuildPack(loader.loxFace_DarkBrown, loader.loxtBody_DarkBrown, loader.loxFur_DarkBrown, "Lox", "Brown");
BuildPack(loader.loxFace_Ginger, loader.loxtBody_Ginger, loader.loxFur_Ginger, "Lox", "Ginger");
BuildPack(loader.wolfBody_Default, loader.wolfBody_Default, loader.wolfBody_Default, "Wolf", "Default");
BuildPack(loader.wolfBody_Albino, loader.wolfBody_Albino, loader.wolfBody_Albino, "Wolf", "Albino");
BuildPack(loader.wolfBody_Black, loader.wolfBody_Black, loader.wolfBody_Black, "Wolf", "Black");
BuildPack(loader.wolfBody_DarkBrown, loader.wolfBody_DarkBrown, loader.wolfBody_DarkBrown, "Wolf", "Brown");
BuildPack(loader.wolfBody_Grey, loader.wolfBody_Grey, loader.wolfBody_Grey, "Wolf", "Grey");
BuildPack(loader.deerBody_Default, loader.deerBody_Default, loader.deerBody_Default, "Deer", "Default");
BuildPack(loader.deerBody_Albino, loader.deerBody_Albino, loader.deerBody_Albino, "Deer", "Albino");
BuildPack(loader.deerBody_Red, loader.deerBody_Red, loader.deerBody_Red, "Deer", "Red");
BuildPack(loader.deerBody_DarkBrown, loader.deerBody_DarkBrown, loader.deerBody_DarkBrown, "Deer", "Brown");
BuildPack(loader.deerBody_Grey, loader.deerBody_Grey, loader.deerBody_Grey, "Deer", "Grey");
BuildPack(loader.boarBody_Default, loader.boarBody_Default, loader.boarBody_Default, "Boar", "Default");
BuildPack(loader.boarBody_Grey, loader.boarBody_Grey, loader.boarBody_Grey, "Boar", "Grey");
BuildPack(loader.boarBody_Black, loader.boarBody_Black, loader.boarBody_Black, "Boar", "Black");
BuildPack(loader.boarBody_DarkBrown, loader.boarBody_DarkBrown, loader.boarBody_DarkBrown, "Boar", "Brown");
BuildPack(loader.boarBody_LightBrown, loader.boarBody_LightBrown, loader.boarBody_LightBrown, "Boar", "Brown2");
BuildPack(loader.neckBody_Default, loader.neckBody_Default, loader.neckBody_Default, "Neck", "Default");
BuildPack(loader.neckBody_Albino, loader.neckBody_Albino, loader.neckBody_Albino, "Neck", "Albino");
BuildPack(loader.neckBody_DarkBlue, loader.neckBody_DarkBlue, loader.neckBody_DarkBlue, "Neck", "Dark");
BuildPack(loader.neckBody_DarkGreen, loader.neckBody_DarkGreen, loader.neckBody_DarkGreen, "Neck", "Green");
BuildPack(loader.neckBody_Blue, loader.neckBody_Blue, loader.neckBody_Blue, "Neck", "Blue");
BuildPack(loader.askvinBody_Default, loader.askvinBody_Default, loader.askvinBody_Default, "Asksvin", "Default");
BuildPack(loader.askvinBody_Albino, loader.askvinBody_Albino, loader.askvinBody_Albino, "Asksvin", "Albino");
BuildPack(loader.askvinBody_Black, loader.askvinBody_Black, loader.askvinBody_Black, "Asksvin", "Dark");
BuildPack(loader.askvinBody_Purple, loader.askvinBody_Purple, loader.askvinBody_Purple, "Asksvin", "Purple");
BuildPack(loader.askvinBody_Grey, loader.askvinBody_Grey, loader.askvinBody_Grey, "Asksvin", "Grey");
BuildPack(loader.hareBody_Default, loader.hareBody_Default, loader.hareBody_Default, "Hare", "Default");
BuildPack(loader.hareBody_Albino, loader.hareBody_Albino, loader.hareBody_Albino, "Hare", "Albino");
BuildPack(loader.hareBody_Black, loader.hareBody_Black, loader.hareBody_Black, "Hare", "Black");
BuildPack(loader.hareBody_DarkBlue, loader.hareBody_DarkBlue, loader.hareBody_DarkBlue, "Hare", "Blue");
BuildPack(loader.hareBody_Ginger, loader.hareBody_Ginger, loader.hareBody_Ginger, "Hare", "Ginger");
BuildPack(loader.drakeBody_Default, loader.drakeBody_Default, loader.drakeBody_Default, "Hatchling", "Default");
BuildPack(loader.drakeBody_Red, loader.drakeBody_Red, loader.drakeBody_Red, "Hatchling", "Albino");
BuildPack(loader.drakeBody_DarkBlue, loader.drakeBody_DarkBlue, loader.drakeBody_DarkBlue, "Hatchling", "Blue");
BuildPack(loader.drakeBody_IceBlue, loader.drakeBody_IceBlue, loader.drakeBody_IceBlue, "Hatchling", "Ice");
BuildPack(loader.drakeBody_Purple, loader.drakeBody_Purple, loader.drakeBody_Purple, "Hatchling", "Purple");
BuildPack(loader.serpentBody_Default, loader.serpentBody_Default, loader.serpentBody_Default, "Serpent", "Default");
BuildPack(loader.serpentBody_Albino, loader.serpentBody_Albino, loader.serpentBody_Albino, "Serpent", "Albino");
BuildPack(loader.serpentBody_Black, loader.serpentBody_Black, loader.serpentBody_Black, "Serpent", "Black");
BuildPack(loader.serpentBody_Blue, loader.serpentBody_Blue, loader.serpentBody_Blue, "Serpent", "Blue");
BuildPack(loader.serpentBody_Green, loader.serpentBody_Green, loader.serpentBody_Green, "Serpent", "Green");
BuildPack(loader.serpentBody_Red, loader.serpentBody_Red, loader.serpentBody_Red, "Serpent", "Red");
}
}
private void BuildPack(Material face, Material body, Material body2, string name, string skin)
{
if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)body2 == (Object)null)
{
Debug.LogWarning((object)("Skipping null material pack: " + name + " / " + skin));
}
else
{
materialPacks.Add(new MaterialPack(face, body, body2, name, skin));
}
}
public void SetupFurRandomizerForMonster(GameObject monster)
{
if ((Object)(object)monster == (Object)null)
{
Debug.LogWarning((object)"Monster not found");
}
else if ((Object)(object)monster.GetComponent<FurRandomizer>() == (Object)null)
{
monster.AddComponent<FurRandomizer>();
}
}
}
[Serializable]
public class FurRandomizer : MonoBehaviour
{
private static readonly string[] ModelsToChange = new string[9] { "Wolf", "Lox", "Serpent", "Neck", "Hatchling", "Hare", "Boar", "Deer", "Asksvin" };
private ZNetView m_zview;
private MonsterAI m_monsterAI;
private AnimalAI m_animalAI;
private Humanoid m_humanoid;
public List<MaterialPack> m_materials = new List<MaterialPack>();
private string skinName;
private MaterialPack m_materialPack;
public SkinnedMeshRenderer face;
public SkinnedMeshRenderer body;
public SkinnedMeshRenderer fur;
public static ModResourceLoader modResourceLoader = Launch.modResourceLoader;
private readonly List<MaterialPack> materialPacks = ItemSetBuilder.materialPacks;
private const string ZdoSetKey = "furRandomizerSet";
private const string ZdoActiveKey = "furRandomizerSetActive";
private void Awake()
{
if (!ValidatePrefab())
{
Debug.LogWarning((object)("I should not be randomized: " + ((Object)((Component)this).gameObject).name));
return;
}
if (modResourceLoader == null)
{
Debug.LogWarning((object)"ModResourceLoader is null");
return;
}
if ((Object)(object)modResourceLoader.drakeBody_DarkBlue == (Object)null)
{
Debug.LogWarning((object)"Nothing loaded");
}
m_zview = ((Component)this).GetComponent<ZNetView>();
m_monsterAI = ((Component)this).GetComponent<MonsterAI>();
m_animalAI = ((Component)this).GetComponent<AnimalAI>();
m_humanoid = ((Component)this).GetComponent<Humanoid>();
if ((Object)(object)m_zview == (Object)null || m_zview.m_zdo == null)
{
Debug.LogWarning((object)("Missing ZNetView or ZDO on " + ((Object)((Component)this).gameObject).name));
return;
}
CreateMaterialPacksOnce();
if (SetupFurRandomizerForMonster())
{
if (m_materials == null || m_materials.Count == 0)
{
Debug.LogWarning((object)("Material list is empty for " + ((Object)((Component)this).gameObject).name));
return;
}
bool @bool = m_zview.m_zdo.GetBool("furRandomizerSetActive", false);
PickRandomSet(@bool);
}
}
private bool ValidatePrefab()
{
string value = EditZnetName(((Object)((Component)this).gameObject).name);
return ModelsToChange.Contains(value);
}
private string EditZnetName(string name)
{
name = name.Replace("(Clone)", "");
int num = name.IndexOf("(");
if (num >= 0)
{
name = name.Substring(0, num);
}
return name.Trim();
}
private void PickRandomSet(bool chosen = false)
{
if (m_materials == null || m_materials.Count == 0)
{
Debug.LogWarning((object)("No material packs available for " + ((Object)((Component)this).gameObject).name));
return;
}
int num = -1;
if (chosen)
{
num = m_zview.m_zdo.GetInt("furRandomizerSet", 0);
}
if (!chosen || num < 0 || num >= m_materials.Count)
{
num = Random.Range(0, m_materials.Count);
}
m_zview.m_zdo.Set("furRandomizerSet", num);
m_zview.m_zdo.Set("furRandomizerSetActive", true);
MaterialPack materialPack = m_materials[num];
skinName = materialPack.skin;
m_materialPack = materialPack;
SetSkin(materialPack);
}
private void SetSkin(MaterialPack pack)
{
switch (EditZnetName(((Object)((Component)this).gameObject).name))
{
case "Lox":
ApplyLoxMaterials(pack);
break;
case "Hare":
case "Serpent":
case "Neck":
case "Wolf":
case "Boar":
case "Deer":
case "Asksvin":
ApplySingleRendererMaterial(body, pack.face);
break;
case "Hatchling":
ApplyHatchlingMaterials(pack);
break;
}
}
private void ApplyLoxMaterials(MaterialPack pack)
{
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Expected O, but got Unknown
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Expected O, but got Unknown
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Expected O, but got Unknown
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Expected O, but got Unknown
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Expected O, but got Unknown
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
//IL_0185: Expected O, but got Unknown
if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)fur == (Object)null)
{
Debug.LogWarning((object)("Lox renderers missing on " + ((Object)((Component)this).gameObject).name));
return;
}
Material[] materials = ((Renderer)face).materials;
if (materials.Length != 0)
{
materials[0] = new Material(pack.body);
((Renderer)face).materials = materials;
}
Material[] materials2 = ((Renderer)body).materials;
if (materials2.Length != 0)
{
materials2[0] = new Material(pack.body);
((Renderer)body).materials = materials2;
}
Material[] materials3 = ((Renderer)fur).materials;
if (materials3.Length != 0)
{
materials3[0] = new Material(pack.body2);
((Renderer)fur).materials = materials3;
}
Material[] sharedMaterials = ((Renderer)face).sharedMaterials;
if (sharedMaterials.Length > 1)
{
sharedMaterials[1] = new Material(pack.face);
((Renderer)face).sharedMaterials = sharedMaterials;
}
Material[] sharedMaterials2 = ((Renderer)body).sharedMaterials;
if (sharedMaterials2.Length != 0)
{
sharedMaterials2[0] = new Material(pack.body);
((Renderer)body).sharedMaterials = sharedMaterials2;
}
Material[] sharedMaterials3 = ((Renderer)fur).sharedMaterials;
if (sharedMaterials3.Length != 0)
{
sharedMaterials3[0] = new Material(pack.body2);
((Renderer)fur).sharedMaterials = sharedMaterials3;
}
}
private void ApplyHatchlingMaterials(MaterialPack pack)
{
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Expected O, but got Unknown
if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)fur == (Object)null)
{
Debug.LogWarning((object)("Hatchling renderers missing on " + ((Object)((Component)this).gameObject).name));
return;
}
Material[] materials = ((Renderer)face).materials;
if (materials.Length != 0)
{
materials[0] = new Material(pack.body);
}
((Renderer)face).materials = materials;
((Renderer)body).materials = materials;
((Renderer)fur).materials = materials;
((Renderer)face).sharedMaterials = materials;
((Renderer)body).sharedMaterials = materials;
((Renderer)fur).sharedMaterials = materials;
}
private void ApplySingleRendererMaterial(SkinnedMeshRenderer renderer, Material source)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Expected O, but got Unknown
if ((Object)(object)renderer == (Object)null || (Object)(object)source == (Object)null)
{
Debug.LogWarning((object)("Renderer or source material missing on " + ((Object)((Component)this).gameObject).name));
return;
}
((Renderer)renderer).sharedMaterial = new Material(source);
((Renderer)renderer).material = new Material(source);
}
private void CreateMaterialPacksOnce()
{
if (materialPacks == null)
{
Debug.LogWarning((object)"materialPacks list is null");
}
else if (materialPacks.Count <= 0)
{
BuildPack(modResourceLoader.loxFace_Default, modResourceLoader.loxtBody_Default, modResourceLoader.loxFur_Default, "Lox", "Default");
BuildPack(modResourceLoader.loxFace_Albino, modResourceLoader.loxtBody_Albino, modResourceLoader.loxFur_Albino, "Lox", "Albino");
BuildPack(modResourceLoader.loxFace_Black, modResourceLoader.loxtBody_Black, modResourceLoader.loxFur_Black, "Lox", "Black");
BuildPack(modResourceLoader.loxFace_Blond, modResourceLoader.loxtBody_Blond, modResourceLoader.loxFur_Blond, "Lox", "Blond");
BuildPack(modResourceLoader.loxFace_DarkBrown, modResourceLoader.loxtBody_DarkBrown, modResourceLoader.loxFur_DarkBrown, "Lox", "Brown");
BuildPack(modResourceLoader.loxFace_Ginger, modResourceLoader.loxtBody_Ginger, modResourceLoader.loxFur_Ginger, "Lox", "Ginger");
BuildPack(modResourceLoader.wolfBody_Default, modResourceLoader.wolfBody_Default, modResourceLoader.wolfBody_Default, "Wolf", "Default");
BuildPack(modResourceLoader.wolfBody_Albino, modResourceLoader.wolfBody_Albino, modResourceLoader.wolfBody_Albino, "Wolf", "Albino");
BuildPack(modResourceLoader.wolfBody_Black, modResourceLoader.wolfBody_Black, modResourceLoader.wolfBody_Black, "Wolf", "Black");
BuildPack(modResourceLoader.wolfBody_DarkBrown, modResourceLoader.wolfBody_DarkBrown, modResourceLoader.wolfBody_DarkBrown, "Wolf", "Brown");
BuildPack(modResourceLoader.wolfBody_Grey, modResourceLoader.wolfBody_Grey, modResourceLoader.wolfBody_Grey, "Wolf", "Grey");
BuildPack(modResourceLoader.neckBody_Default, modResourceLoader.neckBody_Default, modResourceLoader.neckBody_Default, "Neck", "Default");
BuildPack(modResourceLoader.neckBody_Albino, modResourceLoader.neckBody_Albino, modResourceLoader.neckBody_Albino, "Neck", "Albino");
BuildPack(modResourceLoader.neckBody_DarkBlue, modResourceLoader.neckBody_DarkBlue, modResourceLoader.neckBody_DarkBlue, "Neck", "Dark");
BuildPack(modResourceLoader.neckBody_DarkGreen, modResourceLoader.neckBody_DarkGreen, modResourceLoader.neckBody_DarkGreen, "Neck", "Green");
BuildPack(modResourceLoader.neckBody_Blue, modResourceLoader.neckBody_Blue, modResourceLoader.neckBody_Blue, "Neck", "Blue");
BuildPack(modResourceLoader.hareBody_Default, modResourceLoader.hareBody_Default, modResourceLoader.hareBody_Default, "Hare", "Default");
BuildPack(modResourceLoader.hareBody_Albino, modResourceLoader.hareBody_Albino, modResourceLoader.hareBody_Albino, "Hare", "Albino");
BuildPack(modResourceLoader.hareBody_Black, modResourceLoader.hareBody_Black, modResourceLoader.hareBody_Black, "Hare", "Black");
BuildPack(modResourceLoader.hareBody_DarkBlue, modResourceLoader.hareBody_DarkBlue, modResourceLoader.hareBody_DarkBlue, "Hare", "Blue");
BuildPack(modResourceLoader.hareBody_Ginger, modResourceLoader.hareBody_Ginger, modResourceLoader.hareBody_Ginger, "Hare", "Ginger");
BuildPack(modResourceLoader.drakeBody_Default, modResourceLoader.drakeBody_Default, modResourceLoader.drakeBody_Default, "Hatchling", "Default");
BuildPack(modResourceLoader.drakeBody_Red, modResourceLoader.drakeBody_Red, modResourceLoader.drakeBody_Red, "Hatchling", "Albino");
BuildPack(modResourceLoader.drakeBody_DarkBlue, modResourceLoader.drakeBody_DarkBlue, modResourceLoader.drakeBody_DarkBlue, "Hatchling", "Blue");
BuildPack(modResourceLoader.drakeBody_IceBlue, modResourceLoader.drakeBody_IceBlue, modResourceLoader.drakeBody_IceBlue, "Hatchling", "Ice");
BuildPack(modResourceLoader.drakeBody_Purple, modResourceLoader.drakeBody_Purple, modResourceLoader.drakeBody_Purple, "Hatchling", "Purple");
BuildPack(modResourceLoader.serpentBody_Default, modResourceLoader.serpentBody_Default, modResourceLoader.serpentBody_Default, "Serpent", "Default");
BuildPack(modResourceLoader.serpentBody_Albino, modResourceLoader.serpentBody_Albino, modResourceLoader.serpentBody_Albino, "Serpent", "Albino");
BuildPack(modResourceLoader.serpentBody_Black, modResourceLoader.serpentBody_Black, modResourceLoader.serpentBody_Black, "Serpent", "Black");
BuildPack(modResourceLoader.serpentBody_Blue, modResourceLoader.serpentBody_Blue, modResourceLoader.serpentBody_Blue, "Serpent", "Blue");
BuildPack(modResourceLoader.serpentBody_Green, modResourceLoader.serpentBody_Green, modResourceLoader.serpentBody_Green, "Serpent", "Green");
BuildPack(modResourceLoader.serpentBody_Red, modResourceLoader.serpentBody_Red, modResourceLoader.serpentBody_Red, "Serpent", "Red");
BuildPack(modResourceLoader.askvinBody_Default, modResourceLoader.askvinBody_Default, modResourceLoader.askvinBody_Default, "Asksvin", "Default");
BuildPack(modResourceLoader.askvinBody_Albino, modResourceLoader.askvinBody_Albino, modResourceLoader.askvinBody_Albino, "Asksvin", "Albino");
BuildPack(modResourceLoader.askvinBody_Black, modResourceLoader.askvinBody_Black, modResourceLoader.askvinBody_Black, "Asksvin", "Dark");
BuildPack(modResourceLoader.askvinBody_Purple, modResourceLoader.askvinBody_Purple, modResourceLoader.askvinBody_Purple, "Asksvin", "Purple");
BuildPack(modResourceLoader.askvinBody_Grey, modResourceLoader.askvinBody_Grey, modResourceLoader.askvinBody_Grey, "Asksvin", "Grey");
BuildPack(modResourceLoader.deerBody_Default, modResourceLoader.deerBody_Default, modResourceLoader.deerBody_Default, "Deer", "Default");
BuildPack(modResourceLoader.deerBody_Albino, modResourceLoader.deerBody_Albino, modResourceLoader.deerBody_Albino, "Deer", "Albino");
BuildPack(modResourceLoader.deerBody_Red, modResourceLoader.deerBody_Red, modResourceLoader.deerBody_Red, "Deer", "Red");
BuildPack(modResourceLoader.deerBody_DarkBrown, modResourceLoader.deerBody_DarkBrown, modResourceLoader.deerBody_DarkBrown, "Deer", "Brown");
BuildPack(modResourceLoader.deerBody_Grey, modResourceLoader.deerBody_Grey, modResourceLoader.deerBody_Grey, "Deer", "Grey");
BuildPack(modResourceLoader.boarBody_Default, modResourceLoader.boarBody_Default, modResourceLoader.boarBody_Default, "Boar", "Default");
BuildPack(modResourceLoader.boarBody_Grey, modResourceLoader.boarBody_Grey, modResourceLoader.boarBody_Grey, "Boar", "Grey");
BuildPack(modResourceLoader.boarBody_Black, modResourceLoader.boarBody_Black, modResourceLoader.boarBody_Black, "Boar", "Black");
BuildPack(modResourceLoader.boarBody_DarkBrown, modResourceLoader.boarBody_DarkBrown, modResourceLoader.boarBody_DarkBrown, "Boar", "Brown");
BuildPack(modResourceLoader.boarBody_LightBrown, modResourceLoader.boarBody_LightBrown, modResourceLoader.boarBody_LightBrown, "Boar", "Brown2");
}
}
private void BuildPack(Material face, Material body, Material body2, string name, string skin)
{
if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)body2 == (Object)null)
{
Debug.LogWarning((object)("Skipping null material pack: " + name + " / " + skin));
}
else
{
materialPacks.Add(new MaterialPack(face, body, body2, name, skin));
}
}
private bool SetupFurRandomizerForMonster()
{
string name = EditZnetName(((Object)((Component)this).gameObject).name);
m_materials = materialPacks.FindAll((MaterialPack x) => x.animal == name);
switch (name)
{
case "Lox":
{
Transform[] componentsInChildren4 = ((Component)this).gameObject.GetComponentsInChildren<Transform>(true);
foreach (Transform val4 in componentsInChildren4)
{
if (((Object)((Component)val4).gameObject).name == "Body")
{
SkinnedMeshRenderer component4 = ((Component)val4).GetComponent<SkinnedMeshRenderer>();
if ((Object)(object)component4 != (Object)null)
{
face = component4;
body = component4;
}
}
else if (((Object)((Component)val4).gameObject).name == "Furr1")
{
SkinnedMeshRenderer component5 = ((Component)val4).GetComponent<SkinnedMeshRenderer>();
if ((Object)(object)component5 != (Object)null)
{
fur = component5;
}
}
}
break;
}
case "Hatchling":
{
Transform[] componentsInChildren2 = ((Component)this).gameObject.GetComponentsInChildren<Transform>(true);
foreach (Transform val2 in componentsInChildren2)
{
if (((Object)((Component)val2).gameObject).name == "Hatchling")
{
SkinnedMeshRenderer component = ((Component)val2).GetComponent<SkinnedMeshRenderer>();
if ((Object)(object)component != (Object)null)
{
body = component;
face = ((Component)this).gameObject.GetComponentInChildren<SkinnedMeshRenderer>(true);
}
}
else if (((Object)((Component)val2).gameObject).name == "Hatchling.001")
{
SkinnedMeshRenderer component2 = ((Component)val2).GetComponent<SkinnedMeshRenderer>();
if ((Object)(object)component2 != (Object)null)
{
fur = component2;
}
}
}
break;
}
case "Neck":
{
Transform[] componentsInChildren3 = ((Component)this).gameObject.GetComponentsInChildren<Transform>(true);
foreach (Transform val3 in componentsInChildren3)
{
if (((Object)((Component)val3).gameObject).name == "Body")
{
SkinnedMeshRenderer component3 = ((Component)val3).GetComponent<SkinnedMeshRenderer>();
if ((Object)(object)component3 != (Object)null)
{
face = component3;
body = component3;
fur = component3;
}
}
}
break;
}
case "Boar":
{
SkinnedMeshRenderer[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>(true);
foreach (SkinnedMeshRenderer val in componentsInChildren)
{
if (((Object)val).name == "Poly Art Boar")
{
face = val;
body = val;
fur = val;
break;
}
}
break;
}
case "Asksvin":
case "Deer":
case "Serpent":
case "Wolf":
case "Hare":
fur = (body = (face = ((Component)this).gameObject.GetComponentInChildren<SkinnedMeshRenderer>(true)));
break;
}
if ((Object)(object)face == (Object)null || (Object)(object)body == (Object)null || (Object)(object)fur == (Object)null)
{
Debug.LogWarning((object)("Couldn't find renderers for " + ((Object)((Component)this).gameObject).name));
return false;
}
return true;
}
}
public class LevelEffectGenerator
{
private BaseLevelEffectSetupValue baseLevelEffectSetupValue = new BaseLevelEffectSetupValue();
public void CreateVisuals(LevelEffects levelEffects)
{
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
baseLevelEffectSetupValue.getSetup(levelEffects);
int num = 0;
if (levelEffects.m_levelSetups != null)
{
num = levelEffects.m_levelSetups.Count;
}
int num2 = 6 - num;
for (int i = 0; i < num2; i++)
{
LevelSetup item = createSetup(baseLevelEffectSetupValue.scale, baseLevelEffectSetupValue.saturation, baseLevelEffectSetupValue.hue, baseLevelEffectSetupValue.value, baseLevelEffectSetupValue.setEmmisive, baseLevelEffectSetupValue.emissive, baseLevelEffectSetupValue.sumValue * (float)(i + 1), num2, i + 1);
levelEffects.m_levelSetups.Add(item);
}
}
public LevelEffects CreateLevelEffectAt(Transform visual, SkinnedMeshRenderer meshRenderer)
{
if ((Object)(object)meshRenderer == (Object)null)
{
return null;
}
if ((Object)(object)meshRenderer != (Object)null)
{
LevelEffects val = ((Component)visual).gameObject.AddComponent<LevelEffects>();
val.m_mainRender = (Renderer)(object)meshRenderer;
val.m_character = (Character)(object)((Component)visual.parent).gameObject.GetComponent<Humanoid>();
return val;
}
return null;
}
public LevelEffects CreateLevelEffectComponent(Transform visual)
{
SkinnedMeshRenderer[] componentsInChildren = ((Component)visual).GetComponentsInChildren<SkinnedMeshRenderer>();
if (componentsInChildren.Length > 1)
{
Debug.LogWarning((object)("To many renderers to create Visual Effects:" + ((Object)visual.parent).name));
return null;
}
if (componentsInChildren.Length == 1)
{
LevelEffects val = ((Component)visual).gameObject.AddComponent<LevelEffects>();
val.m_mainRender = (Renderer)(object)componentsInChildren[0];
val.m_character = (Character)(object)((Component)visual.parent).gameObject.GetComponent<Humanoid>();
return val;
}
return null;
}
private LevelSetup createSetup(float scale, float saturation, float hue, float value, bool isEmmisive, Color emission, float changeValue, int maxAmount, int lvl)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: 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_006e: 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)
LevelSetup val = new LevelSetup();
val.m_scale = scale + changeValue;
val.m_saturation = saturation + changeValue;
val.m_hue = hue + changeValue;
val.m_value = value + changeValue;
val.m_enableObject = pickEnabledObject(maxAmount, lvl);
val.m_setEmissiveColor = isEmmisive;
val.m_emissiveColor = new Color(emission.r + changeValue, emission.g + changeValue, emission.b + changeValue, emission.a);
return val;
}
private GameObject pickEnabledObject(int maxAmount, int lvl)
{
if (maxAmount == 6)
{
if (lvl > 4)
{
return baseLevelEffectSetupValue.enabledObjectLevel3;
}
if (lvl > 2)
{
return baseLevelEffectSetupValue.enabledObjectLevel2;
}
}
if (maxAmount == 3)
{
if (lvl > 3)
{
return baseLevelEffectSetupValue.enabledObjectLevel3;
}
if (lvl > 2)
{
return baseLevelEffectSetupValue.enabledObjectLevel2;
}
}
if (maxAmount < 3)
{
switch (lvl)
{
case 2:
return baseLevelEffectSetupValue.enabledObjectLevel3;
case 1:
return baseLevelEffectSetupValue.enabledObjectLevel2;
}
}
return baseLevelEffectSetupValue.enabledObject;
}
}
[Serializable]
public class MaterialPack
{
public Material face;
public Material body;
public Material body2;
public string animal;
public string skin;
public MaterialPack(Material body, Material body2, Material face, string monsterName, string skinName)
{
animal = monsterName;
this.face = face;
this.body = body;
this.body2 = body2;
skin = skinName;
}
}
public class DatabaseAddMethods
{
public void AddItems(List<GameObject> items)
{
foreach (GameObject item in items)
{
AddItem(item);
}
}
public void AddRecipes(List<Recipe> recipes)
{
foreach (Recipe recipe in recipes)
{
AddRecipe(recipe);
}
}
public void AddStatuseffects(List<StatusEffect> statusEffects)
{
foreach (StatusEffect statusEffect in statusEffects)
{
AddStatus(statusEffect);
}
}
private bool IsObjectDBValid()
{
return (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count != 0 && ObjectDB.instance.m_recipes.Count != 0 && (Object)(object)ObjectDB.instance.GetItemPrefab("Amber") != (Object)null;
}
private void AddStatus(StatusEffect status)
{
if (!IsObjectDBValid())
{
return;
}
if ((Object)(object)status != (Object)null)
{
if ((Object)(object)ObjectDB.instance.GetStatusEffect(((object)status).GetHashCode()) == (Object)null)
{
ObjectDB.instance.m_StatusEffects.Add(status);
}
}
else
{
Debug.LogError((object)("BalrondFurRandomizer: " + ((Object)status).name + " - Status not found"));
}
}
private void AddRecipe(Recipe recipe)
{
if (!IsObjectDBValid())
{
return;
}
if ((Object)(object)recipe != (Object)null)
{
if ((Object)(object)ObjectDB.instance.GetRecipe(recipe.m_item.m_itemData) == (Object)null)
{
ObjectDB.instance.m_recipes.Add(recipe);
}
}
else
{
Debug.LogError((object)("BalrondFurRandomizer: " + ((Object)recipe).name + " - Recipe not found"));
}
}
private void AddItem(GameObject newPrefab)
{
if (!IsObjectDBValid())
{
return;
}
ItemDrop component = newPrefab.GetComponent<ItemDrop>();
if ((Object)(object)component != (Object)null)
{
if ((Object)(object)ObjectDB.instance.GetItemPrefab(((Object)newPrefab).name) == (Object)null)
{
ObjectDB.instance.m_items.Add(newPrefab);
Dictionary<int, GameObject> dictionary = (Dictionary<int, GameObject>)typeof(ObjectDB).GetField("m_itemByHash", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(ObjectDB.instance);
dictionary[((Object)newPrefab).name.GetHashCode()] = newPrefab;
}
}
else
{
Debug.LogError((object)("BalrondFurRandomizer: " + ((Object)newPrefab).name + " - ItemDrop not found on prefab"));
}
}
}
[BepInPlugin("balrond.astafaraios.BalrondFurRandomizer", "BalrondFurRandomizer", "1.0.7")]
public class Launch : BaseUnityPlugin
{
[HarmonyPatch(typeof(Game), "Awake")]
public static class Game_Awake_Patch
{
public static void Prefix()
{
ZNetScene_Awake_Patch.hasSpawned = false;
}
}
[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
public static class ObjectDB_CopyOtherDB_Patch
{
public static void Postfix()
{
if (IsObjectDBValid())
{
}
}
}
[HarmonyPatch(typeof(ObjectDB), "Awake")]
public static class ObjectDB_Awake_Patch
{
public static void Postfix()
{
if (IsObjectDBValid())
{
}
}
}
[HarmonyPatch(typeof(Character), "OnDeath")]
public static class Character_OnDeath_Patch
{
public static void Prefix(Character __instance)
{
if ((Object)(object)__instance == (Object)null)
{
Debug.LogWarning((object)"Character instance does not exist yet");
}
else
{
if (__instance.m_deathEffects == null || __instance.m_deathEffects.m_effectPrefabs == null)
{
return;
}
LevelEffects componentInChildren = ((Component)__instance).GetComponentInChildren<LevelEffects>();
if ((Object)(object)componentInChildren == (Object)null || (Object)(object)componentInChildren.m_mainRender == (Object)null)
{
return;
}
Material[] sharedMaterials = componentInChildren.m_mainRender.sharedMaterials;
if (sharedMaterials == null || sharedMaterials.Length == 0)
{
return;
}
EffectData[] effectPrefabs = __instance.m_deathEffects.m_effectPrefabs;
foreach (EffectData val in effectPrefabs)
{
if (val != null && !((Object)(object)val.m_prefab == (Object)null))
{
Ragdoll component = val.m_prefab.GetComponent<Ragdoll>();
if ((Object)(object)component != (Object)null && (Object)(object)component.m_mainModel != (Object)null)
{
component.m_mainModel.sharedMaterials = sharedMaterials;
}
}
}
}
}
}
[HarmonyPatch(typeof(LevelEffects), "SetupLevelVisualization")]
public static class LevelEffects_SetupLevelVisualization_Patch
{
public static bool Prefix(LevelEffects __instance, int level)
{
//IL_005e: 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_00b9: Expected O, but got Unknown
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null)
{
return false;
}
if (level <= 1 || __instance.m_levelSetups.Count < level - 1)
{
return false;
}
LevelSetup val = __instance.m_levelSetups[level - 2];
((Component)__instance).transform.localScale = new Vector3(val.m_scale, val.m_scale, val.m_scale);
if ((Object)(object)__instance.m_mainRender != (Object)null)
{
Material[] sharedMaterials = __instance.m_mainRender.sharedMaterials;
if (sharedMaterials != null && sharedMaterials.Length != 0 && (Object)(object)sharedMaterials[0] != (Object)null)
{
sharedMaterials[0] = new Material(sharedMaterials[0]);
sharedMaterials[0].SetFloat("_Hue", val.m_hue);
sharedMaterials[0].SetFloat("_Saturation", val.m_saturation);
sharedMaterials[0].SetFloat("_Value", val.m_value);
if (val.m_setEmissiveColor)
{
sharedMaterials[0].SetColor("_EmissionColor", val.m_emissiveColor);
}
__instance.m_mainRender.sharedMaterials = sharedMaterials;
if ((Object)(object)__instance.m_character != (Object)null)
{
string key = Utils.GetPrefabName(((Component)__instance.m_character).gameObject) + level;
LevelEffects.m_materials[key] = sharedMaterials[0];
}
}
}
if ((Object)(object)__instance.m_baseEnableObject != (Object)null)
{
__instance.m_baseEnableObject.SetActive(false);
}
if ((Object)(object)val.m_enableObject != (Object)null)
{
val.m_enableObject.SetActive(true);
}
return false;
}
}
[HarmonyPatch(typeof(ZNetScene), "Awake")]
public static class ZNetScene_Awake_Patch
{
public static bool hasSpawned;
public static void Prefix(ZNetScene __instance)
{
if ((Object)(object)__instance == (Object)null)
{
Debug.LogWarning((object)"BalrondFurRandomizer: No ZNetScene found");
}
else if (!hasSpawned)
{
itemSetBuilder.CreateMaterialPacks(modResourceLoader);
SetupFurRandomizers(__instance.m_prefabs);
if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsDedicated())
{
hasSpawned = true;
return;
}
ShaderReplacment.runMaterialFix();
hasSpawned = true;
}
}
private static void SetupFurRandomizers(List<GameObject> prefabs)
{
if (prefabs == null || prefabs.Count == 0)
{
Debug.LogWarning((object)"BalrondFurRandomizer: Prefab list is empty");
return;
}
string[] array = new string[9] { "Wolf", "Neck", "Hare", "Serpent", "Hatchling", "Lox", "Deer", "Boar", "Asksvin" };
string[] array2 = array;
foreach (string targetName in array2)
{
GameObject monster = prefabs.Find((GameObject x) => (Object)(object)x != (Object)null && ((Object)x).name == targetName);
itemSetBuilder.SetupFurRandomizerForMonster(monster);
}
}
}
private readonly Harmony harmony = new Harmony("balrond.astafaraios.BalrondFurRandomizer");
public const string PluginGUID = "balrond.astafaraios.BalrondFurRandomizer";
public const string PluginName = "BalrondFurRandomizer";
public const string PluginVersion = "1.0.7";
public static ModResourceLoader modResourceLoader = new ModResourceLoader();
public static DatabaseAddMethods databaseAddMethods = new DatabaseAddMethods();
public static MonsterManager monsterManager = new MonsterManager();
public static ItemSetBuilder itemSetBuilder = new ItemSetBuilder();
public static GameObject gui;
public static GameObject gui2;
public static GameObject RootObject;
public static GameObject PrefabContainer;
private void Awake()
{
CreatePrefabContainer();
modResourceLoader.loadAssets();
harmony.PatchAll();
}
private void OnDestroy()
{
harmony.UnpatchSelf();
}
public void CreatePrefabContainer()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
if (!((Object)(object)RootObject != (Object)null) || !((Object)(object)PrefabContainer != (Object)null))
{
RootObject = new GameObject("_ValheimReforgedRoot");
Object.DontDestroyOnLoad((Object)(object)RootObject);
PrefabContainer = new GameObject("Prefabs");
PrefabContainer.transform.SetParent(RootObject.transform, false);
PrefabContainer.SetActive(false);
}
}
public static GameObject CloneMe(GameObject source, string name)
{
if ((Object)(object)source == (Object)null)
{
Debug.LogWarning((object)"BalrondFurRandomizer: CloneMe source is null");
return null;
}
if ((Object)(object)PrefabContainer == (Object)null)
{
Debug.LogWarning((object)"BalrondFurRandomizer: PrefabContainer is null");
return null;
}
GameObject val = Object.Instantiate<GameObject>(source, PrefabContainer.transform);
((Object)val).name = name;
return val;
}
private static bool IsObjectDBValid()
{
return (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items != null && ObjectDB.instance.m_recipes != null && ObjectDB.instance.m_items.Count != 0 && ObjectDB.instance.m_recipes.Count != 0 && (Object)(object)ObjectDB.instance.GetItemPrefab("Amber") != (Object)null;
}
public static void AddStatusToAttackField(GameObject gameObject, StatusEffect statusEffect)
{
if (!((Object)(object)gameObject == (Object)null) && !((Object)(object)statusEffect == (Object)null))
{
ItemDrop component = gameObject.GetComponent<ItemDrop>();
if ((Object)(object)component == (Object)null)
{
Debug.LogWarning((object)("BalrondFurRandomizer: ItemDrop not found on " + ((Object)gameObject).name));
}
else
{
component.m_itemData.m_shared.m_attackStatusEffect = statusEffect;
}
}
}
}
public class ModResourceLoader
{
public AssetBundle assetBundle;
public Material loxFace_Default;
public Material loxtBody_Default;
public Material loxFur_Default;
public Material loxFace_Albino;
public Material loxtBody_Albino;
public Material loxFur_Albino;
public Material loxFace_Black;
public Material loxtBody_Black;
public Material loxFur_Black;
public Material loxFace_Blond;
public Material loxtBody_Blond;
public Material loxFur_Blond;
public Material loxFace_DarkBrown;
public Material loxtBody_DarkBrown;
public Material loxFur_DarkBrown;
public Material loxFace_Ginger;
public Material loxtBody_Ginger;
public Material loxFur_Ginger;
public Material wolfBody_Default;
public Material wolfBody_Albino;
public Material wolfBody_Black;
public Material wolfBody_DarkBrown;
public Material wolfBody_Grey;
public Material boarBody_Default;
public Material boarBody_Grey;
public Material boarBody_Black;
public Material boarBody_DarkBrown;
public Material boarBody_LightBrown;
public Material askvinBody_Default;
public Material askvinBody_Albino;
public Material askvinBody_Purple;
public Material askvinBody_Black;
public Material askvinBody_Grey;
public Material deerBody_Default;
public Material deerBody_Albino;
public Material deerBody_Red;
public Material deerBody_DarkBrown;
public Material deerBody_Grey;
public Material neckBody_Default;
public Material neckBody_Albino;
public Material neckBody_Blue;
public Material neckBody_DarkBlue;
public Material neckBody_DarkGreen;
public Material hareBody_Default;
public Material hareBody_Albino;
public Material hareBody_Black;
public Material hareBody_DarkBlue;
public Material hareBody_Ginger;
public Material drakeBody_Default;
public Material drakeBody_DarkBlue;
public Material drakeBody_IceBlue;
public Material drakeBody_Purple;
public Material drakeBody_Red;
public Material serpentBody_Default;
public Material serpentBody_Albino;
public Material serpentBody_Black;
public Material serpentBody_Blue;
public Material serpentBody_Green;
public Material serpentBody_Red;
public void loadAssets()
{
assetBundle = GetAssetBundleFromResources("furrandomizer");
string text = "Assets/BalrondFurRandomizer/";
Material temp = assetBundle.LoadAsset<Material>(text + "Lox/Default/lox_face.mat");
CreateLoxMaterial(temp, text);
CreateWolfMaterial(temp, text);
CreateNeckMaterial(temp, text);
CreateHareMaterial(temp, text);
CreateDrakeMaterial(temp, text);
CreateSerpentMaterials(temp, text);
CreateAskvinMaterial(temp, text);
CreateBoarMaterial(temp, text);
CreateDeerMaterial(temp, text);
}
private void CreateLoxMaterial(Material temp, string mainPath)
{
ShaderReplacment.ReplaceMaterial(temp);
loxFace_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Default/lox_body1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxtBody_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Default/lox_fur1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFur_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Albino/lox_face.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFace_Albino = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Albino/lox_body1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxtBody_Albino = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Albino/lox_fur1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFur_Albino = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Black/lox_face.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFace_Black = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Black/lox_body1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxtBody_Black = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Black/lox_fur1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFur_Black = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Blonde/lox_face.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFace_Blond = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Blonde/lox_body1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxtBody_Blond = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Blonde/lox_fur1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFur_Blond = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/DarkBrown/lox_face.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFace_DarkBrown = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/DarkBrown/lox_body1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxtBody_DarkBrown = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/DarkBrown/lox_fur1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFur_DarkBrown = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Ginger/lox_face.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFace_Ginger = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Ginger/lox_body1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxtBody_Ginger = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Lox/Ginger/lox_fur1.mat");
ShaderReplacment.ReplaceMaterial(temp);
loxFur_Ginger = temp;
}
private void CreateWolfMaterial(Material temp, string mainPath)
{
temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/Default/wolfMat.mat");
ShaderReplacment.ReplaceMaterial(temp);
wolfBody_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/Albino/wolfMat.mat");
ShaderReplacment.ReplaceMaterial(temp);
wolfBody_Albino = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/Black/wolfMat.mat");
ShaderReplacment.ReplaceMaterial(temp);
wolfBody_Black = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/DarkBrown/wolfMat.mat");
ShaderReplacment.ReplaceMaterial(temp);
wolfBody_DarkBrown = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Wolf/Grey/wolfMat.mat");
ShaderReplacment.ReplaceMaterial(temp);
wolfBody_Grey = temp;
}
private void CreateBoarMaterial(Material temp, string mainPath)
{
temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/Default/Material_default.mat");
ShaderReplacment.ReplaceMaterial(temp);
boarBody_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/Grey/Material_grey.mat");
ShaderReplacment.ReplaceMaterial(temp);
boarBody_Grey = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/Black/Material_black.mat");
ShaderReplacment.ReplaceMaterial(temp);
boarBody_Black = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/DarkBrown/Material_darkBrown.mat");
ShaderReplacment.ReplaceMaterial(temp);
boarBody_DarkBrown = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Boar/Young/Material_young.mat");
ShaderReplacment.ReplaceMaterial(temp);
boarBody_LightBrown = temp;
}
private void CreateDeerMaterial(Material temp, string mainPath)
{
temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/Default/Deer_default.mat");
ShaderReplacment.ReplaceMaterial(temp);
deerBody_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/Albino/Deer_albino.mat");
ShaderReplacment.ReplaceMaterial(temp);
deerBody_Albino = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/Red/Deer_red.mat");
ShaderReplacment.ReplaceMaterial(temp);
deerBody_Red = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/LightBrown/Deer_brown.mat");
ShaderReplacment.ReplaceMaterial(temp);
deerBody_DarkBrown = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Deer/Grey/Deer_gray.mat");
ShaderReplacment.ReplaceMaterial(temp);
deerBody_Grey = temp;
}
private void CreateAskvinMaterial(Material temp, string mainPath)
{
temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Default/asksvin_Mat_default.mat");
ShaderReplacment.ReplaceMaterial(temp);
askvinBody_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Albino/asksvin_Mat_albino.mat");
ShaderReplacment.ReplaceMaterial(temp);
askvinBody_Albino = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Purple/asksvin_Mat_purple.mat");
ShaderReplacment.ReplaceMaterial(temp);
askvinBody_Purple = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Black/asksvin_Mat_black.mat");
ShaderReplacment.ReplaceMaterial(temp);
askvinBody_Black = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Askvin/Young/asksvincub_Mat_young.mat");
ShaderReplacment.ReplaceMaterial(temp);
askvinBody_Grey = temp;
}
private void CreateNeckMaterial(Material temp, string mainPath)
{
temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/Default/neck1.mat");
ShaderReplacment.ReplaceMaterial(temp);
neckBody_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/Albino/neck1.mat");
ShaderReplacment.ReplaceMaterial(temp);
neckBody_Albino = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/Blue/neck1.mat");
ShaderReplacment.ReplaceMaterial(temp);
neckBody_Blue = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/DarkBlue/neck1.mat");
ShaderReplacment.ReplaceMaterial(temp);
neckBody_DarkBlue = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Neck/DarkGreen/neck1.mat");
ShaderReplacment.ReplaceMaterial(temp);
neckBody_DarkGreen = temp;
}
private void CreateHareMaterial(Material temp, string mainPath)
{
temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/Default/Hare_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
hareBody_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/Albino/Hare_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
hareBody_Albino = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/Black/Hare_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
hareBody_Black = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/DarkBlue/Hare_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
hareBody_DarkBlue = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Hare/Ginger/Hare_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
hareBody_Ginger = temp;
}
private void CreateDrakeMaterial(Material temp, string mainPath)
{
temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/Default/Hatchling_mountain_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
drakeBody_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/DarkBlue/Hatchling_mountain_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
drakeBody_DarkBlue = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/IceBlue/Hatchling_mountain_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
drakeBody_IceBlue = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/Purple/Hatchling_mountain_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
drakeBody_Purple = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Drake/Red/Hatchling_mountain_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
drakeBody_Red = temp;
}
private void CreateSerpentMaterials(Material temp, string mainPath)
{
temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Default/SeaSerpent_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
serpentBody_Default = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Albino/SeaSerpent_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
serpentBody_Albino = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Black/SeaSerpent_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
serpentBody_Black = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Blue/SeaSerpent_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
serpentBody_Blue = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Green/SeaSerpent_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
serpentBody_Green = temp;
temp = assetBundle.LoadAsset<Material>(mainPath + "Serpent/Red/SeaSerpent_mat1.mat");
ShaderReplacment.ReplaceMaterial(temp);
serpentBody_Red = temp;
}
private AssetBundle GetAssetBundleFromResources(string filename)
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(filename));
using Stream stream = executingAssembly.GetManifestResourceStream(name);
return AssetBundle.LoadFromStream(stream);
}
}
public class MonsterManager
{
private readonly LevelEffectGenerator levelEffectGenerator = new LevelEffectGenerator();
private List<GameObject> monsters = new List<GameObject>();
private static readonly HashSet<string> VisualNames = new HashSet<string>
{
"Lox", "Wraith", "TentaRoot", "TheHive", "Hatchling", "GoblinKing", "Eikthyr", "Bonemass", "Frog", "Haugbui",
"Greydwarf_Mystic", "Varsvin", "Varsvin_Brute", "Varsvin_Hunter", "SeekerQueen"
};
private static readonly HashSet<string> SkipNames = new HashSet<string> { "TheHive", "Haugbui", "Greydwarf_Mystic" };
public void SetupMonsterList(List<GameObject> list)
{
if (list == null)
{
Debug.LogWarning((object)"I DID NOT FIND PREFAB LIST!");
monsters = new List<GameObject>();
}
else
{
monsters = list.FindAll((GameObject x) => (Object)(object)x != (Object)null && (Object)(object)x.GetComponent<MonsterAI>() != (Object)null);
}
}
public void ChangeMonsterResistance()
{
if (monsters == null || monsters.Count == 0)
{
Debug.LogWarning((object)"I DID NOT FIND ANY MONSTERS!");
return;
}
foreach (GameObject monster in monsters)
{
if (!((Object)(object)monster == (Object)null))
{
SetupLevelVisual(monster);
}
}
}
private void SetupLevelVisual(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null || SkipNames.Contains(((Object)gameObject).name))
{
return;
}
Transform val = gameObject.transform.Find("Visual");
if ((Object)(object)val == (Object)null)
{
return;
}
LevelEffects val2 = gameObject.GetComponentInChildren<LevelEffects>();
if (VisualNames.Contains(((Object)gameObject).name))
{
Transform val3 = FindSpecialBodyTransform(gameObject);
if ((Object)(object)val3 == (Object)null)
{
return;
}
SkinnedMeshRenderer component = ((Component)val3).GetComponent<SkinnedMeshRenderer>();
if ((Object)(object)component == (Object)null)
{
return;
}
val2 = levelEffectGenerator.CreateLevelEffectAt(val, component);
}
else if ((Object)(object)val2 == (Object)null)
{
val2 = levelEffectGenerator.CreateLevelEffectComponent(val);
}
if ((Object)(object)val2 != (Object)null)
{
levelEffectGenerator.CreateVisuals(val2);
}
}
private Transform FindSpecialBodyTransform(GameObject gameObject)
{
switch (((Object)gameObject).name)
{
case "Lox":
return gameObject.transform.Find("Visual/offset/Body");
case "Wraith":
return gameObject.transform.Find("Visual/wraith/wraith");
case "TentaRoot":
return gameObject.transform.Find("Visual/Tentaroots/Cube.001");
case "Hatchling":
return gameObject.transform.Find("Visual/Hatchling_mountain/Hatchling");
case "GoblinKing":
return gameObject.transform.Find("Visual/Yagluth");
case "Eikthyr":
return gameObject.transform.Find("Visual/Deer");
case "Bonemass":
return gameObject.transform.Find("Visual/model/bonemass");
case "Varsvin":
case "Varsvin_Brute":
case "Varsvin_Hunter":
return gameObject.transform.Find("Visual/Body");
case "Frog":
return gameObject.transform.Find("Visual/Frog2_mesh");
case "SeekerQueen":
return gameObject.transform.Find("Visual/Cube");
default:
return null;
}
}
}
