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 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: AssemblyTitle("ValheimReforgedWeapons")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValheimReforgedWeapons")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("108df065-3a24-4888-8a60-cf793a69379c")]
[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]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace BjornheimArtifacts
{
public class BuildPieceChanges
{
private List<GameObject> buildPieces = new List<GameObject>();
private List<GameObject> items = new List<GameObject>();
private List<ItemConversion> allConversions = new List<ItemConversion>();
public void editBuidlPieces(List<GameObject> buildpieces, List<GameObject> newPieces, List<GameObject> items)
{
buildPieces = buildpieces;
this.items = items;
createBuildPiecesRecipes(newPieces);
editFermenter();
editSmelter();
editFurnace();
editKiln();
editWHeel();
editRefinery();
editWIndMIll();
editSap();
}
public void editStations(List<GameObject> buildpieces)
{
buildPieces = buildpieces;
items = buildpieces;
editFermenter();
editSmelter();
editFurnace();
editKiln();
editWHeel();
editRefinery();
editWIndMIll();
editSap();
}
private void createBuildPiecesRecipes(List<GameObject> newPieces)
{
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Expected O, but got Unknown
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Expected O, but got Unknown
GameObject val = items.Find((GameObject x) => ((Object)x).name == "Hammer");
List<GameObject> pieces = val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
foreach (GameObject piece in newPieces)
{
Piece component = piece.GetComponent<Piece>();
if (!((Object)component == (Object)null))
{
CheckForOtherNames(component, component.m_name);
List<Requirement> list = new List<Requirement>();
component.m_resources = createResources(piece);
if ((Object)pieces.Find((GameObject x) => ((Object)x).name == ((Object)piece).name) == (Object)null)
{
pieces.Add(piece);
}
}
}
}
private CraftingStation FindStation(List<GameObject> list, string name)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected O, but got Unknown
GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val != (Object)null)
{
return val.GetComponent<CraftingStation>();
}
return null;
}
private GameObject FindItem(string name)
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Expected O, but got Unknown
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
GameObject val = items.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val == (Object)null)
{
val = items.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val != (Object)null)
{
return val;
}
Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
return items.Find((GameObject x) => ((Object)x).name == "Wood");
}
if ((Object)val != (Object)null)
{
return val;
}
Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
return items.Find((GameObject x) => ((Object)x).name == "Wood");
}
private Requirement[] createResources(GameObject item)
{
List<Requirement> list = new List<Requirement>();
switch (((Object)item).name)
{
case "sacredforge_ext3":
case "sacredforge_ext2":
case "sacredforge_ext1":
case "SacredForge":
case "GrandForgeV2":
list.Add(createReq("SwordCheat", 1, 0));
break;
}
return list.ToArray();
}
private Requirement createReq(string name, int amount, int amountPerLevel)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Expected O, but got Unknown
Requirement val = new Requirement();
val.m_recover = true;
ItemDrop val2 = (val.m_resItem = items.Find((GameObject x) => ((Object)x).name == name).GetComponent<ItemDrop>());
val.m_amount = amount;
val.m_amountPerLevel = amountPerLevel;
return val;
}
private void CheckForOtherNames(Piece piece, string name)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Expected O, but got Unknown
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Expected O, but got Unknown
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Expected O, but got Unknown
Chair component = ((Component)piece).GetComponent<Chair>();
if ((Object)component != (Object)null)
{
component.m_name = name;
}
Fermenter component2 = ((Component)piece).GetComponent<Fermenter>();
if ((Object)component2 != (Object)null)
{
component2.m_name = name;
}
Door component3 = ((Component)piece).GetComponent<Door>();
if ((Object)component3 != (Object)null)
{
component3.m_name = name;
}
ItemStand component4 = ((Component)piece).GetComponent<ItemStand>();
if ((Object)component4 != (Object)null)
{
component4.m_name = name;
}
Container component5 = ((Component)piece).GetComponent<Container>();
if ((Object)component5 != (Object)null)
{
component5.m_name = name;
}
}
private void editFermenter()
{
GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "fermenter");
Fermenter component = val.GetComponent<Fermenter>();
component.m_conversion.Add(addFermenterCoversion(FindItem("MeadBaseLightingResistMedium_bal"), FindItem("MediumThunderPotion_bal")));
component.m_conversion.Add(addFermenterCoversion(FindItem("MeadBaseSpiritResistMedium_bal"), FindItem("MediumSpiritPotion_bal")));
}
private ItemConversion addFermenterCoversion(GameObject from, GameObject to)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
ItemConversion val = new ItemConversion();
val.m_from = from.GetComponent<ItemDrop>();
val.m_to = to.GetComponent<ItemDrop>();
val.m_producedItems = 6;
return val;
}
private void editSmelter()
{
GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "smelter");
Smelter component = val.GetComponent<Smelter>();
component.m_secPerProduct = 6f;
component.m_fuelPerProduct = 3;
allConversions.AddRange(component.m_conversion);
}
private void editFurnace()
{
GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "blastfurnace");
Smelter component = val.GetComponent<Smelter>();
component.m_secPerProduct = 3f;
component.m_fuelPerProduct = 2;
foreach (ItemConversion itemConversion in component.m_conversion)
{
ItemConversion val2 = allConversions.Find((ItemConversion x) => ((Object)x.m_from).name == ((Object)itemConversion.m_from).name);
if (val2 == null)
{
allConversions.Add(itemConversion);
}
}
component.m_conversion.Clear();
component.m_conversion.AddRange(allConversions);
}
private void editWHeel()
{
GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_spinningwheel");
Smelter component = val.GetComponent<Smelter>();
component.m_secPerProduct = 10f;
}
private void editRefinery()
{
GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "eitrrefinery");
Smelter component = val.GetComponent<Smelter>();
component.m_secPerProduct = 10f;
}
private void editWIndMIll()
{
GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "piece_sapcollector");
SapCollector component = val.GetComponent<SapCollector>();
component.m_secPerUnit = 15f;
component.m_maxLevel = 60;
}
private void editSap()
{
GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "windmill");
Smelter component = val.GetComponent<Smelter>();
component.m_secPerProduct = 8f;
}
private void editKiln()
{
GameObject val = buildPieces.Find((GameObject x) => ((Object)x).name == "charcoal_kiln");
Smelter component = val.GetComponent<Smelter>();
component.m_secPerProduct = 10f;
}
}
[BepInPlugin("balrond.astafaraios.BjornheimArtifacts", "BjornheimArtifacts", "1.0.1")]
public class Launch : BaseUnityPlugin
{
[HarmonyPatch(typeof(ZNetScene), "Awake")]
public static class ZNetScene_Awake_Path
{
public static void Prefix(ZNetScene __instance)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
if ((Object)__instance == (Object)null)
{
return;
}
foreach (GameObject newPrefab3 in vfxList)
{
if (!Object.op_Implicit((Object)(object)__instance.m_prefabs.Find((GameObject x) => ((Object)x).name == ((Object)newPrefab3).name)))
{
__instance.m_prefabs.Add(newPrefab3);
}
}
foreach (GameObject newPrefab2 in prefabs)
{
if (!Object.op_Implicit((Object)(object)__instance.m_prefabs.Find((GameObject x) => ((Object)x).name == ((Object)newPrefab2).name)))
{
__instance.m_prefabs.Add(newPrefab2);
}
}
foreach (GameObject newPrefab in buildPieces)
{
if (!Object.op_Implicit((Object)(object)__instance.m_prefabs.Find((GameObject x) => ((Object)x).name == ((Object)newPrefab).name)))
{
__instance.m_prefabs.Add(newPrefab);
}
}
buildPieceChanges.editBuidlPieces(__instance.m_prefabs, buildPieces, __instance.m_prefabs);
monsterManager.setupMonsters(__instance.m_prefabs, __instance.m_prefabs);
editPortal(__instance.m_prefabs, "portal_wood");
editPortal(__instance.m_prefabs, "portal_stone");
GameObject playerResistance = __instance.m_prefabs.Find((GameObject x) => ((Object)x).name == "Player");
monsterManager.setPlayerResistance(playerResistance);
buildPieceChanges.editStations(__instance.m_prefabs);
recipeBuilder.fixWaveGround(__instance.m_prefabs);
}
}
[HarmonyAfter(new string[] { "FactionPowers" })]
[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
public static class Object_CopyOtherDB_Path
{
public static void Postfix()
{
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Expected O, but got Unknown
if (!IsObjectDBValid())
{
return;
}
GameObject val = ObjectDB.instance.m_items.Find((GameObject x) => ((Object)x).name == "Hammer");
List<GameObject> pieces = val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
foreach (GameObject piece in buildPieces)
{
if ((Object)pieces.Find((GameObject x) => ((Object)x).name == ((Object)piece).name) == (Object)null)
{
pieces.Add(piece);
}
}
foreach (StatusEffect statusEffect in statusEffects)
{
AddStatus(statusEffect);
}
StatusEffect val2 = ObjectDB.instance.m_StatusEffects.Find((StatusEffect x) => ((Object)x).name == "Spirit");
val2.m_icon = iconSpirit;
foreach (GameObject prefab in prefabs)
{
AddNewPrefab(prefab);
}
}
}
[HarmonyAfter(new string[] { "FactionPowers" })]
[HarmonyPatch(typeof(ObjectDB), "Awake")]
public static class Object_Awake_Path
{
public static void Postfix()
{
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Expected O, but got Unknown
if (!IsObjectDBValid())
{
return;
}
GameObject val = ObjectDB.instance.m_items.Find((GameObject x) => ((Object)x).name == "Hammer");
List<GameObject> pieces = val.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
foreach (GameObject piece in buildPieces)
{
if ((Object)pieces.Find((GameObject x) => ((Object)x).name == ((Object)piece).name) == (Object)null)
{
pieces.Add(piece);
}
}
foreach (StatusEffect statusEffect in statusEffects)
{
AddStatus(statusEffect);
}
StatusEffect val2 = ObjectDB.instance.m_StatusEffects.Find((StatusEffect x) => ((Object)x).name == "Spirit");
val2.m_icon = iconSpirit;
foreach (GameObject prefab in prefabs)
{
AddNewPrefab(prefab);
}
recipes.AddRange(recipeBuilder.createRecipes(ObjectDB.instance.m_items, prefabs));
foreach (Recipe recipe in recipes)
{
AddRecipe(recipe);
}
}
}
private readonly Harmony harmony = new Harmony("balrond.astafaraios.BjornheimArtifacts");
public const string PluginGUID = "balrond.astafaraios.BjornheimArtifacts";
public const string PluginName = "BjornheimArtifacts";
public const string PluginVersion = "1.0.1";
private static AssetBundle assetBundle;
private static readonly string bundleName = "factionweapons";
private static List<GameObject> prefabs = new List<GameObject>();
private static List<GameObject> buildPieces = new List<GameObject>();
private static List<GameObject> vfxList = new List<GameObject>();
private static List<StatusEffect> statusEffects = new List<StatusEffect>();
public static RecipeBuilder recipeBuilder = new RecipeBuilder();
public static List<Recipe> recipes = new List<Recipe>();
public static MonsterManager monsterManager = new MonsterManager();
public static BuildPieceChanges buildPieceChanges = new BuildPieceChanges();
private static readonly string[] prefabNames = new string[9] { "Blidhr_bal", "Blidhr_base_bal", "BowRazorStrikes", "FenrirSword_bal", "FenrirSword_base_bal", "Gugnir_bal", "Gugnir_base_bal", "HoundsSycle", "HoundsScythe" };
private static readonly string[] resourceNames = new string[19]
{
"AcidSludge_bal", "Amethyst_bal", "AmethystSteel", "BlackTissue", "Bloodsteel", "DarkSteel", "DvergrHeart", "Electrum", "Frosteel", "GjallCore_bal",
"GoldBar", "SeedFrost_bal", "SeekerBruteBlood", "MeadBaseLightingResistMedium_bal", "MeadBaseSpiritResistMedium_bal", "MediumSpiritPotion_bal", "MediumThunderPotion_bal", "DraugrInsygnia", "QueenCore"
};
private static readonly string[] pieceNames = new string[5] { "SacredForge", "sacredforge_ext1", "sacredforge_ext2", "sacredforge_ext3", "GrandForgeV2" };
private static readonly string[] vfxNames = new string[12]
{
"SacredForgeAltar", "GrandForge", "Wave_Ground", "projectile_runeAxe", "fx_eikthyr_forwardshockwave1", "fx_Lightning1", "vfx_iceblocker_destroyed1", "vfx_scythExplosion", "vfx_scythe_ground", "vfx_scytheSpikeAoe",
"fx_eikthyr_forwardshockwave2", "vfx_spiritbolt_explosion"
};
public static Sprite iconSpirit = null;
private void Awake()
{
Debug.Log((object)"ReidrheimrFactionWeapons loading");
init();
Debug.Log((object)"ReidrheimrFactionWeapons done loading");
}
private void init()
{
LoadAllAssetBundles();
harmony.PatchAll();
}
private void OnDestroy()
{
harmony.UnpatchSelf();
}
public static void LoadAllAssetBundles()
{
assetBundle = GetAssetBundleFromResources(bundleName);
LoadPrefabs(assetBundle);
loadStatusFromPotion();
}
public static 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);
}
private static void LoadPrefabs(AssetBundle assetBundle)
{
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
iconSpirit = assetBundle.LoadAsset<Sprite>("Assets/Custom/Comission/FactionWeapons/ico/spiritburn1.png");
string[] array = vfxNames;
string[] array2 = array;
foreach (string text in array2)
{
GameObject val = assetBundle.LoadAsset<GameObject>("Assets/Custom/Comission/FactionWeapons/Objects/" + text + ".prefab");
val.SetActive(true);
vfxList.Add(val);
}
string[] array3 = resourceNames;
string[] array4 = array3;
foreach (string text2 in array4)
{
GameObject val2 = assetBundle.LoadAsset<GameObject>("Assets/Custom/Comission/FactionWeapons/Resources/" + text2 + ".prefab");
val2.SetActive(true);
prefabs.Add(val2);
}
string[] array5 = prefabNames;
string[] array6 = array5;
foreach (string text3 in array6)
{
GameObject val3 = assetBundle.LoadAsset<GameObject>("Assets/Custom/Comission/FactionWeapons/Weapons/" + text3 + ".prefab");
val3.SetActive(true);
if (text3 == "Blidhr_bal" || text3 == "Blidhr_base_bal")
{
recolorParticleEmitterColorsRecursively(val3, new Color(0f, 0.64f, 1f));
}
prefabs.Add(val3);
}
string[] array7 = pieceNames;
string[] array8 = array7;
foreach (string text4 in array8)
{
GameObject val4 = assetBundle.LoadAsset<GameObject>("Assets/Custom/Comission/FactionWeapons/Pieces/" + text4 + ".prefab");
val4.SetActive(true);
buildPieces.Add(val4);
}
}
private static void recolorParticleEmitterColorsRecursively(GameObject g, Color c)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: 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)
ParticleSystem component = g.GetComponent<ParticleSystem>();
if ((Object)(object)component != (Object)null)
{
MainModule main = component.main;
MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
c.a = ((MinMaxGradient)(ref startColor)).color.a;
((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(c);
}
for (int i = 0; i < g.transform.childCount; i++)
{
recolorParticleEmitterColorsRecursively(((Component)g.transform.GetChild(i)).gameObject, c);
}
}
private static void loadStatusFromPotion()
{
string[] source = new string[2] { "MediumSpiritPotion_bal", "MediumThunderPotion_bal" };
foreach (GameObject prefab in prefabs)
{
if (source.Contains(((Object)prefab).name))
{
ItemDrop component = prefab.GetComponent<ItemDrop>();
statusEffects.Add(component.m_itemData.m_shared.m_consumeStatusEffect);
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Fireplace), "UpdateFireplace")]
public static void Fireplace_UpdateFireplace(Fireplace __instance, ref ZNetView ___m_nview)
{
___m_nview.GetZDO().Set("fuel", __instance.m_maxFuel);
}
public static void editPortal(List<GameObject> prefbaList, string name)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected O, but got Unknown
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Expected O, but got Unknown
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Expected O, but got Unknown
GameObject val = prefbaList.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val == (Object)null)
{
Debug.LogWarning((object)"NO PORTAL FOUND");
return;
}
Piece component = val.GetComponent<Piece>();
if ((Object)component == (Object)null)
{
Debug.LogWarning((object)"NO PIECE FOUND");
return;
}
Requirement[] resources = component.m_resources;
List<Requirement> list = new List<Requirement>(resources.Length);
Requirement[] array = resources;
foreach (Requirement item in array)
{
list.Add(item);
}
List<Requirement> list2 = list;
if (!list2.Any((Requirement w) => ((Object)w.m_resItem).name.ToLower().Contains("queen")))
{
Requirement val2 = new Requirement();
val2.m_amount = 1;
GameObject val3 = prefbaList.Find((GameObject x) => ((Object)x).name == "QueenCore");
if ((Object)val3 == (Object)null)
{
Debug.LogWarning((object)"NO QUEEN CORE FOUND");
return;
}
val2.m_resItem = val3.GetComponent<ItemDrop>();
val2.m_recover = true;
list2.Add(val2);
}
component.m_resources = list2.ToArray();
}
private static bool IsObjectDBValid()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Expected O, but got Unknown
return (Object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items.Count != 0 && ObjectDB.instance.m_recipes.Count != 0 && (Object)ObjectDB.instance.GetItemPrefab("Amber") != (Object)null;
}
private static void AddRecipe(Recipe recipe)
{
int num = ObjectDB.instance.m_recipes.RemoveAll((Recipe x) => ((Object)x).name == ((Object)recipe).name);
if (num > 0)
{
Debug.Log((object)$"Recipe ({((Object)recipe).name}): {num} instances removed.");
}
ObjectDB.instance.m_recipes.Add(recipe);
Debug.Log((object)("Recipe (" + ((Object)recipe).name + ") added."));
}
private static void AddNewPrefab(GameObject newPrefab)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
ItemDrop component = newPrefab.GetComponent<ItemDrop>();
if ((Object)component != (Object)null)
{
if ((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[StringExtensionMethods.GetStableHashCode(((Object)newPrefab).name)] = newPrefab;
Debug.Log((object)(((Object)newPrefab).name + " - Added to the Game"));
}
else
{
Debug.LogWarning((object)(((Object)newPrefab).name + " - ItemDrop already exists"));
}
}
else
{
Debug.LogError((object)(((Object)newPrefab).name + " - ItemDrop not found on prefab"));
}
}
private static void AddStatus(StatusEffect status)
{
if (!IsObjectDBValid())
{
return;
}
if ((Object)(object)status != (Object)null)
{
if ((Object)(object)ObjectDB.instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode(((Object)status).name)) == (Object)null)
{
ObjectDB.instance.m_StatusEffects.Add(status);
Debug.Log((object)(((Object)status).name + " - Status Added to the Game"));
}
}
else
{
Debug.LogError((object)(((Object)status).name + " - Status not found"));
}
}
}
public class MonsterManager
{
private List<GameObject> monsters;
private List<GameObject> list;
private List<GameObject> list2;
private string[] names = new string[0];
private string[] thiefName = new string[14]
{
"Greyling", "Greydwarf", "Greydwarf_Elite", "Draugr", "Draugr_Elite", "Draugr_Ranged", "Skeleton", "Skeleton_NoArcher", "Skeleton_Poison", "Forsaken",
"GoblinBrute", "GoblinArcher", "Goblin", "GoblinShaman"
};
public void setPlayerResistance(GameObject player)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
Humanoid component = player.GetComponent<Humanoid>();
((Character)component).m_damageModifiers.m_spirit = (DamageModifier)0;
}
public void setupMonsters(List<GameObject> list, List<GameObject> newItemList)
{
if (list == null)
{
Debug.LogWarning((object)"I DID NOT FOUND PREFAB LIST!");
return;
}
this.list = list;
list2 = newItemList;
monsters = list.FindAll((GameObject x) => (Object)x.GetComponent<MonsterAI>() != (Object)null);
if (monsters == null)
{
Debug.LogWarning((object)"I DID NOT FOUND ANY MONSTERS!");
return;
}
changeMonsterResistance();
changeMonsterDrops();
}
private void changeMonsterDrops()
{
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Expected O, but got Unknown
string[] array = new string[13]
{
"Tick", "Seeker", "SeekerBrute", "Gjall", "DvergerMageIce", "DvergerMageSupport", "DvergerMage", "DvergerMageFire", "Dverger", "Draugr",
"Draugr_Elite", "Draugr_Ranged", "SeekerQueen"
};
string[] array2 = array;
string[] array3 = array2;
foreach (string name in array3)
{
GameObject val = monsters.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val != (Object)null)
{
monsterLootChange(val);
}
}
}
private void monsterLootChange(GameObject monster)
{
string name = ((Object)monster).name;
string text = name;
if (text == null)
{
return;
}
switch (text.Length)
{
case 11:
switch (text[6])
{
case 'r':
if (text == "DvergerMage")
{
addItemToLootTable(monster, "DvergrHeart", 1, 1, 0.25f);
}
break;
case 'B':
if (text == "SeekerBrute")
{
addItemToLootTable(monster, "SeekerBruteBlood", 1, 1, 0.5f);
}
break;
case 'Q':
if (text == "SeekerQueen")
{
addItemToLootTable(monster, "QueenCore", 1, 1, 0.15f);
}
break;
}
break;
case 6:
switch (text[0])
{
default:
return;
case 'S':
if (text == "Seeker")
{
addItemToLootTable(monster, "AcidSludge_bal", 1, 1, 0.5f);
}
return;
case 'D':
break;
}
if (!(text == "Draugr"))
{
break;
}
goto IL_02ca;
case 4:
if (text == "Tick")
{
addItemToLootTable(monster, "BlackTissue", 1, 1, 0.25f);
}
break;
case 14:
if (text == "DvergerMageIce")
{
addItemToLootTable(monster, "DvergrHeart", 1, 1, 0.25f);
addItemToLootTable(monster, "SeedFrost_bal", 1, 1, 0.75f);
}
break;
case 18:
if (text == "DvergerMageSupport")
{
addItemToLootTable(monster, "DvergrHeart", 1, 1, 0.25f);
addItemToLootTable(monster, "Amethyst_bal", 1, 1, 0.5f);
}
break;
case 15:
if (text == "DvergerMageFire")
{
addItemToLootTable(monster, "DvergrHeart", 1, 1, 0.25f);
addItemToLootTable(monster, "Amethyst_bal", 1, 1, 0.25f);
}
break;
case 7:
if (text == "Dverger")
{
addItemToLootTable(monster, "GoldBar", 1, 1, 0.25f);
}
break;
case 5:
if (text == "Gjall")
{
addItemToLootTable(monster, "GjallCore_bal", 1, 1, 1f);
}
break;
case 13:
if (!(text == "Draugr_Ranged"))
{
break;
}
goto IL_02ca;
case 12:
if (text == "Draugr_Elite")
{
addItemToLootTable(monster, "DraugrInsygnia", 1, 1, 0.5f);
}
break;
case 8:
case 9:
case 10:
case 16:
case 17:
break;
IL_02ca:
addItemToLootTable(monster, "DraugrInsygnia", 1, 1, 0.2f);
break;
}
}
private void addItemToLootTable(GameObject monster, string itemName, int amountMin, int amountMax, float chance)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Expected O, but got Unknown
CharacterDrop component = monster.GetComponent<CharacterDrop>();
Drop val = new Drop();
val.m_amountMin = amountMin;
val.m_amountMax = amountMax;
val.m_chance = chance;
val.m_levelMultiplier = false;
GameObject val2 = (val.m_prefab = FindItem(itemName));
component.m_drops.Add(val);
}
private void changeMonsterResistance()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
foreach (GameObject monster in monsters)
{
Humanoid component = monster.GetComponent<Humanoid>();
if ((Object)component != (Object)null)
{
changeResistanceForException(component);
}
}
}
private GameObject FindItem(string name)
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Expected O, but got Unknown
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val == (Object)null)
{
val = list2.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val != (Object)null)
{
return val;
}
Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
return list.Find((GameObject x) => ((Object)x).name == "Wood");
}
if ((Object)val != (Object)null)
{
return val;
}
Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
return list.Find((GameObject x) => ((Object)x).name == "Wood");
}
private CraftingStation FindStation(string name)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Expected O, but got Unknown
GameObject val = FindItem(name);
if ((Object)val != (Object)null)
{
return val.GetComponent<CraftingStation>();
}
return null;
}
private void changeSpiritResistance(Humanoid humanoid)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected I4, but got Unknown
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: 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_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
switch ((int)((Character)humanoid).m_faction)
{
case 0:
((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)0;
break;
case 1:
((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)1;
break;
case 5:
((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)5;
break;
case 2:
((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)2;
break;
case 3:
((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)2;
break;
case 6:
((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)1;
break;
case 4:
((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)5;
break;
case 8:
((Character)humanoid).m_damageModifiers.m_spirit = (DamageModifier)5;
break;
case 7:
break;
}
}
private void changeResistanceForException(Humanoid humanoid)
{
changeSpiritResistance(humanoid);
}
}
public class RecipeBuilder
{
private List<GameObject> pieces;
private List<GameObject> items;
private List<GameObject> newItems;
public List<Recipe> recipes;
private string[] toRecipe = new string[17]
{
"Blidhr_bal", "Blidhr_base_bal", "BowRazorStrikes", "FenrirSword_bal", "FenrirSword_base_bal", "Gugnir_bal", "Gugnir_base_bal", "HoundsSycle", "Electrum", "Frosteel",
"GoldBar", "Bloodsteel", "HoundsScythe", "DarkSteel", "AmethystSteel", "MeadBaseLightingResistMedium_bal", "MeadBaseSpiritResistMedium_bal"
};
private string[] itemEditNames = new string[19]
{
"SeekerAspic", "YggdrasilPorridge", "MagicallyStuffedShroom", "MushroomOmelette", "draugr_sword", "draugr_bow", "draugr_axe", "skeleton_bow", "skeleton_mace", "skeleton_sword2",
"skeleton_bow2", "skeleton_sword2", "imp_fireball_attack", "Ghost_attack", "gd_king_shoot", "Greydwarf_shaman_attack", "GoblinKing_Beam", "GoblinShaman_attack_fireball", "BowRazorStrikes"
};
private void editItems()
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
string[] array = itemEditNames;
string[] array2 = array;
foreach (string text in array2)
{
GameObject val = FindItem(text);
if ((Object)val == (Object)null)
{
Debug.LogWarning((object)("Could not find: " + text));
}
else
{
CheckStats(val);
}
}
}
private void CheckStats(GameObject gameObject)
{
string name = ((Object)gameObject).name;
string text = name;
if (text == null)
{
return;
}
switch (text.Length)
{
case 12:
switch (text[0])
{
default:
return;
case 'd':
if (text == "draugr_sword")
{
editSpiritDamageStat(gameObject, 25);
}
return;
case 's':
if (!(text == "skeleton_bow"))
{
return;
}
break;
case 'G':
if (!(text == "Ghost_attack"))
{
return;
}
break;
}
goto IL_0243;
case 10:
switch (text[7])
{
case 'b':
if (text == "draugr_bow")
{
editSpiritDamageStat(gameObject, 15);
}
break;
case 'a':
if (text == "draugr_axe")
{
editSpiritDamageStat(gameObject, 15);
}
break;
}
break;
case 13:
switch (text[9])
{
default:
return;
case 'b':
if (!(text == "skeleton_bow2"))
{
return;
}
break;
case 'm':
if (!(text == "skeleton_mace"))
{
return;
}
break;
case 'h':
if (!(text == "gd_king_shoot"))
{
return;
}
break;
}
goto IL_024f;
case 15:
switch (text[0])
{
default:
return;
case 's':
if (!(text == "skeleton_sword2"))
{
return;
}
break;
case 'G':
if (!(text == "GoblinKing_Beam"))
{
return;
}
break;
case 'B':
if (text == "BowRazorStrikes")
{
editStatsRazorStrike(gameObject, 94, 0, 10, 10, 0, 10);
}
return;
}
goto IL_024f;
case 14:
if (!(text == "skeleton_sword"))
{
break;
}
goto IL_0243;
case 23:
if (!(text == "Greydwarf_shaman_attack"))
{
break;
}
goto IL_024f;
case 28:
if (!(text == "GoblinShaman_attack_fireball"))
{
break;
}
goto IL_024f;
case 19:
{
if (text == "imp_fireball_attack")
{
editSpiritDamageStat(gameObject, 10);
}
break;
}
IL_0243:
editSpiritDamageStat(gameObject, 10);
break;
IL_024f:
editSpiritDamageStat(gameObject, 20);
break;
}
}
private void editStatsRazorStrike(GameObject gameObject, int pierce, int fire, int frost, int lightning, int poison, int spirit)
{
ItemDrop component = gameObject.GetComponent<ItemDrop>();
component.m_itemData.m_shared.m_damages.m_pierce = pierce;
component.m_itemData.m_shared.m_damages.m_fire = fire;
component.m_itemData.m_shared.m_damages.m_frost = frost;
component.m_itemData.m_shared.m_damages.m_lightning = lightning;
component.m_itemData.m_shared.m_damages.m_poison = poison;
component.m_itemData.m_shared.m_damages.m_spirit = spirit;
component.m_itemData.m_shared.m_damagesPerLevel.m_pierce = 4f;
component.m_itemData.m_shared.m_damagesPerLevel.m_fire = 0f;
component.m_itemData.m_shared.m_damagesPerLevel.m_frost = 4f;
component.m_itemData.m_shared.m_damagesPerLevel.m_lightning = 4f;
component.m_itemData.m_shared.m_damagesPerLevel.m_poison = 0f;
component.m_itemData.m_shared.m_damagesPerLevel.m_spirit = 4f;
}
private void editSpiritDamageStat(GameObject gameObject, int spiritDamage)
{
ItemDrop component = gameObject.GetComponent<ItemDrop>();
component.m_itemData.m_shared.m_damages.m_spirit = spiritDamage;
if (((Object)gameObject).name == "skeleton_mace" || ((Object)gameObject).name == "imp_fireball_attack")
{
component.m_itemData.m_shared.m_damages.m_blunt += spiritDamage;
}
}
private void editFoodStat(GameObject gameObject, int hp, int stam, int eitr)
{
ItemDrop component = gameObject.GetComponent<ItemDrop>();
component.m_itemData.m_shared.m_food = hp;
component.m_itemData.m_shared.m_foodStamina = stam;
component.m_itemData.m_shared.m_foodEitr = eitr;
}
public List<Recipe> createRecipes(List<GameObject> items, List<GameObject> newItems)
{
this.items = items;
this.newItems = newItems;
pieces = items.Find((GameObject x) => ((Object)x).name == "Hammer").GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
List<Recipe> list = new List<Recipe>();
CraftingStation component = pieces.Find((GameObject x) => ((Object)x).name == "forge").GetComponent<CraftingStation>();
int minStationLevel = 3;
foreach (GameObject newItem in newItems)
{
if (toRecipe.Contains(((Object)newItem).name))
{
Recipe val = ScriptableObject.CreateInstance<Recipe>();
val.m_craftingStation = component;
val.m_repairStation = component;
val.m_minStationLevel = minStationLevel;
val = createResources(newItem, val);
list.Add(val);
}
}
editItems();
return list;
}
public Sprite LoadNewSprite(string FilePath, float PixelsPerUnit = 100f)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
Texture2D val = LoadTexture(FilePath);
return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0f, 0f), PixelsPerUnit);
}
public Texture2D LoadTexture(string fileName)
{
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
Assembly executingAssembly = Assembly.GetExecutingAssembly();
string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(fileName));
using (Stream stream = executingAssembly.GetManifestResourceStream(name))
{
byte[] array = new byte[stream.Length];
stream.Read(array, 0, (int)stream.Length);
Texture2D val = new Texture2D(2, 2);
if (ImageConversion.LoadImage(val, array))
{
return val;
}
}
return null;
}
private Recipe createResources(GameObject item, Recipe newRecipe)
{
((Object)newRecipe).name = "Recipe_" + ((Object)item).name;
newRecipe.m_item = item.GetComponent<ItemDrop>();
newRecipe.m_amount = 1;
newRecipe.m_enabled = true;
List<Requirement> list = new List<Requirement>();
switch (((Object)item).name)
{
case "Blidhr_base_bal":
{
item.GetComponent<ItemDrop>().m_itemData.m_shared.m_name = "Freyrs Rune Axe";
list.Add(createReq("DarkSteel", 10, 5));
list.Add(createReq("ElderBark", 10, 2));
list.Add(createReq("Silver", 10, 2));
list.Add(createReq("AncientSeed", 15, 6));
List<Sprite> list3 = new List<Sprite>();
list3.Add(LoadNewSprite("bladhir_base_ico.png"));
item.GetComponent<ItemDrop>().m_itemData.m_shared.m_icons = list3.ToArray();
break;
}
case "Blidhr_bal":
{
newRecipe.m_craftingStation = FindStation(pieces, "SacredForge");
newRecipe.m_minStationLevel = 1;
list.Add(createReq("Blidhr_base_bal", 1, 0));
list.Add(createReq("AmethystSteel", 8, 4));
list.Add(createReq("AcidSludge_bal", 20, 10));
list.Add(createReq("YmirRemains", 20, 10));
List<Sprite> list2 = new List<Sprite>();
list2.Add(LoadNewSprite("bladhir_ico.png"));
item.GetComponent<ItemDrop>().m_itemData.m_shared.m_icons = list2.ToArray();
break;
}
case "BowRazorStrikes":
newRecipe.m_craftingStation = FindStation(pieces, "piece_workbench");
newRecipe.m_minStationLevel = 1;
list.Add(createReq("Electrum", 15, 5));
list.Add(createReq("Eitr", 30, 2));
list.Add(createReq("MediumSpiritPotion_bal", 5, 2));
break;
case "FenrirSword_bal":
newRecipe.m_craftingStation = FindStation(pieces, "SacredForge");
newRecipe.m_minStationLevel = 1;
list.Add(createReq("FenrirSword_base_bal", 1, 0));
list.Add(createReq("Frosteel", 8, 4));
list.Add(createReq("SeedFrost_bal", 20, 10));
list.Add(createReq("Crystal", 20, 10));
break;
case "FenrirSword_base_bal":
list.Add(createReq("DarkSteel", 10, 5));
list.Add(createReq("ElderBark", 10, 2));
list.Add(createReq("Silver", 10, 2));
list.Add(createReq("WolfPelt", 10, 2));
break;
case "Gugnir_base_bal":
item.GetComponent<ItemDrop>().m_itemData.m_shared.m_name = "Spear of Penitents";
list.Add(createReq("DarkSteel", 10, 5));
list.Add(createReq("ElderBark", 10, 2));
list.Add(createReq("Silver", 10, 2));
list.Add(createReq("MushroomYellow", 20, 5));
break;
case "Gugnir_bal":
newRecipe.m_craftingStation = FindStation(pieces, "SacredForge");
newRecipe.m_minStationLevel = 1;
list.Add(createReq("Gugnir_base_bal", 1, 0));
list.Add(createReq("Electrum", 8, 4));
list.Add(createReq("GoldBar", 20, 10));
list.Add(createReq("Thunderstone", 20, 10));
break;
case "HoundsSycle":
list.Add(createReq("DarkSteel", 10, 5));
list.Add(createReq("ElderBark", 10, 2));
list.Add(createReq("Silver", 10, 2));
list.Add(createReq("Bloodbag", 15, 6));
break;
case "HoundsScythe":
newRecipe.m_craftingStation = FindStation(pieces, "SacredForge");
newRecipe.m_minStationLevel = 1;
list.Add(createReq("HoundsSycle", 1, 0));
list.Add(createReq("Bloodsteel", 8, 4));
list.Add(createReq("BlackTissue", 20, 10));
list.Add(createReq("SurtlingCore", 20, 10));
break;
case "Electrum":
newRecipe.m_craftingStation = FindStation(pieces, "SacredForge");
newRecipe.m_minStationLevel = 1;
list.Add(createReq("FlametalNew", 4, 0));
list.Add(createReq("DarkSteel", 3, 0));
list.Add(createReq("GjallCore_bal", 5, 0));
list.Add(createReq("Coal", 8, 0));
break;
case "Frosteel":
newRecipe.m_craftingStation = FindStation(pieces, "SacredForge");
newRecipe.m_minStationLevel = 1;
list.Add(createReq("FlametalNew", 4, 0));
list.Add(createReq("DarkSteel", 3, 0));
list.Add(createReq("SeedFrost_bal", 5, 0));
list.Add(createReq("Coal", 8, 0));
break;
case "GoldBar":
newRecipe.m_minStationLevel = 5;
list.Add(createReq("Coins", 999, 0));
list.Add(createReq("Coal", 10, 0));
break;
case "Bloodsteel":
newRecipe.m_craftingStation = FindStation(pieces, "SacredForge");
newRecipe.m_minStationLevel = 1;
list.Add(createReq("FlametalNew", 4, 0));
list.Add(createReq("DarkSteel", 3, 0));
list.Add(createReq("SeekerBruteBlood", 5, 0));
list.Add(createReq("Coal", 8, 0));
break;
case "DarkSteel":
list.Add(createReq("Iron", 3, 0));
list.Add(createReq("Obsidian", 6, 0));
list.Add(createReq("Coal", 5, 0));
break;
case "AmethystSteel":
newRecipe.m_craftingStation = FindStation(pieces, "SacredForge");
newRecipe.m_minStationLevel = 1;
list.Add(createReq("FlametalNew", 4, 0));
list.Add(createReq("DarkSteel", 3, 0));
list.Add(createReq("Amethyst_bal", 5, 0));
list.Add(createReq("Coal", 8, 0));
break;
case "MeadBaseLightingResistMedium_bal":
newRecipe.m_craftingStation = FindStation(pieces, "piece_cauldron");
newRecipe.m_minStationLevel = 2;
list.Add(createReq("Thunderstone", 3, 0));
list.Add(createReq("Thistle", 5, 0));
list.Add(createReq("GreydwarfEye", 25, 0));
list.Add(createReq("TrophyFrostTroll", 2, 0));
break;
case "MeadBaseSpiritResistMedium_bal":
newRecipe.m_craftingStation = FindStation(pieces, "piece_cauldron");
newRecipe.m_minStationLevel = 2;
list.Add(createReq("DraugrInsygnia", 6, 0));
list.Add(createReq("Honey", 10, 0));
list.Add(createReq("Bloodbag", 4, 0));
list.Add(createReq("TrophyGreydwarfShaman", 2, 0));
break;
}
newRecipe.m_resources = list.ToArray();
return newRecipe;
}
public Requirement createReq(string name, int amount, int amountPerLevel)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Expected O, but got Unknown
Requirement val = new Requirement();
val.m_recover = true;
ItemDrop val2 = (val.m_resItem = items.Find((GameObject x) => ((Object)x).name == name).GetComponent<ItemDrop>());
val.m_amount = amount;
val.m_amountPerLevel = amountPerLevel;
return val;
}
private GameObject FindItem(string name)
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Expected O, but got Unknown
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
GameObject val = items.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val == (Object)null)
{
val = newItems.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val != (Object)null)
{
return val;
}
Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
return items.Find((GameObject x) => ((Object)x).name == "Wood");
}
if ((Object)val != (Object)null)
{
return val;
}
Debug.LogWarning((object)("Item Not Found - " + name + ", Replaced With Wood"));
return items.Find((GameObject x) => ((Object)x).name == "Wood");
}
private CraftingStation FindStation(List<GameObject> list, string name)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected O, but got Unknown
GameObject val = list.Find((GameObject x) => ((Object)x).name == name);
if ((Object)val != (Object)null)
{
return val.GetComponent<CraftingStation>();
}
return null;
}
internal void fixWaveGround(List<GameObject> m_prefabs)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_0141: Unknown result type (might be due to invalid IL or missing references)
try
{
GameObject g = m_prefabs.Find((GameObject x) => ((Object)x).name == "Wave_Ground");
recolorParticleEmitterColorsRecursively(g, new Color(0f, 0.64f, 1f));
GameObject g2 = m_prefabs.Find((GameObject x) => ((Object)x).name == "vfx_spiritbolt_explosion");
recolorParticleEmitterColorsRecursively(g2, new Color(0f, 0.64f, 1f));
GameObject val = m_prefabs.Find((GameObject x) => ((Object)x).name == "Blidhr_base_bal");
Transform val2 = RecursiveFindChild(val.transform, "RuneRock_3 (1)");
((Component)val2).GetComponent<Renderer>().material.SetColor("_EmissionColor", new Color(0f, 0.6f, 1f));
GameObject val3 = m_prefabs.Find((GameObject x) => ((Object)x).name == "Blidhr_bal");
Transform val4 = RecursiveFindChild(val3.transform, "RuneRock_1");
((Component)val4).GetComponent<Renderer>().material.SetColor("_EmissionColor", new Color(0f, 0.6f, 1f));
}
catch (Exception ex)
{
Debug.Log((object)"######################################################################");
Debug.Log((object)"Failed to fixwaveground");
Debug.Log((object)ex);
}
}
private static void recolorParticleEmitterColorsRecursively(GameObject g, Color c)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: 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_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
ParticleSystem component = g.GetComponent<ParticleSystem>();
if ((Object)(object)component != (Object)null)
{
MainModule main = component.main;
MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
c.a = ((MinMaxGradient)(ref startColor)).color.a;
((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(c);
TrailModule trails = component.trails;
if (((TrailModule)(ref trails)).enabled)
{
TrailModule trails2 = component.trails;
((TrailModule)(ref trails2)).colorOverLifetime = MinMaxGradient.op_Implicit(c);
}
ColorOverLifetimeModule colorOverLifetime = component.colorOverLifetime;
if (((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled)
{
try
{
ColorOverLifetimeModule colorOverLifetime2 = component.colorOverLifetime;
((ColorOverLifetimeModule)(ref colorOverLifetime2)).color = MinMaxGradient.op_Implicit(c);
}
catch (Exception ex)
{
Debug.Log((object)"######################################################################");
Debug.Log((object)"Failed to recolorParticleEmitterColorsRecursively");
Debug.Log((object)ex);
}
}
}
for (int i = 0; i < g.transform.childCount; i++)
{
recolorParticleEmitterColorsRecursively(((Component)g.transform.GetChild(i)).gameObject, c);
}
}
private Transform RecursiveFindChild(Transform parent, string childName)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
foreach (Transform item in parent)
{
Transform val = item;
if (((Object)val).name == childName)
{
return val;
}
Transform val2 = RecursiveFindChild(val, childName);
if ((Object)(object)val2 != (Object)null)
{
return val2;
}
}
return null;
}
}
public class ShaderReplacment
{
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 List<Shader> shaders = new List<Shader>();
public void findShadersByName()
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
string[] array = shaderlist;
string[] array2 = array;
foreach (string text in array2)
{
Shader val = Shader.Find(text);
if ((Object)val != (Object)null)
{
shaders.Add(val);
}
}
}
public void ReplaceShadersInObject(GameObject gameObject)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Expected O, but got Unknown
if ((Object)gameObject == (Object)null)
{
return;
}
Renderer[] componentsInChildren = gameObject.GetComponentsInChildren<Renderer>();
if (componentsInChildren == null || componentsInChildren.Length == 0)
{
return;
}
Renderer[] array = componentsInChildren;
Renderer[] array2 = array;
foreach (Renderer val in array2)
{
int num = 0;
Material[] sharedMaterials = val.sharedMaterials;
if (sharedMaterials == null || sharedMaterials.Length == 0)
{
continue;
}
Material[] array3 = sharedMaterials;
Material[] array4 = array3;
foreach (Material val2 in array4)
{
string name = ((Object)val2.shader).name;
if (!(name == "Standard") && name.Contains("Balrond"))
{
string name2 = name.Replace("Balrond", "Custom");
name2 = checkNaming(name2);
Shader val3 = Shader.Find(name2);
if ((Object)val3 == (Object)null)
{
Debug.LogWarning((object)("[Project Ashlands]: Shader not found " + name2));
continue;
}
val2.shader = val3;
num++;
}
}
}
}
private 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;
}
}
}
