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 BepInEx;
using HarmonyLib;
using JotunnLib.Entities;
using JotunnLib.Events;
using JotunnLib.Managers;
using JotunnLib.Utils;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("JotunnLib")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("JotunnLib")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a6082a59-38be-4cab-9078-2c8fcda65b8f")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.0", FrameworkDisplayName = ".NET Framework 4")]
[assembly: AssemblyVersion("1.0.0.0")]
internal static class ObjImporter
{
private struct meshStruct
{
public Vector3[] vertices;
public Vector3[] normals;
public Vector2[] uv;
public Vector2[] uv1;
public Vector2[] uv2;
public int[] triangles;
public int[] faceVerts;
public int[] faceUVs;
public Vector3[] faceData;
public string name;
public string fileName;
}
public static Mesh ImportFile(string filePath)
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: 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)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Expected O, but got Unknown
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
meshStruct mesh = createMeshStruct(filePath);
populateMeshStruct(ref mesh);
Vector3[] array = (Vector3[])(object)new Vector3[mesh.faceData.Length];
Vector2[] array2 = (Vector2[])(object)new Vector2[mesh.faceData.Length];
Vector3[] array3 = (Vector3[])(object)new Vector3[mesh.faceData.Length];
int num = 0;
Vector3[] faceData = mesh.faceData;
foreach (Vector3 val in faceData)
{
array[num] = mesh.vertices[(int)val.x - 1];
if (val.y >= 1f)
{
array2[num] = mesh.uv[(int)val.y - 1];
}
if (val.z >= 1f)
{
array3[num] = mesh.normals[(int)val.z - 1];
}
num++;
}
Mesh val2 = new Mesh
{
vertices = array,
uv = array2,
normals = array3,
triangles = mesh.triangles
};
val2.RecalculateBounds();
val2.Optimize();
return val2;
}
private static meshStruct createMeshStruct(string filename)
{
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
meshStruct result = default(meshStruct);
result.fileName = filename;
StreamReader streamReader = File.OpenText(filename);
string s = streamReader.ReadToEnd();
streamReader.Close();
using (StringReader stringReader = new StringReader(s))
{
string text = stringReader.ReadLine();
char[] separator = new char[1] { ' ' };
while (text != null)
{
if (!text.StartsWith("f ") && !text.StartsWith("v ") && !text.StartsWith("vt ") && !text.StartsWith("vn "))
{
text = stringReader.ReadLine();
if (text != null)
{
text = text.Replace(" ", " ");
}
continue;
}
text = text.Trim();
string[] array = text.Split(separator, 50);
switch (array[0])
{
case "v":
num2++;
break;
case "vt":
num3++;
break;
case "vn":
num4++;
break;
case "f":
num5 = num5 + array.Length - 1;
num += 3 * (array.Length - 2);
break;
}
text = stringReader.ReadLine();
if (text != null)
{
text = text.Replace(" ", " ");
}
}
}
result.triangles = new int[num];
result.vertices = (Vector3[])(object)new Vector3[num2];
result.uv = (Vector2[])(object)new Vector2[num3];
result.normals = (Vector3[])(object)new Vector3[num4];
result.faceData = (Vector3[])(object)new Vector3[num5];
return result;
}
private static void populateMeshStruct(ref meshStruct mesh)
{
//IL_037d: Unknown result type (might be due to invalid IL or missing references)
//IL_0382: Unknown result type (might be due to invalid IL or missing references)
//IL_034e: Unknown result type (might be due to invalid IL or missing references)
//IL_0353: Unknown result type (might be due to invalid IL or missing references)
//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
//IL_031f: Unknown result type (might be due to invalid IL or missing references)
//IL_0324: Unknown result type (might be due to invalid IL or missing references)
//IL_03db: Unknown result type (might be due to invalid IL or missing references)
//IL_0448: Unknown result type (might be due to invalid IL or missing references)
//IL_044a: Unknown result type (might be due to invalid IL or missing references)
StreamReader streamReader = File.OpenText(mesh.fileName);
string s = streamReader.ReadToEnd();
streamReader.Close();
using StringReader stringReader = new StringReader(s);
string text = stringReader.ReadLine();
char[] separator = new char[1] { ' ' };
char[] separator2 = new char[1] { '/' };
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
int num6 = 0;
int num7 = 0;
while (text != null)
{
if (!text.StartsWith("f ") && !text.StartsWith("v ") && !text.StartsWith("vt ") && !text.StartsWith("vn ") && !text.StartsWith("g ") && !text.StartsWith("usemtl ") && !text.StartsWith("mtllib ") && !text.StartsWith("vt1 ") && !text.StartsWith("vt2 ") && !text.StartsWith("vc ") && !text.StartsWith("usemap "))
{
text = stringReader.ReadLine();
if (text != null)
{
text = text.Replace(" ", " ");
}
continue;
}
text = text.Trim();
string[] array = text.Split(separator, 50);
switch (array[0])
{
case "v":
mesh.vertices[num3] = new Vector3(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]), Convert.ToSingle(array[3]));
num3++;
break;
case "vt":
mesh.uv[num5] = new Vector2(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]));
num5++;
break;
case "vt1":
mesh.uv[num6] = new Vector2(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]));
num6++;
break;
case "vt2":
mesh.uv[num7] = new Vector2(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]));
num7++;
break;
case "vn":
mesh.normals[num4] = new Vector3(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]), Convert.ToSingle(array[3]));
num4++;
break;
case "f":
{
int num8 = 1;
List<int> list = new List<int>();
while (num8 < array.Length && (array[num8] ?? "").Length > 0)
{
Vector3 val = default(Vector3);
string[] array2 = array[num8].Split(separator2, 3);
val.x = Convert.ToInt32(array2[0]);
if (array2.Length > 1)
{
if (array2[1] != "")
{
val.y = Convert.ToInt32(array2[1]);
}
val.z = Convert.ToInt32(array2[2]);
}
num8++;
mesh.faceData[num2] = val;
list.Add(num2);
num2++;
}
for (num8 = 1; num8 + 2 < array.Length; num8++)
{
mesh.triangles[num] = list[0];
num++;
mesh.triangles[num] = list[num8];
num++;
mesh.triangles[num] = list[num8 + 1];
num++;
}
break;
}
}
text = stringReader.ReadLine();
if (text != null)
{
text = text.Replace(" ", " ");
}
}
}
}
namespace JotunnLib
{
public abstract class Manager : MonoBehaviour
{
internal virtual void Init()
{
}
internal virtual void Load()
{
}
internal virtual void Register()
{
}
}
[BepInPlugin("com.bepinex.plugins.jotunnlib", "JotunnLib", "0.1.9")]
public class JotunnLib : BaseUnityPlugin
{
public const string Version = "0.1.9";
public const string ModGuid = "com.bepinex.plugins.jotunnlib";
private readonly List<Type> managerTypes = new List<Type>
{
typeof(LocalizationManager),
typeof(EventManager),
typeof(CommandManager),
typeof(InputManager),
typeof(SkillManager),
typeof(PrefabManager),
typeof(PieceManager),
typeof(ObjectManager),
typeof(ZoneManager)
};
private readonly List<Manager> managers = new List<Manager>();
internal static GameObject RootObject;
private void Awake()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
new Harmony("jotunnlib").PatchAll();
RootObject = new GameObject("_JotunnLibRoot");
Object.DontDestroyOnLoad((Object)(object)RootObject);
foreach (Type managerType in managerTypes)
{
managers.Add((Manager)(object)RootObject.AddComponent(managerType));
}
foreach (Manager manager in managers)
{
manager.Init();
}
initCommands();
Debug.Log((object)"JotunnLib v0.1.9 loaded successfully");
}
private void initCommands()
{
}
}
}
namespace JotunnLib.Utils
{
public class ReflectionUtils
{
public static object InvokePrivate(object instance, string name, object[] args = null)
{
MethodInfo method = instance.GetType().GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic);
if (method == null)
{
Type[] types = ((args == null) ? new Type[0] : args.Select((object arg) => arg.GetType()).ToArray());
method = instance.GetType().GetMethod(name, types);
}
if (method == null)
{
Debug.LogError((object)("Method " + name + " does not exist on type: " + instance.GetType()));
return null;
}
return method.Invoke(instance, args);
}
public static T GetPrivateField<T>(object instance, string name)
{
FieldInfo field = instance.GetType().GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
if (field == null)
{
Debug.LogError((object)("Variable " + name + " does not exist on type: " + instance.GetType()));
return default(T);
}
return (T)field.GetValue(instance);
}
public static void SetPrivateField(object instance, string name, object value)
{
FieldInfo field = instance.GetType().GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
if (field == null)
{
Debug.LogError((object)("Variable " + name + " does not exist on type: " + instance.GetType()));
}
else
{
field.SetValue(instance, value);
}
}
public static T GetPrivateStaticField<T>(Type type, string name)
{
FieldInfo field = type.GetField(name, BindingFlags.Static | BindingFlags.NonPublic);
if (field == null)
{
Debug.LogError((object)("Variable " + name + " does not exist on static type: " + type));
return default(T);
}
return (T)field.GetValue(null);
}
}
public static class AssetUtils
{
public static Texture2D LoadTexture(string texturePath)
{
//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_002b: Expected O, but got Unknown
//IL_002d: Expected O, but got Unknown
string path = Path.Combine(Paths.PluginPath, texturePath);
if (!File.Exists(path))
{
return null;
}
byte[] array = File.ReadAllBytes(path);
Texture2D val = new Texture2D(2, 2);
ImageConversion.LoadImage(val, array);
return val;
}
public static Mesh LoadMesh(string meshPath)
{
string text = Path.Combine(Paths.PluginPath, meshPath);
if (!File.Exists(text))
{
return null;
}
return ObjImporter.ImportFile(text);
}
}
}
namespace JotunnLib.Patches
{
internal class ObjectDBPatches
{
[HarmonyPatch(typeof(ObjectDB), "Awake")]
public static class AwakePatch
{
public static void Postfix()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "main")
{
ObjectManager.Instance.Register();
ObjectManager.Instance.Load();
PieceManager.Instance.Register();
PieceManager.Instance.Load();
}
}
}
}
internal class ZInputPatches
{
[HarmonyPatch(typeof(ZInput), "Initialize")]
public static class InitializePatch
{
public static void Prefix()
{
InputManager.Instance.Register();
}
}
[HarmonyPatch(typeof(ZInput), "Reset")]
public static class ResetPatch
{
public static void Postfix(ref ZInput __instance)
{
InputManager.Instance.Load(__instance);
}
}
}
internal class ZoneSystemPatches
{
[HarmonyPatch(typeof(ZoneSystem), "Awake")]
public static class AwakePatch
{
public static void Postfix()
{
}
}
[HarmonyPatch(typeof(ZoneSystem), "SpawnZone")]
public static class SpawnZonePatch
{
public static void Prefix(Vector2i zoneID)
{
}
}
}
internal class ZNetScenePatches
{
[HarmonyPatch(typeof(ZNetScene), "Awake")]
public static class AwakePatch
{
public static void Postfix()
{
PrefabManager.Instance.Register();
PrefabManager.Instance.Load();
ZoneManager.Instance.Register();
ZoneManager.Instance.Load();
}
}
}
internal class PlayerPatches
{
[HarmonyPatch(typeof(Player), "OnSpawned")]
public static class OnSpawnedPatch
{
public static void Prefix(ref Player __instance, ref bool ___m_firstSpawn)
{
EventManager.OnPlayerSpawned(__instance);
}
}
[HarmonyPatch(typeof(Player), "PlacePiece")]
public static class PlacePiecePatch
{
public static void Postfix(ref Player __instance, Piece piece, bool __result, GameObject ___m_placementGhost)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
EventManager.OnPlayerPlacedPiece(new PlayerPlacedPieceEventArgs
{
Player = __instance,
Piece = piece,
Position = ___m_placementGhost.transform.position,
Rotation = ___m_placementGhost.transform.rotation,
Success = __result
});
}
}
}
internal class SkillsPatches
{
[HarmonyPatch(typeof(Skills), "Awake")]
public static class AwakePatch
{
public static void Postfix(ref Skills __instance)
{
foreach (KeyValuePair<SkillType, SkillDef> skill in SkillManager.Instance.Skills)
{
SkillDef value = skill.Value;
__instance.m_skills.Add(value);
Console.WriteLine("Added extra skill: " + ((object)(SkillType)(ref value.m_skill)).ToString());
}
}
}
[HarmonyPatch(typeof(Skills), "IsSkillValid")]
public static class IsSkillValidPatch
{
public static bool Prefix(ref bool __result, SkillType type)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
foreach (KeyValuePair<SkillType, SkillDef> skill in SkillManager.Instance.Skills)
{
if (skill.Value.m_skill == type)
{
__result = true;
return false;
}
}
return true;
}
}
}
}
namespace JotunnLib.Managers
{
public class CommandManager : Manager
{
private static List<ConsoleCommand> queuedCommands = new List<ConsoleCommand>();
public static CommandManager Instance { get; private set; }
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Debug.LogError((object)("Error, two instances of singleton: " + ((object)this).GetType().Name));
}
else
{
Instance = this;
}
}
[Obsolete("Please use RegisterConsoleCommand(Terminal.ConsoleCommand cmd) instead", false)]
public void RegisterConsoleCommand(ConsoleCommand cmd)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
RegisterConsoleCommand(new ConsoleCommand(cmd.Name, cmd.Help, (ConsoleEvent)delegate(ConsoleEventArgs args)
{
cmd.Run(args.Args);
}, false, false, false, false, false, (ConsoleOptionsFetcher)null));
}
public void RegisterConsoleCommand(ConsoleCommand cmd)
{
if (!ReflectionUtils.GetPrivateStaticField<bool>(typeof(Terminal), "m_terminalInitialized"))
{
queuedCommands.Add(cmd);
return;
}
Dictionary<string, ConsoleCommand> privateField = ReflectionUtils.GetPrivateField<Dictionary<string, ConsoleCommand>>(Console.instance, "commands");
if (queuedCommands.Count > 0)
{
foreach (ConsoleCommand queuedCommand in queuedCommands)
{
if (privateField.ContainsKey(queuedCommand.Command))
{
Debug.LogError((object)("Cannot have two console commands with same name: " + cmd.Command));
return;
}
privateField.Add(queuedCommand.Command, queuedCommand);
}
queuedCommands.Clear();
}
if (privateField.ContainsKey(cmd.Command))
{
Debug.LogError((object)("Cannot have two console commands with same name: " + cmd.Command));
}
else
{
privateField.Add(cmd.Command, cmd);
}
}
}
public class EventManager : Manager
{
internal static EventManager Instance { get; private set; }
public static event EventHandler<PlayerEventArgs> PlayerSpawned;
public static event EventHandler<PlayerPlacedPieceEventArgs> PlayerPlacedPiece;
private static event EventHandler PlayerDied;
private static event EventHandler PlayerSentChat;
private static event EventHandler<PlayerEventArgs> PlayerConnected;
private static event EventHandler<PlayerEventArgs> PlayerDisconnected;
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Debug.LogError((object)("Error, two instances of singleton: " + ((object)this).GetType().Name));
}
else
{
Instance = this;
}
}
internal static void OnPlayerSpawned(Player player)
{
EventManager.PlayerSpawned?.Invoke(player, new PlayerEventArgs
{
Player = player
});
}
internal static void OnPlayerPlacedPiece(PlayerPlacedPieceEventArgs args)
{
EventManager.PlayerPlacedPiece?.Invoke(args.Player, args);
}
}
public class InputManager : Manager
{
public EventHandler InputRegister;
internal static Dictionary<string, ButtonConfig> Buttons = new Dictionary<string, ButtonConfig>();
private bool inputsRegistered;
public static InputManager Instance { get; private set; }
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Debug.LogError((object)("Error, two instances of singleton: " + ((object)this).GetType().Name));
}
else
{
Instance = this;
}
}
internal void Load(ZInput zinput)
{
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
Debug.Log((object)"---- Registering custom inputs ----");
if (zinput == null)
{
Debug.LogError((object)"\t-> ZInput does not exist yet, delaying...");
return;
}
foreach (KeyValuePair<string, ButtonConfig> button in Buttons)
{
ButtonConfig value = button.Value;
if (value.Axis != null && value.Axis.Length > 0)
{
zinput.AddButton(value.Name, value.Axis, value.Inverted, value.RepeatDelay, value.RepeatInterval, true, false);
}
else
{
zinput.AddButton(value.Name, value.Key, value.RepeatDelay, value.RepeatInterval, true, false);
}
Debug.Log((object)("Registered input: " + button.Key));
}
}
internal override void Register()
{
if (!inputsRegistered)
{
InputRegister?.Invoke(null, EventArgs.Empty);
inputsRegistered = true;
}
}
public void RegisterButton(string name, ButtonConfig button)
{
if (Buttons.ContainsKey(name))
{
Debug.LogError((object)("Cannot have duplicate button: " + name));
}
else
{
Buttons.Add(name, button);
}
}
public void RegisterButton(string name, KeyCode key, float repeatDelay = 0f, float repeatInterval = 0f)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (Buttons.ContainsKey(name))
{
Debug.LogError((object)("Cannot have duplicate button: " + name));
return;
}
Buttons.Add(name, new ButtonConfig
{
Name = name,
Key = key,
RepeatDelay = repeatDelay,
RepeatInterval = repeatInterval
});
}
public void RegisterButton(string name, string axis, bool inverted = false, float repeatDelay = 0f, float repeatInterval = 0f)
{
if (Buttons.ContainsKey(name))
{
Debug.LogError((object)("Cannot have duplicate button: " + name));
return;
}
Buttons.Add(name, new ButtonConfig
{
Name = name,
Axis = axis,
Inverted = inverted,
RepeatDelay = repeatDelay,
RepeatInterval = repeatInterval
});
}
}
public class LocalizationManager : Manager
{
internal Dictionary<string, List<LocalizationConfig>> Localizations = new Dictionary<string, List<LocalizationConfig>>();
public static LocalizationManager Instance { get; private set; }
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Debug.LogError((object)("Error, two instances of singleton: " + ((object)this).GetType().Name));
}
else
{
Instance = this;
}
}
public void RegisterTranslation(string key, string text)
{
ReflectionUtils.InvokePrivate(Localization.instance, "AddWord", new object[2] { key, text });
}
internal void RegisterTranslation(LocalizationConfig localization)
{
}
}
public class ObjectManager : Manager
{
internal List<GameObject> Items = new List<GameObject>();
internal List<Recipe> Recipes = new List<Recipe>();
public static ObjectManager Instance { get; private set; }
public event EventHandler ObjectRegister;
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Debug.LogError((object)("Error, two instances of singleton: " + ((object)this).GetType().Name));
}
else
{
Instance = this;
}
}
internal override void Register()
{
Debug.Log((object)"---- Registering custom objects ----");
Items.Clear();
Recipes.Clear();
this.ObjectRegister?.Invoke(null, EventArgs.Empty);
}
internal override void Load()
{
Debug.Log((object)"---- Loading custom objects ----");
foreach (GameObject item in Items)
{
try
{
ObjectDB.instance.m_items.Add(item);
Debug.Log((object)("Loaded item: " + ((Object)item).name));
}
catch (Exception ex)
{
Debug.Log((object)("Error loading item: " + ex));
}
}
foreach (Recipe recipe in Recipes)
{
try
{
ObjectDB.instance.m_recipes.Add(recipe);
Debug.Log((object)("Loaded item recipe: " + ((Object)recipe).name));
}
catch (Exception ex2)
{
Debug.Log((object)("Error loading recipe: " + ex2));
}
}
try
{
ReflectionUtils.InvokePrivate(ObjectDB.instance, "UpdateItemHashes");
}
catch (Exception ex3)
{
Debug.Log((object)("Error updating item hashes: " + ex3));
}
}
public void RegisterItem(string prefabName)
{
Items.Add(PrefabManager.Instance.GetPrefab(prefabName));
}
public void RegisterItem(GameObject item)
{
if (item.layer == 0)
{
item.layer = LayerMask.NameToLayer("item");
}
Items.Add(item);
}
public void RegisterRecipe(RecipeConfig recipeConfig)
{
Recipe recipe = recipeConfig.GetRecipe();
if ((Object)(object)recipe == (Object)null)
{
Debug.LogError((object)("Failed to add recipe for item: " + recipeConfig.Item));
}
else
{
Recipes.Add(recipe);
}
}
public void RegisterRecipe(Recipe recipe)
{
if ((Object)(object)recipe == (Object)null)
{
Debug.LogError((object)"Failed to add null recipe");
}
else
{
Recipes.Add(recipe);
}
}
public GameObject GetItemPrefab(string name)
{
if (string.IsNullOrEmpty(name))
{
return null;
}
return ObjectDB.instance.GetItemPrefab(name);
}
public ItemDrop GetItemDrop(string name)
{
GameObject itemPrefab = GetItemPrefab(name);
if (itemPrefab == null)
{
return null;
}
return itemPrefab.GetComponent<ItemDrop>();
}
}
public class PieceManager : Manager
{
internal GameObject PieceTableContainer;
private bool loaded;
private Dictionary<string, PieceTable> pieceTables = new Dictionary<string, PieceTable>();
private Dictionary<string, string> pieceTableNameMap = new Dictionary<string, string>
{
{ "Cultivator", "_CultivatorPieceTable" },
{ "Hammer", "_HammerPieceTable" },
{ "Hoe", "_HoePieceTable" }
};
public static PieceManager Instance { get; private set; }
public event EventHandler PieceTableRegister;
public event EventHandler PieceRegister;
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Debug.LogError((object)("Error, two instances of singleton: " + ((object)this).GetType().Name));
}
else
{
Instance = this;
}
}
internal override void Init()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
PieceTableContainer = new GameObject("PieceTables");
PieceTableContainer.transform.parent = JotunnLib.RootObject.transform;
Debug.Log((object)"Initialized PieceTableManager");
}
internal override void Register()
{
}
internal override void Load()
{
//IL_002d: 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_008a: Expected O, but got Unknown
if (loaded)
{
return;
}
pieceTables.Clear();
foreach (Transform item in PieceTableContainer.transform)
{
Object.Destroy((Object)(object)((Component)item).gameObject);
}
List<string> list = new List<string>();
Debug.Log((object)"---- Loading piece tables ----");
Object[] array = Resources.FindObjectsOfTypeAll(typeof(PieceTable));
for (int i = 0; i < array.Length; i++)
{
PieceTable val = (PieceTable)array[i];
try
{
string name = ((Object)((Component)val).gameObject).name;
if (!pieceTables.ContainsKey(name))
{
pieceTables.Add(name, val);
}
if (!list.Contains(name))
{
list.Add(name);
Debug.Log((object)("Loaded existing piece table: " + name));
}
}
catch (Exception ex)
{
Debug.Log((object)("Error loading piece table: " + ex));
}
}
this.PieceTableRegister?.Invoke(null, EventArgs.Empty);
foreach (KeyValuePair<string, PieceTable> pieceTable in pieceTables)
{
try
{
PieceTable value = pieceTable.Value;
string name2 = ((Object)((Component)value).gameObject).name;
if (!list.Contains(name2))
{
pieceTables.Add(name2, value);
Debug.Log((object)("Registered piece table: " + name2));
}
}
catch (Exception ex2)
{
Debug.Log((object)("Error registering piece table: " + ex2));
}
}
Debug.Log((object)"---- Loading pieces ----");
this.PieceRegister?.Invoke(null, EventArgs.Empty);
loaded = true;
}
public void RegisterPieceTable(string name)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
if (pieceTables.ContainsKey(name))
{
Debug.Log((object)("Failed to register piece table with existing name: " + name));
return;
}
GameObject val = new GameObject(name);
val.transform.parent = PieceTableContainer.transform;
PieceTable value = val.AddComponent<PieceTable>();
pieceTables.Add(name, value);
}
public void RegisterPiece(string pieceTable, string prefabName)
{
GameObject prefab = PrefabManager.Instance.GetPrefab(prefabName);
if (!Object.op_Implicit((Object)(object)prefab))
{
Debug.LogError((object)("Failed to register Piece with invalid prefab: " + prefabName));
}
else
{
RegisterPiece(pieceTable, prefab);
}
}
internal void RegisterPiece(string pieceTable, GameObject prefab)
{
PieceTable pieceTable2 = getPieceTable(pieceTable);
if (!Object.op_Implicit((Object)(object)pieceTable2))
{
Debug.LogError((object)("Failed to register piece, Piece table does not exist: " + pieceTable));
return;
}
if (!Object.op_Implicit((Object)(object)prefab))
{
Debug.LogError((object)"Failed to register Piece with null prefab");
return;
}
if (!Object.op_Implicit((Object)(object)prefab.GetComponent<Piece>()))
{
Debug.LogError((object)("Failed to register piece, Prefab does not have Piece component: " + ((Object)prefab).name));
return;
}
if (prefab.layer == 0)
{
prefab.layer = LayerMask.NameToLayer("piece");
}
pieceTable2.m_pieces.Add(prefab);
Debug.Log((object)("Registered piece: " + ((Object)prefab).name + " to " + pieceTable));
}
private PieceTable getPieceTable(string name)
{
if (pieceTables.ContainsKey(name))
{
return pieceTables[name];
}
if (pieceTableNameMap.ContainsKey(name))
{
return pieceTables[pieceTableNameMap[name]];
}
return null;
}
}
public class PrefabManager : Manager
{
internal static GameObject PrefabContainer;
internal Dictionary<string, GameObject> Prefabs = new Dictionary<string, GameObject>();
private bool loaded;
public static PrefabManager Instance { get; private set; }
public event EventHandler PrefabRegister;
public event EventHandler PrefabsLoaded;
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Debug.LogError((object)("Error, two instances of singleton: " + ((object)this).GetType().Name));
}
else
{
Instance = this;
}
}
internal override void Init()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
PrefabContainer = new GameObject("Prefabs");
PrefabContainer.transform.parent = JotunnLib.RootObject.transform;
PrefabContainer.SetActive(false);
Debug.Log((object)"Initialized PrefabManager");
}
internal override void Register()
{
}
internal override void Load()
{
Debug.Log((object)"---- Registering custom prefabs ----");
if (!loaded)
{
this.PrefabRegister?.Invoke(null, EventArgs.Empty);
}
Dictionary<int, GameObject> privateField = ReflectionUtils.GetPrivateField<Dictionary<int, GameObject>>(ZNetScene.instance, "m_namedPrefabs");
foreach (KeyValuePair<string, GameObject> prefab in Prefabs)
{
try
{
GameObject value = prefab.Value;
ZNetScene.instance.m_prefabs.Add(value);
privateField.Add(StringExtensionMethods.GetStableHashCode(((Object)value).name), value);
Debug.Log((object)("Registered prefab: " + prefab.Key));
}
catch (Exception ex)
{
Debug.Log((object)("Error registering prefab: " + ex));
}
}
if (!loaded)
{
this.PrefabsLoaded?.Invoke(null, EventArgs.Empty);
}
Debug.Log((object)"All prefabs loaded");
loaded = true;
}
public void RegisterPrefab(GameObject prefab, string name = null)
{
if (name == null)
{
name = ((Object)prefab).name;
}
if (Object.op_Implicit((Object)(object)GetPrefab(name)))
{
Debug.LogError((object)("Failed to register prefab that already exists: " + name));
return;
}
((Object)prefab).name = name;
prefab.transform.parent = PrefabContainer.transform;
prefab.SetActive(true);
Prefabs.Add(name, prefab);
}
public void RegisterPrefab(PrefabConfig prefabConfig)
{
if (prefabConfig.BasePrefabName == null || prefabConfig.BasePrefabName == "")
{
prefabConfig.Prefab = CreatePrefab(prefabConfig.Name);
}
else
{
prefabConfig.Prefab = CreatePrefab(prefabConfig.Name, prefabConfig.BasePrefabName);
}
if ((Object)(object)prefabConfig.Prefab != (Object)null)
{
prefabConfig.Register();
}
}
public GameObject CreatePrefab(string name)
{
if (string.IsNullOrEmpty(name))
{
Debug.LogError((object)("Failed to create prefab with invalid name: " + name));
return null;
}
if (Object.op_Implicit((Object)(object)GetPrefab(name)))
{
Debug.LogError((object)("Failed to create prefab, name already exists: " + name));
return null;
}
GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
((Object)val).name = name;
val.transform.parent = PrefabContainer.transform;
val.AddComponent<ZNetView>().m_persistent = true;
Prefabs.Add(name, val);
return val;
}
public GameObject CreatePrefab(string name, string baseName)
{
if (string.IsNullOrEmpty(name))
{
Debug.LogError((object)("Failed to create prefab with invalid name: " + name));
return null;
}
if (Object.op_Implicit((Object)(object)GetPrefab(name)))
{
Debug.LogError((object)("Failed to create prefab, name already exists: " + name));
return null;
}
GameObject prefab = GetPrefab(baseName);
if (!Object.op_Implicit((Object)(object)prefab))
{
Debug.LogError((object)("Failed to create prefab, base does not exist: " + baseName));
return null;
}
GameObject val = Object.Instantiate<GameObject>(prefab, PrefabContainer.transform);
((Object)val).name = name;
val.SetActive(true);
Prefabs.Add(name, val);
return val;
}
public GameObject GetPrefab(string name)
{
if (string.IsNullOrEmpty(name))
{
return null;
}
if (Prefabs.ContainsKey(name))
{
return Prefabs[name];
}
if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
{
Debug.LogError((object)"\t-> ZNetScene instance null for some reason");
return null;
}
Dictionary<int, GameObject> privateField = ReflectionUtils.GetPrivateField<Dictionary<int, GameObject>>(ZNetScene.instance, "m_namedPrefabs");
int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
if (privateField.ContainsKey(stableHashCode))
{
return privateField[stableHashCode];
}
return null;
}
}
internal class ZoneManager : Manager
{
internal List<ZoneVegetation> Vegetation = new List<ZoneVegetation>();
public static ZoneManager Instance { get; private set; }
public event EventHandler ZoneLoad;
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Debug.LogError((object)("Error, two instances of singleton: " + ((object)this).GetType().Name));
}
else
{
Instance = this;
}
}
internal override void Register()
{
Debug.Log((object)"---- Registering custom zone data ----");
this.ZoneLoad?.Invoke(null, EventArgs.Empty);
foreach (ZoneVegetation item in Vegetation)
{
ZoneSystem.instance.m_vegetation.Add(item);
Debug.Log((object)("Added vegetation: " + item.m_name));
}
}
public void RegisterVegetation(ZoneVegetation veg)
{
Vegetation.Add(veg);
}
}
public class SkillManager : Manager
{
internal Dictionary<SkillType, SkillDef> Skills = new Dictionary<SkillType, SkillDef>();
private int nextSkillId = 1000;
public static SkillManager Instance { get; private set; }
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Debug.LogError((object)("Error, two instances of singleton: " + ((object)this).GetType().Name));
}
else
{
Instance = this;
}
}
[Obsolete("Use `RegisterSkill(SkillConfig config)` instead. This method could potentially cause users to lose skill save progress", true)]
public SkillType RegisterSkill(string name, string description, float increaseStep = 1f, Sprite icon = null)
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Expected O, but got Unknown
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
LocalizationManager.Instance.RegisterTranslation("skill_" + nextSkillId, name);
LocalizationManager.Instance.RegisterTranslation("skill_" + nextSkillId + "_description", description);
SkillDef val = new SkillDef
{
m_skill = (SkillType)nextSkillId,
m_description = "$skill_" + nextSkillId + "_description",
m_increseStep = increaseStep,
m_icon = icon
};
Skills.Add((SkillType)nextSkillId, val);
nextSkillId++;
return val.m_skill;
}
public SkillType RegisterSkill(SkillConfig skillConfig, bool registerLocalizations = true)
{
//IL_002b: 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: Invalid comparison between Unknown and I4
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Expected I4, but got Unknown
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Expected O, but got Unknown
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: 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)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
if (string.IsNullOrEmpty(skillConfig.Identifier))
{
Debug.LogError((object)("Failed to register skill with invalid identifier: " + skillConfig.Identifier));
return (SkillType)0;
}
SkillType uID;
if (Skills.ContainsKey(skillConfig.UID))
{
uID = skillConfig.UID;
Debug.LogError((object)("Failed to register skill with conflicting UID (m_skill): " + ((object)(SkillType)(ref uID)).ToString()));
return (SkillType)0;
}
if ((int)skillConfig.UID < 1000)
{
Debug.LogError((object)("Failed to register skill with invalid UID (m_skill), please use a UID >= 1000: " + (int)skillConfig.UID));
return (SkillType)0;
}
if (registerLocalizations)
{
LocalizationManager instance = LocalizationManager.Instance;
uID = skillConfig.UID;
instance.RegisterTranslation("skill_" + ((object)(SkillType)(ref uID)).ToString(), skillConfig.Name);
LocalizationManager instance2 = LocalizationManager.Instance;
uID = skillConfig.UID;
instance2.RegisterTranslation("skill_" + ((object)(SkillType)(ref uID)).ToString() + "_description", skillConfig.Description);
}
SkillDef val = new SkillDef
{
m_skill = skillConfig.UID
};
uID = skillConfig.UID;
val.m_description = "$skill_" + ((object)(SkillType)(ref uID)).ToString() + "_description";
val.m_increseStep = skillConfig.IncreaseStep;
val.m_icon = skillConfig.Icon;
SkillDef val2 = val;
Skills.Add(skillConfig.UID, val2);
return val2.m_skill;
}
public SkillType RegisterSkill(string identifer, string name, string description, float increaseStep = 1f, Sprite icon = null, bool registerLocalizations = true)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
return RegisterSkill(new SkillConfig
{
Identifier = identifer,
Name = name,
Description = description,
IncreaseStep = increaseStep,
Icon = icon
}, registerLocalizations);
}
public SkillDef GetSkill(SkillType skillType)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
if (Skills.ContainsKey(skillType))
{
return Skills[skillType];
}
if ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)((Character)Player.m_localPlayer).GetSkills() != (Object)null)
{
foreach (SkillDef skill in ((Character)Player.m_localPlayer).GetSkills().m_skills)
{
if (skill.m_skill == skillType)
{
return skill;
}
}
}
return null;
}
public SkillDef GetSkill(string identifier)
{
if (string.IsNullOrEmpty(identifier))
{
return null;
}
return GetSkill((SkillType)StringExtensionMethods.GetStableHashCode(identifier));
}
}
}
namespace JotunnLib.Events
{
public class PlayerEventArgs : EventArgs
{
public Player Player { get; set; }
}
public class PlayerPlacedPieceEventArgs : PlayerEventArgs
{
public Piece Piece { get; set; }
public Vector3 Position { get; set; }
public Quaternion Rotation { get; set; }
public bool Success { get; set; }
}
}
namespace JotunnLib.Entities
{
public class ButtonConfig
{
public string Name { get; set; }
public string Axis { get; set; }
public KeyCode Key { get; set; }
public bool Inverted { get; set; }
public float RepeatDelay { get; set; }
public float RepeatInterval { get; set; }
}
internal class LocalizationConfig
{
public Dictionary<string, string> Translations = new Dictionary<string, string>();
public string Language { get; set; } = "English";
}
public class PieceConfig
{
public string Name { get; set; }
public string Description { get; set; } = "";
public PieceRequirementConfig[] Requirements { get; set; } = new PieceRequirementConfig[0];
public Requirement[] GetRequirements()
{
Requirement[] array = (Requirement[])(object)new Requirement[Requirements.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = Requirements[i].GetPieceRequirement();
}
return array;
}
}
public class PieceRequirementConfig
{
public string Item { get; set; }
public int Amount { get; set; }
public int AmountPerLevel { get; set; }
public bool Recover { get; set; }
public Requirement GetPieceRequirement()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: 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_0045: Expected O, but got Unknown
return new Requirement
{
m_resItem = PrefabManager.Instance.GetPrefab(Item).GetComponent<ItemDrop>(),
m_amount = Amount,
m_amountPerLevel = AmountPerLevel,
m_recover = Recover
};
}
}
public abstract class PrefabConfig
{
public string Name { get; private set; }
public string BasePrefabName { get; private set; }
public GameObject Prefab { get; set; }
public PrefabConfig(string name)
{
Name = name;
}
public PrefabConfig(string name, string baseName)
{
Name = name;
BasePrefabName = baseName;
}
public abstract void Register();
public Piece AddPiece(PieceConfig pieceConfig)
{
Piece obj = Prefab.AddComponent<Piece>();
obj.m_name = pieceConfig.Name;
obj.m_description = pieceConfig.Description;
obj.m_resources = pieceConfig.GetRequirements();
return obj;
}
}
public class RecipeConfig
{
public string Name { get; set; }
public string Item { get; set; }
public int Amount { get; set; } = 1;
public bool Enabled { get; set; } = true;
public string CraftingStation { get; set; }
public string RepairStation { get; set; }
public int MinStationLevel { get; set; }
public PieceRequirementConfig[] Requirements { get; set; } = new PieceRequirementConfig[0];
public Recipe GetRecipe()
{
Requirement[] array = (Requirement[])(object)new Requirement[Requirements.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = Requirements[i].GetPieceRequirement();
}
Recipe val = ScriptableObject.CreateInstance<Recipe>();
GameObject prefab = PrefabManager.Instance.GetPrefab(Item);
if ((Object)(object)prefab == (Object)null)
{
Debug.LogError((object)("Error, recipe contained null item prefab for item: " + Item));
return null;
}
if (string.IsNullOrEmpty(Name))
{
Name = "Recipe_" + Item;
}
((Object)val).name = Name;
val.m_item = prefab.GetComponent<ItemDrop>();
val.m_amount = Amount;
val.m_enabled = Enabled;
if (CraftingStation != null)
{
GameObject prefab2 = PrefabManager.Instance.GetPrefab(CraftingStation);
CraftingStation component = prefab2.GetComponent<CraftingStation>();
if ((Object)(object)prefab2 == (Object)null || (Object)(object)component == (Object)null)
{
Debug.LogError((object)("Crafting station is not valid: " + CraftingStation));
return null;
}
val.m_craftingStation = component;
}
if (RepairStation != null)
{
GameObject prefab3 = PrefabManager.Instance.GetPrefab(RepairStation);
CraftingStation component2 = prefab3.GetComponent<CraftingStation>();
if ((Object)(object)prefab3 == (Object)null || (Object)(object)component2 == (Object)null)
{
Debug.LogError((object)("Repair station is not valid: " + RepairStation));
return null;
}
val.m_craftingStation = component2;
}
val.m_minStationLevel = MinStationLevel;
val.m_resources = array;
return val;
}
}
public class SkillConfig
{
private string _identifier;
public string Identifier
{
get
{
return _identifier;
}
set
{
if (string.IsNullOrEmpty(value))
{
Debug.LogError((object)("Error, SkillConfig cannot have invalid Identifier: " + value));
return;
}
_identifier = value;
UID = (SkillType)StringExtensionMethods.GetStableHashCode(value);
}
}
public SkillType UID { get; private set; }
public string Name { get; set; }
public string Description { get; set; }
public Sprite Icon { get; set; }
public float IncreaseStep { get; set; }
}
public abstract class ConsoleCommand
{
public abstract string Name { get; }
public abstract string Help { get; }
public abstract void Run(string[] args);
}
}
