Decompiled source of TestModPleaseIgnoreIV v1.0.0

TMPI.dll

Decompiled 7 months ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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 BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Bloodstone.API;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppSystem;
using Microsoft.CodeAnalysis;
using ProjectM;
using TMPI.Augments;
using TMPI.Core;
using Unity.Collections;
using Unity.Entities;
using VRising.GameData;
using VRising.GameData.Methods;
using VRising.GameData.Models;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("TMPI")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5af46a5de12e23c1bcbc95f673fb15f9ceb81a2b")]
[assembly: AssemblyProduct("TMPI")]
[assembly: AssemblyTitle("TMPI")]
[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 TMPI
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "TMPI";

		public const string PLUGIN_NAME = "TMPI";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace TMPI.Hooks
{
	[HarmonyPatch]
	internal class VBloodConsumed
	{
		[HarmonyPatch(typeof(VBloodSystem), "OnUpdate")]
		[HarmonyPrefix]
		public static void OnUpdate(VBloodSystem __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//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_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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0059: 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_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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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)
			if (__instance.EventList.IsEmpty)
			{
				return;
			}
			EntityManager entityManager = VWorld.Server.EntityManager;
			Enumerator<VBloodConsumed> enumerator = __instance.EventList.GetEnumerator();
			PlayerCharacter val = default(PlayerCharacter);
			PrefabGUID val4 = default(PrefabGUID);
			Entity val5 = default(Entity);
			bool flag = default(bool);
			while (enumerator.MoveNext())
			{
				VBloodConsumed current = enumerator.Current;
				if (!((EntityManager)(ref entityManager)).TryGetComponentData<PlayerCharacter>(current.Target, ref val))
				{
					continue;
				}
				Entity val2 = __instance._PrefabCollectionSystem._PrefabGuidToEntityMap[current.Source];
				Entity userEntity = val.UserEntity;
				ConvertedAssetData val3 = __instance._PrefabCollectionSystem._PrefabDataLookup[current.Source];
				string text = ((object)(FixedString128)(ref val3.AssetName)).ToString();
				string text2 = ((object)(FixedString64)(ref val.Name)).ToString();
				UserModel userByCharacterName = GameData.Users.GetUserByCharacterName(text2);
				Entity character = userByCharacterName.FromCharacter.Character;
				try
				{
					if (text == "CHAR_ChurchOfLight_Paladin_VBlood")
					{
						((PrefabGUID)(ref val4))..ctor(2019195024);
						if (InventoryUtilities.TryGetInventoryEntity(entityManager, character, ref val5, 0))
						{
							InventoryUtilitiesServer.TryRemoveItem(entityManager, val5, val4, 1);
						}
						AddItemToInventory(val4, 1, userByCharacterName);
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger = Plugin.Logger;
					BepInExErrorLogInterpolatedStringHandler val6 = new BepInExErrorLogInterpolatedStringHandler(7, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val6).AppendLiteral("Error: ");
						((BepInExLogInterpolatedStringHandler)val6).AppendFormatted<Exception>(ex);
					}
					logger.LogError(val6);
				}
			}
		}

		public static void AddItemToInventory(PrefabGUID guid, int amount, UserModel user)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Entity val = default(Entity);
			UserModelMethods.TryGiveItem(user, guid, 1, ref val);
		}
	}
}
namespace TMPI.Core
{
	[BepInPlugin("TMPI", "TMPI", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin, IRunOnInitialized
	{
		private Harmony _harmony;

		public static ManualLogSource Logger;

		public static readonly string ConfigPath = Path.Combine(Paths.ConfigPath, "TMPI");

		public static bool shardDrop;

		public static bool setBonus;

		internal static Plugin Instance { get; private set; }

		public override void Load()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			Instance = this;
			Logger = ((BasePlugin)this).Log;
			_harmony = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), (string)null);
			ServerEvents.OnGameDataInitialized += GameDataOnInitialize;
			GameData.OnInitialize += new OnGameDataInitializedEventHandler(GameDataOnInitialize);
			InitConfig();
		}

		private void GameDataOnInitialize(World world)
		{
			ArmorModifierSystem.ModifyArmorPrefabEquipmentSet();
		}

		private void InitConfig()
		{
			shardDrop = ((BasePlugin)this).Config.Bind<bool>("Config", "ShardDrop", false, "Enables shard drop from Solarus.").Value;
			setBonus = ((BasePlugin)this).Config.Bind<bool>("Config", "SetBonus", false, "Enables Bloodmoon set bonus for Death gear.").Value;
			if (!Directory.Exists(ConfigPath))
			{
				Directory.CreateDirectory(ConfigPath);
			}
		}

		public override bool Unload()
		{
			((BasePlugin)this).Config.Clear();
			_harmony.UnpatchSelf();
			return true;
		}

		public void OnGameInitialized()
		{
		}
	}
	public delegate void OnGameDataInitializedEventHandler(World world);
	internal class ServerEvents
	{
		internal static event OnGameDataInitializedEventHandler OnGameDataInitialized;

		[HarmonyPatch(typeof(LoadPersistenceSystemV2), "SetLoadState")]
		[HarmonyPostfix]
		private static void ServerStartupStateChange_Postfix(State loadState, LoadPersistenceSystemV2 __instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			try
			{
				if ((int)loadState == 4)
				{
					ServerEvents.OnGameDataInitialized?.Invoke(((ComponentSystemBase)__instance).World);
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)ex);
			}
		}
	}
	public static class Utilities
	{
		public static Type Il2CppTypeGet(Type type)
		{
			return Type.GetType(type.ToString());
		}

		public static ComponentType ComponentTypeGet(string component)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ComponentType.ReadOnly(Type.GetType(component));
		}

		public static bool HasComponent<T>(Entity entity) where T : struct
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			EntityManager entityManager = VWorld.Server.EntityManager;
			return ((EntityManager)(ref entityManager)).HasComponent(entity, ComponentTypeOther<T>());
		}

		public static bool AddComponent<T>(Entity entity) where T : struct
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			EntityManager entityManager = VWorld.Server.EntityManager;
			return ((EntityManager)(ref entityManager)).AddComponent(entity, ComponentTypeOther<T>());
		}

		public static void AddComponentData<T>(Entity entity, T componentData) where T : struct
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			AddComponent<T>(entity);
			SetComponentData(entity, componentData);
		}

		public static bool RemoveComponent<T>(Entity entity) where T : struct
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			EntityManager entityManager = VWorld.Server.EntityManager;
			return ((EntityManager)(ref entityManager)).RemoveComponent(entity, ComponentTypeOther<T>());
		}

		public unsafe static T GetComponentData<T>(Entity entity) where T : struct
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			EntityManager entityManager = VWorld.Server.EntityManager;
			void* componentDataRawRO = ((EntityManager)(ref entityManager)).GetComponentDataRawRO(entity, ComponentTypeIndex<T>());
			return Marshal.PtrToStructure<T>(new IntPtr(componentDataRawRO));
		}

		public unsafe static void SetComponentData<T>(Entity entity, T componentData) where T : struct
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			int num = Marshal.SizeOf(componentData);
			fixed (byte* ptr = StructureToByteArray(componentData))
			{
				EntityManager entityManager = VWorld.Server.EntityManager;
				((EntityManager)(ref entityManager)).SetComponentDataRaw(entity, ComponentTypeIndex<T>(), (void*)ptr, num);
			}
		}

		private static ComponentType ComponentTypeOther<T>()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return new ComponentType(Il2CppType.Of<T>(), (AccessMode)0);
		}

		private static int ComponentTypeIndex<T>()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ComponentTypeOther<T>().TypeIndex;
		}

		private static byte[] StructureToByteArray<T>(T structure) where T : struct
		{
			int num = Marshal.SizeOf(structure);
			byte[] array = new byte[num];
			IntPtr intPtr = Marshal.AllocHGlobal(num);
			try
			{
				Marshal.StructureToPtr(structure, intPtr, fDeleteOld: true);
				Marshal.Copy(intPtr, array, 0, num);
				return array;
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}
	}
}
namespace TMPI.Augments
{
	public static class ArmorModifierSystem
	{
		public static void ModifyArmorPrefabEquipmentSet()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			EntityManager entityManager = VWorld.Server.EntityManager;
			List<PrefabGUID> list = new List<PrefabGUID>
			{
				new PrefabGUID(1055898174),
				new PrefabGUID(1400688919),
				new PrefabGUID(125611165),
				new PrefabGUID(-204401621)
			};
			PrefabGUID equipmentSet = default(PrefabGUID);
			((PrefabGUID)(ref equipmentSet))..ctor(35317589);
			bool flag = default(bool);
			foreach (PrefabGUID item in list)
			{
				Entity prefabEntityByPrefabGUID = GetPrefabEntityByPrefabGUID(item, entityManager);
				if (prefabEntityByPrefabGUID != Entity.Null)
				{
					EquippableData componentData = Utilities.GetComponentData<EquippableData>(prefabEntityByPrefabGUID);
					componentData.EquipmentSet = equipmentSet;
					Utilities.SetComponentData<EquippableData>(prefabEntityByPrefabGUID, componentData);
					continue;
				}
				ManualLogSource logger = Plugin.Logger;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(39, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Could not find prefab entity for GUID: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<PrefabGUID>(item);
				}
				logger.LogInfo(val);
			}
		}

		public static Entity GetPrefabEntityByPrefabGUID(PrefabGUID prefabGUID, EntityManager entityManager)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				PrefabCollectionSystem existingSystem = ((EntityManager)(ref entityManager)).World.GetExistingSystem<PrefabCollectionSystem>();
				return existingSystem._PrefabGuidToEntityMap[prefabGUID];
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(7, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Error: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				logger.LogError(val);
				return Entity.Null;
			}
		}
	}
}

VRising.GameData.dll

Decompiled 7 months ago
#define DEBUG
using System;
using System.Collections.Generic;
using System.Diagnostics;
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.Core.Logging.Interpolation;
using BepInEx.Logging;
using HarmonyLib;
using Il2CppSystem;
using Microsoft.CodeAnalysis;
using ProjectM;
using ProjectM.Auth;
using ProjectM.Behaviours;
using ProjectM.CastleBuilding;
using ProjectM.CastleBuilding.Placement;
using ProjectM.Gameplay;
using ProjectM.Gameplay.Clan;
using ProjectM.Gameplay.Scripting;
using ProjectM.Hybrid;
using ProjectM.Network;
using ProjectM.Pathfinding;
using ProjectM.Physics;
using ProjectM.Portrait;
using ProjectM.Roofs;
using ProjectM.Scripting;
using ProjectM.Sequencer;
using ProjectM.Shared;
using ProjectM.Terrain;
using ProjectM.Tiles;
using ProjectM.UI;
using Stunlock.Core;
using Stunlock.Localization;
using Stunlock.Sequencer;
using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Physics;
using Unity.Physics.Systems;
using Unity.Scenes;
using Unity.Transforms;
using UnityEngine;
using VRising.GameData.Models;
using VRising.GameData.Models.Base;
using VRising.GameData.Models.Data;
using VRising.GameData.Models.Internals;
using VRising.GameData.Patch;
using VRising.GameData.Utils;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("VRising.GameData")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("An extensible framework to access V Rising ECS data")]
[assembly: AssemblyFileVersion("0.3.3.0")]
[assembly: AssemblyInformationalVersion("0.3.3")]
[assembly: AssemblyProduct("VRising.GameData")]
[assembly: AssemblyTitle("VRising.GameData")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/adainrivers/VRising.GameData")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.3.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 VRising.GameData
{
	public delegate void OnGameDataInitializedEventHandler(World world);
	public delegate void OnGameDataDestroyedEventHandler();
	public static class GameData
	{
		private static bool _initialized;

		private static bool _worldDataInitialized;

		private const string NotInitializedError = "GameData is not initialized";

		public static bool IsServer;

		public static bool IsClient;

		private static World _world;

		private static Harmony _harmonyInstance;

		internal static ManualLogSource Logger;

		public static GameVersionData GameVersion => GameVersionUtils.GetVersionData();

		public static World World => _world ?? throw new InvalidOperationException("GameData is not initialized");

		public static Systems Systems
		{
			get
			{
				if (!_worldDataInitialized)
				{
					throw new InvalidOperationException("GameData is not initialized");
				}
				return Systems.Instance;
			}
		}

		public static Users Users
		{
			get
			{
				if (!_worldDataInitialized)
				{
					throw new InvalidOperationException("GameData is not initialized");
				}
				return Users.Instance;
			}
		}

		public static Items Items
		{
			get
			{
				if (!_worldDataInitialized)
				{
					throw new InvalidOperationException("GameData is not initialized");
				}
				return Items.Instance;
			}
		}

		public static Npcs Npcs
		{
			get
			{
				if (!_worldDataInitialized)
				{
					throw new InvalidOperationException("GameData is not initialized");
				}
				return Npcs.Instance;
			}
		}

		public static bool Initialized => _worldDataInitialized;

		public static event OnGameDataInitializedEventHandler OnInitialize;

		public static event OnGameDataDestroyedEventHandler OnDestroy;

		static GameData()
		{
			IsServer = Application.productName == "VRisingServer";
			IsClient = Application.productName == "VRising";
			Logger = Logger.CreateLogSource("VRising.GameData");
			Create();
		}

		internal static void Create()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if (!_initialized)
			{
				_initialized = true;
				_harmonyInstance = new Harmony("VRising.GameData");
				if (IsClient)
				{
					_harmonyInstance.PatchAll(typeof(ClientEvents));
					ClientEvents.OnGameDataInitialized += OnGameDataInitialized;
					ClientEvents.OnGameDataDestroyed += OnGameDataDestroyed;
				}
				if (IsServer)
				{
					_harmonyInstance.PatchAll(typeof(ServerEvents));
					ServerEvents.OnGameDataInitialized += OnGameDataInitialized;
				}
			}
		}

		internal static void Destroy()
		{
			GameData.OnInitialize = null;
			if (IsClient)
			{
				ClientEvents.OnGameDataInitialized -= OnGameDataInitialized;
			}
			if (IsServer)
			{
				ServerEvents.OnGameDataInitialized -= OnGameDataInitialized;
			}
			_harmonyInstance.UnpatchSelf();
			_harmonyInstance = null;
		}

		private static void OnGameDataDestroyed()
		{
			_world = null;
			_worldDataInitialized = false;
			GameData.OnDestroy?.Invoke();
			if (GameData.OnDestroy == null)
			{
				return;
			}
			Delegate[] invocationList = GameData.OnDestroy.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					@delegate.DynamicInvoke();
				}
				catch (Exception ex)
				{
					Logger.LogError((object)ex);
				}
			}
		}

		private static void OnGameDataInitialized(World world)
		{
			_world = world;
			_worldDataInitialized = true;
			if (GameData.OnInitialize == null)
			{
				return;
			}
			Delegate[] invocationList = GameData.OnInitialize.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				try
				{
					@delegate.DynamicInvoke(world);
				}
				catch (Exception ex)
				{
					Logger.LogError((object)ex);
				}
			}
			Logger.LogInfo((object)"GameData initialized");
		}
	}
	public class Items
	{
		private static Items _instance;

		private List<ItemModel> _itemPrefabs;

		private List<ItemModel> _weapons;

		internal static Items Instance => _instance ?? (_instance = new Items());

		public List<ItemModel> Prefabs => _itemPrefabs ?? (_itemPrefabs = GetItemPrefabs());

		public List<ItemModel> Weapons => _weapons ?? (_weapons = Prefabs.Where((ItemModel itemModel) => (int)itemModel.EquipmentType == 2).ToList());

		private Items()
		{
		}

		public ItemModel GetPrefabById(PrefabGUID prefabGuid)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0062: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameDataSystem existingSystem = GameData.World.GetExistingSystem<GameDataSystem>();
				ManagedDataRegistry managedDataRegistry = existingSystem.ManagedDataRegistry;
				ManagedItemData orDefault = managedDataRegistry.GetOrDefault<ManagedItemData>(prefabGuid, (ManagedItemData)null);
				ManualLogSource logger = GameData.Logger;
				bool flag = default(bool);
				BepInExMessageLogInterpolatedStringHandler val = new BepInExMessageLogInterpolatedStringHandler(6, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Name: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<LocalizationKey>(orDefault.Name);
				}
				logger.LogMessage(val);
				PrefabLookupMap prefabLookupMap = ((PrefabCollectionSystem_Base)GameData.Systems.PrefabCollectionSystem).PrefabLookupMap;
				Entity entity = ((PrefabLookupMap)(ref prefabLookupMap))[prefabGuid];
				return FromEntity(entity);
			}
			catch (Exception ex)
			{
				GameData.Logger.LogError((object)ex);
			}
			return null;
		}

		public ItemModel FromEntity(Entity entity)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return new ItemModel(entity);
			}
			catch (Exception ex)
			{
				GameData.Logger.LogError((object)ex);
			}
			return null;
		}

		private List<ItemModel> GetItemPrefabs()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0059: 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_0062: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			List<ItemModel> list = new List<ItemModel>();
			ManualLogSource logger = GameData.Logger;
			bool flag = default(bool);
			BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(14, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("TOTAL PREFABS ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(GameData.Systems.PrefabCollectionSystem._PrefabGuidToEntityMap.Count());
			}
			logger.LogError(val);
			Enumerator<PrefabGUID, Entity> enumerator = GameData.Systems.PrefabCollectionSystem._PrefabGuidToEntityMap.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemModel itemModel = FromEntity(enumerator.Current.Value);
				if (itemModel != null)
				{
					list.Add(itemModel);
				}
			}
			return list;
		}
	}
	public class Npcs
	{
		private static Npcs _instance;

		internal static Npcs Instance => _instance ?? (_instance = new Npcs());

		private Npcs()
		{
		}

		public NpcModel FromEntity(Entity npcEntity)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return new NpcModel(npcEntity);
		}
	}
	public class Systems
	{
		private static Systems _instance;

		internal static Systems Instance => _instance ?? (_instance = new Systems());

		public PrefabCollectionSystem PrefabCollectionSystem => GameData.World.GetExistingSystem<PrefabCollectionSystem>();

		public GameDataSystem GameDataSystem => GameData.World.GetExistingSystem<GameDataSystem>();

		public ManagedDataRegistry ManagedDataRegistry => GameDataSystem.ManagedDataRegistry;

		private Systems()
		{
		}
	}
	public class Users
	{
		private static Users _instance;

		internal static ulong CurrentUserSteamId { get; set; }

		internal static Users Instance => _instance ?? (_instance = new Users());

		public IEnumerable<UserModel> Online => All.Where((UserModel u) => u.IsConnected);

		public IEnumerable<UserModel> All
		{
			get
			{
				EntityManager entityManager = GameData.World.EntityManager;
				EntityQuery val = ((EntityManager)(ref entityManager)).CreateEntityQuery((ComponentType[])(object)new ComponentType[1] { ComponentType.ReadOnly<User>() });
				Enumerator<Entity> enumerator = ((EntityQuery)(ref val)).ToEntityArray((Allocator)2).GetEnumerator();
				while (enumerator.MoveNext())
				{
					Entity userEntity = enumerator.Current;
					yield return FromEntity(userEntity);
				}
			}
		}

		private Users()
		{
		}

		public UserModel GetCurrentUser()
		{
			return GetUserByPlatformId(CurrentUserSteamId);
		}

		public UserModel GetUserByPlatformId(ulong platformId)
		{
			return All.FirstOrDefault((UserModel u) => u.PlatformId == platformId);
		}

		public UserModel GetUserByCharacterName(string characterName)
		{
			return All.FirstOrDefault((UserModel u) => u.CharacterName == characterName);
		}

		public UserModel FromEntity(Entity userEntity)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			EntityManager entityManager = GameData.World.EntityManager;
			if (!((EntityManager)(ref entityManager)).HasComponent<User>(userEntity))
			{
				throw new Exception("Given entity does not have User component.");
			}
			return new UserModel(userEntity);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "VRising.GameData";

		public const string PLUGIN_NAME = "VRising.GameData";

		public const string PLUGIN_VERSION = "0.3.3";
	}
}
namespace VRising.GameData.Utils
{
	public static class ExtensionMethods
	{
		public static string GetPrefabName(this PrefabGUID prefabGuid)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ((PrefabCollectionSystem_Base)GameData.Systems.PrefabCollectionSystem).PrefabGuidToNameDictionary[prefabGuid].ToString();
			}
			catch
			{
				return null;
			}
		}

		public static IEnumerable<BaseEntityModel> ToEnumerable(this EntityQuery entityQuery)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<Entity> enumerator = ((EntityQuery)(ref entityQuery)).ToEntityArray((Allocator)2).GetEnumerator();
			while (enumerator.MoveNext())
			{
				yield return new BaseEntityModel(entity: enumerator.Current, world: GameData.World);
			}
		}

		public static IEnumerable<NpcModel> AsNpcs(this EntityQuery entityQuery)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<Entity> enumerator = ((EntityQuery)(ref entityQuery)).ToEntityArray((Allocator)2).GetEnumerator();
			while (enumerator.MoveNext())
			{
				Entity entity = enumerator.Current;
				yield return new NpcModel(entity);
			}
		}

		public static DateTime ToDateTime(this long unixDateTime)
		{
			return new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(unixDateTime);
		}

		public static double Distance(this float3 pos1, float3 pos2)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			return Math.Sqrt(Math.Pow(pos1.x - pos2.x, 2.0) + Math.Pow(pos1.z - pos2.z, 2.0));
		}
	}
	internal struct FakeNull
	{
		public int value;

		public bool has_value;
	}
	internal class Logger
	{
		private readonly ManualLogSource _logger;

		internal Logger(ManualLogSource logger)
		{
			_logger = logger;
		}

		internal void Log(LogLevel logLevel, string message)
		{
		}

		internal void LogInfo(string message)
		{
			Log((LogLevel)16, message);
		}

		internal void LogWarning(string message)
		{
			Log((LogLevel)4, message);
		}

		internal void LogDebug(string message)
		{
			Log((LogLevel)32, message);
		}

		internal void LogFatal(string message)
		{
			Log((LogLevel)1, message);
		}

		internal void LogError(string message)
		{
			Log((LogLevel)2, message);
		}

		internal void LogError(Exception exception)
		{
			Log((LogLevel)2, exception.ToString());
		}

		internal void LogMessage(string message)
		{
			Log((LogLevel)8, message);
		}
	}
}
namespace VRising.GameData.Patch
{
	internal class ClientEvents
	{
		private static bool _onGameDataInitializedTriggered;

		internal static event OnGameDataInitializedEventHandler OnGameDataInitialized;

		internal static event OnGameDataDestroyedEventHandler OnGameDataDestroyed;

		[HarmonyPatch(typeof(GameDataManager), "OnUpdate")]
		[HarmonyPostfix]
		private static void GameDataManagerOnUpdatePostfix(GameDataManager __instance)
		{
			if (_onGameDataInitializedTriggered)
			{
				return;
			}
			try
			{
				if (__instance.GameDataInitialized)
				{
					_onGameDataInitializedTriggered = true;
					Debug.WriteLine("GameDataManagerOnUpdatePostfix Trigger");
					ClientEvents.OnGameDataInitialized?.Invoke(((ComponentSystemBase)__instance).World);
				}
			}
			catch (Exception ex)
			{
				GameData.Logger.LogError((object)ex);
			}
		}

		[HarmonyPatch(typeof(ClientBootstrapSystem), "OnDestroy")]
		[HarmonyPostfix]
		private static void ClientBootstrapSystemOnDestroyPostfix(ClientBootstrapSystem __instance)
		{
			_onGameDataInitializedTriggered = false;
			try
			{
				ClientEvents.OnGameDataDestroyed?.Invoke();
			}
			catch (Exception ex)
			{
				GameData.Logger.LogError((object)ex);
			}
		}

		[HarmonyPatch(typeof(SteamPlatformSystem), "TryInitClient")]
		[HarmonyPostfix]
		private static void SteamPlatformSystemOnTryInitClientPostfix(SteamPlatformSystem __instance)
		{
			try
			{
				Users.CurrentUserSteamId = __instance.UserID;
			}
			catch (Exception ex)
			{
				GameData.Logger.LogError((object)ex);
			}
		}
	}
	internal static class ServerEvents
	{
		internal static event OnGameDataInitializedEventHandler OnGameDataInitialized;

		[HarmonyPatch(typeof(LoadPersistenceSystemV2), "SetLoadState")]
		[HarmonyPostfix]
		private static void ServerStartupStateChange_Postfix(State loadState, LoadPersistenceSystemV2 __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			try
			{
				if ((int)loadState == 4)
				{
					ServerEvents.OnGameDataInitialized?.Invoke(((ComponentSystemBase)__instance).World);
				}
			}
			catch (Exception ex)
			{
				GameData.Logger.LogError((object)ex);
			}
		}
	}
}
namespace VRising.GameData.Models
{
	public class CharacterModel
	{
		public Entity Entity { get; }

		public BaseEntityModel Internals { get; }

		public EquipmentModel Equipment => Internals.Equipment.HasValue ? new EquipmentModel(Internals.Equipment.Value) : null;

		internal CharacterModel(Entity entity)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Entity = entity;
			Internals = new BaseEntityModel(GameData.World, entity);
		}
	}
	public class EquipmentModel
	{
		public Equipment Internals { get; }

		public ItemModel Chest => (Internals.ArmorChestSlotEntity._Entity != Entity.Null) ? new ItemModel(Internals.ArmorChestSlotEntity._Entity) : null;

		public ItemModel Leg => (Internals.ArmorLegsSlotEntity._Entity != Entity.Null) ? new ItemModel(Internals.ArmorLegsSlotEntity._Entity) : null;

		public ItemModel Headgear => (Internals.ArmorHeadgearSlotEntity._Entity != Entity.Null) ? new ItemModel(Internals.ArmorHeadgearSlotEntity._Entity) : null;

		public ItemModel Footgear => (Internals.ArmorFootgearSlotEntity._Entity != Entity.Null) ? new ItemModel(Internals.ArmorFootgearSlotEntity._Entity) : null;

		public ItemModel Gloves => (Internals.ArmorGlovesSlotEntity._Entity != Entity.Null) ? new ItemModel(Internals.ArmorGlovesSlotEntity._Entity) : null;

		public ItemModel Cloak => (Internals.CloakSlotEntity._Entity != Entity.Null) ? new ItemModel(Internals.CloakSlotEntity._Entity) : null;

		public ItemModel Weapon => (Internals.WeaponSlotEntity._Entity != Entity.Null) ? new ItemModel(Internals.WeaponSlotEntity._Entity) : null;

		public ItemModel Jewelry => (Internals.GrimoireSlotEntity._Entity != Entity.Null) ? new ItemModel(Internals.GrimoireSlotEntity._Entity) : null;

		public float ArmorLevel
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Equipment internals = Internals;
				return ((ModifiableFloat)(ref internals.ArmorLevel)).Value;
			}
		}

		public float WeaponLevel
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Equipment internals = Internals;
				return ((ModifiableFloat)(ref internals.WeaponLevel)).Value;
			}
		}

		public float SpellLevel
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Equipment internals = Internals;
				return ((ModifiableFloat)(ref internals.SpellLevel)).Value;
			}
		}

		public float Level => ArmorLevel + WeaponLevel + SpellLevel;

		public EquipmentModel(Equipment equipment)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Internals = equipment;
		}
	}
	public class InventoryModel
	{
		private readonly CharacterModel _characterModel;

		public List<InventoryItemData> Items => GetInventoryItems();

		internal InventoryModel(CharacterModel characterModel)
		{
			_characterModel = characterModel;
		}

		private List<InventoryItemData> GetInventoryItems()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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)
			Entity entity = default(Entity);
			InventoryUtilities.TryGetInventoryEntity(GameData.World.EntityManager, _characterModel.Entity, ref entity, 0);
			BaseEntityModel baseEntityModel = new BaseEntityModel(GameData.World, entity);
			List<InventoryBuffer> inventoryBuffers = baseEntityModel.InventoryBuffers;
			if (inventoryBuffers == null)
			{
				return new List<InventoryItemData>();
			}
			return inventoryBuffers.Select(delegate(InventoryBuffer i, int index)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//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_0020: Unknown result type (might be due to invalid IL or missing references)
				//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)
				//IL_0032: 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_0046: Unknown result type (might be due to invalid IL or missing references)
				Entity val;
				if (i.ItemType.GuidHash != 0)
				{
					PrefabLookupMap prefabLookupMap = ((PrefabCollectionSystem_Base)GameData.Systems.PrefabCollectionSystem).PrefabLookupMap;
					val = ((PrefabLookupMap)(ref prefabLookupMap))[i.ItemType];
				}
				else
				{
					val = Entity.Null;
				}
				Entity entity2 = val;
				return new InventoryItemData
				{
					Item = new ItemModel(entity2),
					Stacks = i.Amount,
					Slot = index
				};
			}).ToList();
		}
	}
	public class ItemModel : EntityModel
	{
		public BaseManagedDataModel ManagedGameData { get; }

		public string PrefabName { get; }

		public string Name
		{
			get
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				BaseManagedDataModel managedGameData = ManagedGameData;
				object result;
				if (managedGameData == null)
				{
					result = null;
				}
				else
				{
					ManagedItemData managedItemData = managedGameData.ManagedItemData;
					if (managedItemData == null)
					{
						result = null;
					}
					else
					{
						LocalizationKey name = managedItemData.Name;
						result = ((object)(LocalizationKey)(ref name)).ToString();
					}
				}
				return (string)result;
			}
		}

		public ItemCategory ItemCategory
		{
			get
			{
				//IL_001b: 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)
				ItemData? itemData = base.Internals.ItemData;
				return (ItemCategory)((!itemData.HasValue) ? 0 : ((long)itemData.GetValueOrDefault().ItemCategory));
			}
		}

		public ItemType ItemType
		{
			get
			{
				//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)
				ItemData? itemData = base.Internals.ItemData;
				return (ItemType)(itemData.HasValue ? ((int)itemData.GetValueOrDefault().ItemType) : 0);
			}
		}

		public EquipmentType EquipmentType
		{
			get
			{
				//IL_001b: 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)
				EquippableData? equippableData = base.Internals.EquippableData;
				return (EquipmentType)((!equippableData.HasValue) ? 10 : ((int)equippableData.GetValueOrDefault().EquipmentType));
			}
		}

		internal ItemModel(Entity entity)
			: base(entity)
		{
			//IL_0001: 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)
			PrefabName = base.Internals.PrefabGUID?.GetPrefabName();
			ManagedGameData = new BaseManagedDataModel(GameData.World, base.Internals);
		}
	}
	public class NpcModel : EntityModel
	{
		private readonly HashSet<UnitCategory> _npcCategories = new HashSet<UnitCategory>
		{
			(UnitCategory)4,
			(UnitCategory)2,
			(UnitCategory)0,
			(UnitCategory)1,
			(UnitCategory)3
		};

		public new PrefabGUID PrefabGUID => base.Internals.PrefabGUID.GetValueOrDefault();

		public bool IsDead => base.Internals.Dead.HasValue;

		public float LifeTime => base.Internals.LifeTime?.Duration ?? 0f;

		public float3 Position
		{
			get
			{
				//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_0019: 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)
				LocalToWorld? localToWorld = base.Internals.LocalToWorld;
				? result;
				if (!localToWorld.HasValue)
				{
					result = default(float3);
				}
				else
				{
					LocalToWorld valueOrDefault = localToWorld.GetValueOrDefault();
					result = ((LocalToWorld)(ref valueOrDefault)).Position;
				}
				return (float3)result;
			}
		}

		public bool HasDropTable => base.Internals.DropTable;

		internal NpcModel(Entity entity)
			: base(entity)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			EntityCategory? entityCategory = base.Internals.EntityCategory;
			if (!entityCategory.HasValue || (int)entityCategory.Value.MainCategory != 0 || !_npcCategories.Contains(entityCategory.Value.UnitCategory))
			{
				throw new Exception("Given entity is not a NPC.");
			}
		}
	}
	public class UserModel : EntityModel
	{
		public InventoryModel Inventory { get; }

		public CharacterModel Character { get; }

		public string CharacterName
		{
			get
			{
				//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)
				User? user = base.Internals.User;
				object result;
				if (!user.HasValue)
				{
					result = null;
				}
				else
				{
					User valueOrDefault = user.GetValueOrDefault();
					result = ((object)(FixedString64)(ref valueOrDefault.CharacterName)).ToString();
				}
				return (string)result;
			}
		}

		public EquipmentModel Equipment => Character.Equipment;

		public FromCharacter FromCharacter
		{
			get
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: 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)
				FromCharacter result = default(FromCharacter);
				result.User = base.Entity;
				result.Character = Character.Entity;
				return result;
			}
		}

		public bool IsAdmin => base.Internals.User?.IsAdmin ?? false;

		public bool IsConnected => base.Internals.User?.IsConnected ?? false;

		public ulong PlatformId => base.Internals.User?.PlatformId ?? 0;

		public float3 Position
		{
			get
			{
				//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_0019: 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)
				LocalToWorld? localToWorld = base.Internals.LocalToWorld;
				? result;
				if (!localToWorld.HasValue)
				{
					result = default(float3);
				}
				else
				{
					LocalToWorld valueOrDefault = localToWorld.GetValueOrDefault();
					result = ((LocalToWorld)(ref valueOrDefault)).Position;
				}
				return (float3)result;
			}
		}

		public UserContentFlags UserContent
		{
			get
			{
				//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)
				User? user = base.Internals.User;
				return (UserContentFlags)(user.HasValue ? ((int)user.GetValueOrDefault().UserContent) : 0);
			}
		}

		internal UserModel(Entity entity)
			: base(entity)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Character = new CharacterModel((base.Internals.User?.LocalCharacter._Entity).Value);
			Inventory = new InventoryModel(Character);
		}
	}
}
namespace VRising.GameData.Models.Internals
{
	public class BaseEntityModel
	{
		private readonly World _world;

		public readonly Entity _entity;

		public SceneReference? SceneReference
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				SceneReference value;
				return _world.EntityManager.TryGetComponentDataInternal<SceneReference>(_entity, out value) ? new SceneReference?(value) : null;
			}
		}

		public RequestSceneLoaded? RequestSceneLoaded
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				RequestSceneLoaded value;
				return _world.EntityManager.TryGetComponentDataInternal<RequestSceneLoaded>(_entity, out value) ? new RequestSceneLoaded?(value) : null;
			}
		}

		public ResolvedSceneHash? ResolvedSceneHash
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				ResolvedSceneHash value;
				return _world.EntityManager.TryGetComponentDataInternal<ResolvedSceneHash>(_entity, out value) ? new ResolvedSceneHash?(value) : null;
			}
		}

		public List<LinkedEntityGroup> LinkedEntityGroups => _world.EntityManager.GetBufferInternal<LinkedEntityGroup>(_entity);

		public List<ResolvedSectionEntity> ResolvedSectionEntities => _world.EntityManager.GetBufferInternal<ResolvedSectionEntity>(_entity);

		public PostLoadCommandBuffer PostLoadCommandBuffer
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				PostLoadCommandBuffer value;
				return _world.EntityManager.TryGetComponentDataInternal<PostLoadCommandBuffer>(_entity, out value) ? value : null;
			}
		}

		public ServerRuntimeSettings ServerRuntimeSettings
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				//IL_001c: 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)
				ServerRuntimeSettings value;
				return (ServerRuntimeSettings)(_world.EntityManager.TryGetComponentDataInternal<ServerRuntimeSettings>(_entity, out value) ? value : default(ServerRuntimeSettings));
			}
		}

		public bool Prefab => _world.EntityManager.HasComponentInternal<Prefab>(_entity);

		public NetworkedSettings? NetworkedSettings
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				NetworkedSettings value;
				return _world.EntityManager.TryGetComponentDataInternal<NetworkedSettings>(_entity, out value) ? new NetworkedSettings?(value) : null;
			}
		}

		public FrameChanged? FrameChanged
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				FrameChanged value;
				return _world.EntityManager.TryGetComponentDataInternal<FrameChanged>(_entity, out value) ? new FrameChanged?(value) : null;
			}
		}

		public NetworkSnapshot? NetworkSnapshot
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				NetworkSnapshot value;
				return _world.EntityManager.TryGetComponentDataInternal<NetworkSnapshot>(_entity, out value) ? new NetworkSnapshot?(value) : null;
			}
		}

		public DestroyedEntity? DestroyedEntity
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				DestroyedEntity value;
				return _world.EntityManager.TryGetComponentDataInternal<DestroyedEntity>(_entity, out value) ? new DestroyedEntity?(value) : null;
			}
		}

		public List<NetSnapshot> NetSnapshots => _world.EntityManager.GetBufferInternal<NetSnapshot>(_entity);

		public List<SnapshotFrameChangedBuffer> SnapshotFrameChangedBuffers => _world.EntityManager.GetBufferInternal<SnapshotFrameChangedBuffer>(_entity);

		public List<Snapshot_InventoryBuffer> Snapshot_InventoryBuffer => _world.EntityManager.GetBufferInternal<Snapshot_InventoryBuffer>(_entity);

		public List<Snapshot_PerksBuffer> Snapshot_PerksBuffer => _world.EntityManager.GetBufferInternal<Snapshot_PerksBuffer>(_entity);

		public bool NewDestroyedEntity => _world.EntityManager.HasComponentInternal<NewDestroyedEntity>(_entity);

		public WorldTypeSingleton? WorldTypeSingleton
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				WorldTypeSingleton value;
				return _world.EntityManager.TryGetComponentDataInternal<WorldTypeSingleton>(_entity, out value) ? new WorldTypeSingleton?(value) : null;
			}
		}

		public WorldFrame? WorldFrame
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				WorldFrame value;
				return _world.EntityManager.TryGetComponentDataInternal<WorldFrame>(_entity, out value) ? new WorldFrame?(value) : null;
			}
		}

		public TerrainChunkLoadedEvent? TerrainChunkLoadedEvent
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				TerrainChunkLoadedEvent value;
				return _world.EntityManager.TryGetComponentDataInternal<TerrainChunkLoadedEvent>(_entity, out value) ? new TerrainChunkLoadedEvent?(value) : null;
			}
		}

		public List<PublicEntityRef> PublicEntityRefs => _world.EntityManager.GetBufferInternal<PublicEntityRef>(_entity);

		public TerrainChunkMetadataLoadedEvent? TerrainChunkMetadataLoadedEvent
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				TerrainChunkMetadataLoadedEvent value;
				return _world.EntityManager.TryGetComponentDataInternal<TerrainChunkMetadataLoadedEvent>(_entity, out value) ? new TerrainChunkMetadataLoadedEvent?(value) : null;
			}
		}

		public LoadToTargetWorld? LoadToTargetWorld
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				LoadToTargetWorld value;
				return _world.EntityManager.TryGetComponentDataInternal<LoadToTargetWorld>(_entity, out value) ? new LoadToTargetWorld?(value) : null;
			}
		}

		public ServerGameBalanceSettings ServerGameBalanceSettings
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				//IL_001c: 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)
				ServerGameBalanceSettings value;
				return (ServerGameBalanceSettings)(_world.EntityManager.TryGetComponentDataInternal<ServerGameBalanceSettings>(_entity, out value) ? value : default(ServerGameBalanceSettings));
			}
		}

		public ToggleDisabledEvent? ToggleDisabledEvent
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				ToggleDisabledEvent value;
				return _world.EntityManager.TryGetComponentDataInternal<ToggleDisabledEvent>(_entity, out value) ? new ToggleDisabledEvent?(value) : null;
			}
		}

		public List<Snapshot_CastleBuildingAttachedChildrenBuffer> Snapshot_CastleBuildingAttachedChildrenBuffer => _world.EntityManager.GetBufferInternal<Snapshot_CastleBuildingAttachedChildrenBuffer>(_entity);

		public List<Snapshot_CastleBuildingAttachToParentsBuffer> Snapshot_CastleBuildingAttachToParentsBuffer => _world.EntityManager.GetBufferInternal<Snapshot_CastleBuildingAttachToParentsBuffer>(_entity);

		public List<Snapshot_RefinementstationRecipesBuffer> Snapshot_RefinementstationRecipesBuffer => _world.EntityManager.GetBufferInternal<Snapshot_RefinementstationRecipesBuffer>(_entity);

		public List<Snapshot_ActiveServantMission> Snapshot_ActiveServantMission => _world.EntityManager.GetBufferInternal<Snapshot_ActiveServantMission>(_entity);

		public LocalToWorld? LocalToWorld
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				LocalToWorld value;
				return _world.EntityManager.TryGetComponentDataInternal<LocalToWorld>(_entity, out value) ? new LocalToWorld?(value) : null;
			}
		}

		public TileBounds? TileBounds
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				TileBounds value;
				return _world.EntityManager.TryGetComponentDataInternal<TileBounds>(_entity, out value) ? new TileBounds?(value) : null;
			}
		}

		public TilePosition? TilePosition
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				TilePosition value;
				return _world.EntityManager.TryGetComponentDataInternal<TilePosition>(_entity, out value) ? new TilePosition?(value) : null;
			}
		}

		public TileModelSpatialData? TileModelSpatialData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				TileModelSpatialData value;
				return _world.EntityManager.TryGetComponentDataInternal<TileModelSpatialData>(_entity, out value) ? new TileModelSpatialData?(value) : null;
			}
		}

		public TileData TileData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				//IL_001c: 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)
				TileData value;
				return (TileData)(_world.EntityManager.TryGetComponentDataInternal<TileData>(_entity, out value) ? value : default(TileData));
			}
		}

		public MapZoneData? MapZoneData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				MapZoneData value;
				return _world.EntityManager.TryGetComponentDataInternal<MapZoneData>(_entity, out value) ? new MapZoneData?(value) : null;
			}
		}

		public TileModel? TileModel
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				TileModel value;
				return _world.EntityManager.TryGetComponentDataInternal<TileModel>(_entity, out value) ? new TileModel?(value) : null;
			}
		}

		public List<MapZonePolygonVertexElement> MapZonePolygonVertexElements => _world.EntityManager.GetBufferInternal<MapZonePolygonVertexElement>(_entity);

		public List<MapZoneDiscoverableElement> MapZoneDiscoverableElements => _world.EntityManager.GetBufferInternal<MapZoneDiscoverableElement>(_entity);

		public bool TileRestrictionAreaTag => _world.EntityManager.HasComponentInternal<TileRestrictionAreaTag>(_entity);

		public bool TileModelRegistrationState => _world.EntityManager.HasComponentInternal<TileModelRegistrationState>(_entity);

		public RetainBlobAssets RetainBlobAssets
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				//IL_001c: 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)
				RetainBlobAssets value;
				return (RetainBlobAssets)(_world.EntityManager.TryGetComponentDataInternal<RetainBlobAssets>(_entity, out value) ? value : default(RetainBlobAssets));
			}
		}

		public RetainBlobAssetBatchPtr? RetainBlobAssetBatchPtr
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				RetainBlobAssetBatchPtr value;
				return _world.EntityManager.TryGetComponentDataInternal<RetainBlobAssetBatchPtr>(_entity, out value) ? new RetainBlobAssetBatchPtr?(value) : null;
			}
		}

		public bool BlobAssetOwner => _world.EntityManager.HasComponentInternal<BlobAssetOwner>(_entity);

		public List<WorldAssetChunks> WorldAssetChunks => _world.EntityManager.GetBufferInternal<WorldAssetChunks>(_entity);

		public bool WorldAssetSingleton => _world.EntityManager.HasComponentInternal<WorldAssetSingleton>(_entity);

		public bool WorldConfigSingleton => _world.EntityManager.HasComponentInternal<WorldConfigSingleton>(_entity);

		public List<RelicDropped> RelicDroppeds => _world.EntityManager.GetBufferInternal<RelicDropped>(_entity);

		public KnockbackAssetsSingleton? KnockbackAssetsSingleton
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				KnockbackAssetsSingleton value;
				return _world.EntityManager.TryGetComponentDataInternal<KnockbackAssetsSingleton>(_entity, out value) ? new KnockbackAssetsSingleton?(value) : null;
			}
		}

		public List<Snapshot_SpawnedUnitsBuffer> Snapshot_SpawnedUnitsBuffer => _world.EntityManager.GetBufferInternal<Snapshot_SpawnedUnitsBuffer>(_entity);

		public SceneEntityReference? SceneEntityReference
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				SceneEntityReference value;
				return _world.EntityManager.TryGetComponentDataInternal<SceneEntityReference>(_entity, out value) ? new SceneEntityReference?(value) : null;
			}
		}

		public SceneSectionData? SceneSectionData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				SceneSectionData value;
				return _world.EntityManager.TryGetComponentDataInternal<SceneSectionData>(_entity, out value) ? new SceneSectionData?(value) : null;
			}
		}

		public ResolvedSectionPath? ResolvedSectionPath
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				ResolvedSectionPath value;
				return _world.EntityManager.TryGetComponentDataInternal<ResolvedSectionPath>(_entity, out value) ? new ResolvedSectionPath?(value) : null;
			}
		}

		public SceneBoundingVolume? SceneBoundingVolume
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				SceneBoundingVolume value;
				return _world.EntityManager.TryGetComponentDataInternal<SceneBoundingVolume>(_entity, out value) ? new SceneBoundingVolume?(value) : null;
			}
		}

		public PhysicsCollider PhysicsCollider
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				//IL_001c: 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)
				PhysicsCollider value;
				return (PhysicsCollider)(_world.EntityManager.TryGetComponentDataInternal<PhysicsCollider>(_entity, out value) ? value : default(PhysicsCollider));
			}
		}

		public StaticPhysicsWorldBodyIndex? StaticPhysicsWorldBodyIndex
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				StaticPhysicsWorldBodyIndex value;
				return _world.EntityManager.TryGetComponentDataInternal<StaticPhysicsWorldBodyIndex>(_entity, out value) ? new StaticPhysicsWorldBodyIndex?(value) : null;
			}
		}

		public ModifyMovementDuringCastActive? ModifyMovementDuringCastActive
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				ModifyMovementDuringCastActive value;
				return _world.EntityManager.TryGetComponentDataInternal<ModifyMovementDuringCastActive>(_entity, out value) ? new ModifyMovementDuringCastActive?(value) : null;
			}
		}

		public DestroyData? DestroyData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				DestroyData value;
				return _world.EntityManager.TryGetComponentDataInternal<DestroyData>(_entity, out value) ? new DestroyData?(value) : null;
			}
		}

		public DestroyState? DestroyState
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				DestroyState value;
				return _world.EntityManager.TryGetComponentDataInternal<DestroyState>(_entity, out value) ? new DestroyState?(value) : null;
			}
		}

		public MoveDuringCastActive? MoveDuringCastActive
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				MoveDuringCastActive value;
				return _world.EntityManager.TryGetComponentDataInternal<MoveDuringCastActive>(_entity, out value) ? new MoveDuringCastActive?(value) : null;
			}
		}

		public List<Snapshot_QueuedWorkstationCraftAction> Snapshot_QueuedWorkstationCraftAction => _world.EntityManager.GetBufferInternal<Snapshot_QueuedWorkstationCraftAction>(_entity);

		public RotateTowardsAimDirectionDuringCastActive? RotateTowardsAimDirectionDuringCastActive
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				RotateTowardsAimDirectionDuringCastActive value;
				return _world.EntityManager.TryGetComponentDataInternal<RotateTowardsAimDirectionDuringCastActive>(_entity, out value) ? new RotateTowardsAimDirectionDuringCastActive?(value) : null;
			}
		}

		public List<Snapshot_ResearchBuffer> Snapshot_ResearchBuffer => _world.EntityManager.GetBufferInternal<Snapshot_ResearchBuffer>(_entity);

		public AbilityCastStartedEvent? AbilityCastStartedEvent
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				AbilityCastStartedEvent value;
				return _world.EntityManager.TryGetComponentDataInternal<AbilityCastStartedEvent>(_entity, out value) ? new AbilityCastStartedEvent?(value) : null;
			}
		}

		public List<Snapshot_AllyPermission> Snapshot_AllyPermission => _world.EntityManager.GetBufferInternal<Snapshot_AllyPermission>(_entity);

		public List<Snapshot_RespawnPointOwnerBuffer> Snapshot_RespawnPointOwnerBuffer => _world.EntityManager.GetBufferInternal<Snapshot_RespawnPointOwnerBuffer>(_entity);

		public List<Snapshot_UnlockedWaypointElement> Snapshot_UnlockedWaypointElement => _world.EntityManager.GetBufferInternal<Snapshot_UnlockedWaypointElement>(_entity);

		public List<Snapshot_UserMapZoneElement> Snapshot_UserMapZoneElement => _world.EntityManager.GetBufferInternal<Snapshot_UserMapZoneElement>(_entity);

		public AbilityPostCastFinishedEvent? AbilityPostCastFinishedEvent
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				AbilityPostCastFinishedEvent value;
				return _world.EntityManager.TryGetComponentDataInternal<AbilityPostCastFinishedEvent>(_entity, out value) ? new AbilityPostCastFinishedEvent?(value) : null;
			}
		}

		public List<Snapshot_FollowerBuffer> Snapshot_FollowerBuffer => _world.EntityManager.GetBufferInternal<Snapshot_FollowerBuffer>(_entity);

		public AbilityCastEndedEvent? AbilityCastEndedEvent
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				AbilityCastEndedEvent value;
				return _world.EntityManager.TryGetComponentDataInternal<AbilityCastEndedEvent>(_entity, out value) ? new AbilityCastEndedEvent?(value) : null;
			}
		}

		public AbilityPostCastEndedEvent? AbilityPostCastEndedEvent
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				AbilityPostCastEndedEvent value;
				return _world.EntityManager.TryGetComponentDataInternal<AbilityPostCastEndedEvent>(_entity, out value) ? new AbilityPostCastEndedEvent?(value) : null;
			}
		}

		public List<Snapshot_AbilityStateBuffer> Snapshot_AbilityStateBuffer => _world.EntityManager.GetBufferInternal<Snapshot_AbilityStateBuffer>(_entity);

		public AbilityInterruptedEvent? AbilityInterruptedEvent
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				AbilityInterruptedEvent value;
				return _world.EntityManager.TryGetComponentDataInternal<AbilityInterruptedEvent>(_entity, out value) ? new AbilityInterruptedEvent?(value) : null;
			}
		}

		public TeleportationRequest? TeleportationRequest
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				TeleportationRequest value;
				return _world.EntityManager.TryGetComponentDataInternal<TeleportationRequest>(_entity, out value) ? new TeleportationRequest?(value) : null;
			}
		}

		public List<Snapshot_Restricted_InventoryBuffer> Snapshot_Restricted_InventoryBuffer => _world.EntityManager.GetBufferInternal<Snapshot_Restricted_InventoryBuffer>(_entity);

		public List<Snapshot_AchievementInProgressElement> Snapshot_AchievementInProgressElement => _world.EntityManager.GetBufferInternal<Snapshot_AchievementInProgressElement>(_entity);

		public PhysicsStep? PhysicsStep
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				PhysicsStep value;
				return _world.EntityManager.TryGetComponentDataInternal<PhysicsStep>(_entity, out value) ? new PhysicsStep?(value) : null;
			}
		}

		public WorldTime? WorldTime
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				WorldTime value;
				return _world.EntityManager.TryGetComponentDataInternal<WorldTime>(_entity, out value) ? new WorldTime?(value) : null;
			}
		}

		public List<WorldTimeQueue> WorldTimeQueues => _world.EntityManager.GetBufferInternal<WorldTimeQueue>(_entity);

		public Sun? Sun
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Sun value;
				return _world.EntityManager.TryGetComponentDataInternal<Sun>(_entity, out value) ? new Sun?(value) : null;
			}
		}

		public CloudCookieLight CloudCookieLight
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				CloudCookieLight value;
				return _world.EntityManager.TryGetComponentDataInternal<CloudCookieLight>(_entity, out value) ? value : null;
			}
		}

		public List<Snapshot_ProgressionBookBlueprintElement> Snapshot_ProgressionBookBlueprintElement => _world.EntityManager.GetBufferInternal<Snapshot_ProgressionBookBlueprintElement>(_entity);

		public List<Snapshot_ProgressionBookRecipeElement> Snapshot_ProgressionBookRecipeElement => _world.EntityManager.GetBufferInternal<Snapshot_ProgressionBookRecipeElement>(_entity);

		public List<Snapshot_ProgressionBookShapeshiftElement> Snapshot_ProgressionBookShapeshiftElement => _world.EntityManager.GetBufferInternal<Snapshot_ProgressionBookShapeshiftElement>(_entity);

		public List<Snapshot_ProgressionBookTechElement> Snapshot_ProgressionBookTechElement => _world.EntityManager.GetBufferInternal<Snapshot_ProgressionBookTechElement>(_entity);

		public List<Snapshot_BloodHuntBuffer> Snapshot_BloodHuntBuffer => _world.EntityManager.GetBufferInternal<Snapshot_BloodHuntBuffer>(_entity);

		public Rotation? Rotation
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Rotation value;
				return _world.EntityManager.TryGetComponentDataInternal<Rotation>(_entity, out value) ? new Rotation?(value) : null;
			}
		}

		public Translation? Translation
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Translation value;
				return _world.EntityManager.TryGetComponentDataInternal<Translation>(_entity, out value) ? new Translation?(value) : null;
			}
		}

		public PrefabGUID? PrefabGUID
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				PrefabGUID value;
				return _world.EntityManager.TryGetComponentDataInternal<PrefabGUID>(_entity, out value) ? new PrefabGUID?(value) : null;
			}
		}

		public AiPointOfInterest? AiPointOfInterest
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				AiPointOfInterest value;
				return _world.EntityManager.TryGetComponentDataInternal<AiPointOfInterest>(_entity, out value) ? new AiPointOfInterest?(value) : null;
			}
		}

		public AutoChainInstanceData? AutoChainInstanceData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				AutoChainInstanceData value;
				return _world.EntityManager.TryGetComponentDataInternal<AutoChainInstanceData>(_entity, out value) ? new AutoChainInstanceData?(value) : null;
			}
		}

		public bool SpawnTag => _world.EntityManager.HasComponentInternal<SpawnTag>(_entity);

		public bool PrefabCollectionPrefabTag => _world.EntityManager.HasComponentInternal<PrefabCollectionPrefabTag>(_entity);

		public bool UsesSpawnTag => _world.EntityManager.HasComponentInternal<UsesSpawnTag>(_entity);

		public bool DisableWhenNoPlayersInRange => _world.EntityManager.HasComponentInternal<DisableWhenNoPlayersInRange>(_entity);

		public List<EntityNameCollectionBuffer> EntityNameCollectionBuffers => _world.EntityManager.GetBufferInternal<EntityNameCollectionBuffer>(_entity);

		public List<PrefabCollectionBuffer> PrefabCollectionBuffers => _world.EntityManager.GetBufferInternal<PrefabCollectionBuffer>(_entity);

		public bool PrefabCollectionTag => _world.EntityManager.HasComponentInternal<PrefabCollectionTag>(_entity);

		public bool GameDataSubSceneTag => _world.EntityManager.HasComponentInternal<GameDataSubSceneTag>(_entity);

		public RandomizedSpawnChain? RandomizedSpawnChain
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				RandomizedSpawnChain value;
				return _world.EntityManager.TryGetComponentDataInternal<RandomizedSpawnChain>(_entity, out value) ? new RandomizedSpawnChain?(value) : null;
			}
		}

		public StaticTransformIndex? StaticTransformIndex
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				StaticTransformIndex value;
				return _world.EntityManager.TryGetComponentDataInternal<StaticTransformIndex>(_entity, out value) ? new StaticTransformIndex?(value) : null;
			}
		}

		public BlueprintData? BlueprintData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				BlueprintData value;
				return _world.EntityManager.TryGetComponentDataInternal<BlueprintData>(_entity, out value) ? new BlueprintData?(value) : null;
			}
		}

		public Team? Team
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Team value;
				return _world.EntityManager.TryGetComponentDataInternal<Team>(_entity, out value) ? new Team?(value) : null;
			}
		}

		public EditableTileModel? EditableTileModel
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				EditableTileModel value;
				return _world.EntityManager.TryGetComponentDataInternal<EditableTileModel>(_entity, out value) ? new EditableTileModel?(value) : null;
			}
		}

		public CastleHeartConnection? CastleHeartConnection
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleHeartConnection value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleHeartConnection>(_entity, out value) ? new CastleHeartConnection?(value) : null;
			}
		}

		public DismantleDestroyData? DismantleDestroyData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				DismantleDestroyData value;
				return _world.EntityManager.TryGetComponentDataInternal<DismantleDestroyData>(_entity, out value) ? new DismantleDestroyData?(value) : null;
			}
		}

		public JoinDefaultTeamOnSpawn? JoinDefaultTeamOnSpawn
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				JoinDefaultTeamOnSpawn value;
				return _world.EntityManager.TryGetComponentDataInternal<JoinDefaultTeamOnSpawn>(_entity, out value) ? new JoinDefaultTeamOnSpawn?(value) : null;
			}
		}

		public UpToDateUserBitMask? UpToDateUserBitMask
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				UpToDateUserBitMask value;
				return _world.EntityManager.TryGetComponentDataInternal<UpToDateUserBitMask>(_entity, out value) ? new UpToDateUserBitMask?(value) : null;
			}
		}

		public NetworkId? NetworkId
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				NetworkId value;
				return _world.EntityManager.TryGetComponentDataInternal<NetworkId>(_entity, out value) ? new NetworkId?(value) : null;
			}
		}

		public CastleBuildingMaxRange? CastleBuildingMaxRange
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleBuildingMaxRange value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleBuildingMaxRange>(_entity, out value) ? new CastleBuildingMaxRange?(value) : null;
			}
		}

		public PlacementDestroyData? PlacementDestroyData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				PlacementDestroyData value;
				return _world.EntityManager.TryGetComponentDataInternal<PlacementDestroyData>(_entity, out value) ? new PlacementDestroyData?(value) : null;
			}
		}

		public CastleAreaRequirement? CastleAreaRequirement
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleAreaRequirement value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleAreaRequirement>(_entity, out value) ? new CastleAreaRequirement?(value) : null;
			}
		}

		public List<NetworkedEntityModificationBuffer> NetworkedEntityModificationBuffers => _world.EntityManager.GetBufferInternal<NetworkedEntityModificationBuffer>(_entity);

		public List<CastleBuildingAttachedChildrenBuffer> CastleBuildingAttachedChildrenBuffers => _world.EntityManager.GetBufferInternal<CastleBuildingAttachedChildrenBuffer>(_entity);

		public List<BlueprintRequirementBuffer> BlueprintRequirementBuffers => _world.EntityManager.GetBufferInternal<BlueprintRequirementBuffer>(_entity);

		public bool TilePlacementTag => _world.EntityManager.HasComponentInternal<TilePlacementTag>(_entity);

		public bool Networked => _world.EntityManager.HasComponentInternal<Networked>(_entity);

		public bool RunCastleCleanupOnDeath => _world.EntityManager.HasComponentInternal<RunCastleCleanupOnDeath>(_entity);

		public bool RestrictPlacementToMapZones => _world.EntityManager.HasComponentInternal<RestrictPlacementToMapZones>(_entity);

		public bool NetworkSnapshotType => _world.EntityManager.HasComponentInternal<NetworkSnapshotType>(_entity);

		public bool TileModelLayer => _world.EntityManager.HasComponentInternal<TileModelLayer>(_entity);

		public BuffResistances? BuffResistances
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				BuffResistances value;
				return _world.EntityManager.TryGetComponentDataInternal<BuffResistances>(_entity, out value) ? new BuffResistances?(value) : null;
			}
		}

		public Script_ApplyBuffUnderHealthThreshhold_DataServer? Script_ApplyBuffUnderHealthThreshhold_DataServer
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Script_ApplyBuffUnderHealthThreshhold_DataServer value;
				return _world.EntityManager.TryGetComponentDataInternal<Script_ApplyBuffUnderHealthThreshhold_DataServer>(_entity, out value) ? new Script_ApplyBuffUnderHealthThreshhold_DataServer?(value) : null;
			}
		}

		public Buffable? Buffable
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Buffable value;
				return _world.EntityManager.TryGetComponentDataInternal<Buffable>(_entity, out value) ? new Buffable?(value) : null;
			}
		}

		public CreatedTime? CreatedTime
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CreatedTime value;
				return _world.EntityManager.TryGetComponentDataInternal<CreatedTime>(_entity, out value) ? new CreatedTime?(value) : null;
			}
		}

		public Health? Health
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Health value;
				return _world.EntityManager.TryGetComponentDataInternal<Health>(_entity, out value) ? new Health?(value) : null;
			}
		}

		public HealthConstants? HealthConstants
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				HealthConstants value;
				return _world.EntityManager.TryGetComponentDataInternal<HealthConstants>(_entity, out value) ? new HealthConstants?(value) : null;
			}
		}

		public Immortal? Immortal
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Immortal value;
				return _world.EntityManager.TryGetComponentDataInternal<Immortal>(_entity, out value) ? new Immortal?(value) : null;
			}
		}

		public CollisionRadius? CollisionRadius
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CollisionRadius value;
				return _world.EntityManager.TryGetComponentDataInternal<CollisionRadius>(_entity, out value) ? new CollisionRadius?(value) : null;
			}
		}

		public ArmorLevel? ArmorLevel
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				ArmorLevel value;
				return _world.EntityManager.TryGetComponentDataInternal<ArmorLevel>(_entity, out value) ? new ArmorLevel?(value) : null;
			}
		}

		public EntityCategory? EntityCategory
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				EntityCategory value;
				return _world.EntityManager.TryGetComponentDataInternal<EntityCategory>(_entity, out value) ? new EntityCategory?(value) : null;
			}
		}

		public StaticTransformCompatible? StaticTransformCompatible
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				StaticTransformCompatible value;
				return _world.EntityManager.TryGetComponentDataInternal<StaticTransformCompatible>(_entity, out value) ? new StaticTransformCompatible?(value) : null;
			}
		}

		public ImpactMaterial? ImpactMaterial
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				ImpactMaterial value;
				return _world.EntityManager.TryGetComponentDataInternal<ImpactMaterial>(_entity, out value) ? new ImpactMaterial?(value) : null;
			}
		}

		public CastleDecayAndRegen? CastleDecayAndRegen
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleDecayAndRegen value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleDecayAndRegen>(_entity, out value) ? new CastleDecayAndRegen?(value) : null;
			}
		}

		public StaticHierarchyData StaticHierarchyData
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				//IL_001c: 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)
				StaticHierarchyData value;
				return (StaticHierarchyData)(_world.EntityManager.TryGetComponentDataInternal<StaticHierarchyData>(_entity, out value) ? value : default(StaticHierarchyData));
			}
		}

		public List<BoolModificationBuffer> BoolModificationBuffers => _world.EntityManager.GetBufferInternal<BoolModificationBuffer>(_entity);

		public List<EntityModificationBuffer> EntityModificationBuffers => _world.EntityManager.GetBufferInternal<EntityModificationBuffer>(_entity);

		public List<FloatModificationBuffer> FloatModificationBuffers => _world.EntityManager.GetBufferInternal<FloatModificationBuffer>(_entity);

		public List<IntModificationBuffer> IntModificationBuffers => _world.EntityManager.GetBufferInternal<IntModificationBuffer>(_entity);

		public List<StaticHierarchyBuffer> StaticHierarchyBuffers => _world.EntityManager.GetBufferInternal<StaticHierarchyBuffer>(_entity);

		public List<CastleBuildingAttachToParentsBuffer> CastleBuildingAttachToParentsBuffers => _world.EntityManager.GetBufferInternal<CastleBuildingAttachToParentsBuffer>(_entity);

		public List<CreateGameplayEventsOnSpawn> CreateGameplayEventsOnSpawns => _world.EntityManager.GetBufferInternal<CreateGameplayEventsOnSpawn>(_entity);

		public List<ApplyBuffOnGameplayEvent> ApplyBuffOnGameplayEvents => _world.EntityManager.GetBufferInternal<ApplyBuffOnGameplayEvent>(_entity);

		public List<GameplayEventIdMapping> GameplayEventIdMappings => _world.EntityManager.GetBufferInternal<GameplayEventIdMapping>(_entity);

		public bool TileCollisionTag => _world.EntityManager.HasComponentInternal<TileCollisionTag>(_entity);

		public bool TilePathfindingTag => _world.EntityManager.HasComponentInternal<TilePathfindingTag>(_entity);

		public bool TileLineOfSightTag => _world.EntityManager.HasComponentInternal<TileLineOfSightTag>(_entity);

		public bool ScriptSpawn => _world.EntityManager.HasComponentInternal<ScriptSpawn>(_entity);

		public bool MoveStopTrigger => _world.EntityManager.HasComponentInternal<MoveStopTrigger>(_entity);

		public ProgressionUserContentDependency? ProgressionUserContentDependency
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				ProgressionUserContentDependency value;
				return _world.EntityManager.TryGetComponentDataInternal<ProgressionUserContentDependency>(_entity, out value) ? new ProgressionUserContentDependency?(value) : null;
			}
		}

		public PavementBonusSource? PavementBonusSource
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				PavementBonusSource value;
				return _world.EntityManager.TryGetComponentDataInternal<PavementBonusSource>(_entity, out value) ? new PavementBonusSource?(value) : null;
			}
		}

		public Parent? Parent
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Parent value;
				return _world.EntityManager.TryGetComponentDataInternal<Parent>(_entity, out value) ? new Parent?(value) : null;
			}
		}

		public RotateAroundAxis? RotateAroundAxis
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				RotateAroundAxis value;
				return _world.EntityManager.TryGetComponentDataInternal<RotateAroundAxis>(_entity, out value) ? new RotateAroundAxis?(value) : null;
			}
		}

		public bool CastleBuildingShowOnlyInPreview => _world.EntityManager.HasComponentInternal<CastleBuildingShowOnlyInPreview>(_entity);

		public InventoryOwner? InventoryOwner
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				InventoryOwner value;
				return _world.EntityManager.TryGetComponentDataInternal<InventoryOwner>(_entity, out value) ? new InventoryOwner?(value) : null;
			}
		}

		public Refinementstation? Refinementstation
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Refinementstation value;
				return _world.EntityManager.TryGetComponentDataInternal<Refinementstation>(_entity, out value) ? new Refinementstation?(value) : null;
			}
		}

		public WorkstationAssignedServant? WorkstationAssignedServant
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				WorkstationAssignedServant value;
				return _world.EntityManager.TryGetComponentDataInternal<WorkstationAssignedServant>(_entity, out value) ? new WorkstationAssignedServant?(value) : null;
			}
		}

		public CastleRoomConnection? CastleRoomConnection
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleRoomConnection value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleRoomConnection>(_entity, out value) ? new CastleRoomConnection?(value) : null;
			}
		}

		public ServantInteractPointLocalTransform? ServantInteractPointLocalTransform
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				ServantInteractPointLocalTransform value;
				return _world.EntityManager.TryGetComponentDataInternal<ServantInteractPointLocalTransform>(_entity, out value) ? new ServantInteractPointLocalTransform?(value) : null;
			}
		}

		public StationServants? StationServants
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				StationServants value;
				return _world.EntityManager.TryGetComponentDataInternal<StationServants>(_entity, out value) ? new StationServants?(value) : null;
			}
		}

		public CastleWorkstation? CastleWorkstation
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleWorkstation value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleWorkstation>(_entity, out value) ? new CastleWorkstation?(value) : null;
			}
		}

		public CastleBuildingAttachSettings? CastleBuildingAttachSettings
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleBuildingAttachSettings value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleBuildingAttachSettings>(_entity, out value) ? new CastleBuildingAttachSettings?(value) : null;
			}
		}

		public Interactable? Interactable
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Interactable value;
				return _world.EntityManager.TryGetComponentDataInternal<Interactable>(_entity, out value) ? new Interactable?(value) : null;
			}
		}

		public InteractedUpon? InteractedUpon
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				InteractedUpon value;
				return _world.EntityManager.TryGetComponentDataInternal<InteractedUpon>(_entity, out value) ? new InteractedUpon?(value) : null;
			}
		}

		public List<InventoryBuffer> InventoryBuffers => _world.EntityManager.GetBufferInternal<InventoryBuffer>(_entity);

		public List<StationBonusBuffer> StationBonusBuffers => _world.EntityManager.GetBufferInternal<StationBonusBuffer>(_entity);

		public List<RefinementstationRecipesBuffer> RefinementstationRecipesBuffers => _world.EntityManager.GetBufferInternal<RefinementstationRecipesBuffer>(_entity);

		public List<InteractAbilityBuffer> InteractAbilityBuffers => _world.EntityManager.GetBufferInternal<InteractAbilityBuffer>(_entity);

		public bool TileHeightTag => _world.EntityManager.HasComponentInternal<TileHeightTag>(_entity);

		public bool PickParentTag => _world.EntityManager.HasComponentInternal<PickParentTag>(_entity);

		public bool WallpaperSet => _world.EntityManager.HasComponentInternal<WallpaperSet>(_entity);

		public List<DoorChildren> DoorChildrens => _world.EntityManager.GetBufferInternal<DoorChildren>(_entity);

		public bool ChildPrefabTag => _world.EntityManager.HasComponentInternal<ChildPrefabTag>(_entity);

		public NetherSpawnPosition? NetherSpawnPosition
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				NetherSpawnPosition value;
				return _world.EntityManager.TryGetComponentDataInternal<NetherSpawnPosition>(_entity, out value) ? new NetherSpawnPosition?(value) : null;
			}
		}

		public CastleLimited? CastleLimited
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleLimited value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleLimited>(_entity, out value) ? new CastleLimited?(value) : null;
			}
		}

		public HybridModelSeed? HybridModelSeed
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				HybridModelSeed value;
				return _world.EntityManager.TryGetComponentDataInternal<HybridModelSeed>(_entity, out value) ? new HybridModelSeed?(value) : null;
			}
		}

		public NameableInteractable? NameableInteractable
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				NameableInteractable value;
				return _world.EntityManager.TryGetComponentDataInternal<NameableInteractable>(_entity, out value) ? new NameableInteractable?(value) : null;
			}
		}

		public PrisonCell? PrisonCell
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				PrisonCell value;
				return _world.EntityManager.TryGetComponentDataInternal<PrisonCell>(_entity, out value) ? new PrisonCell?(value) : null;
			}
		}

		public EntityOwner? EntityOwner
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				EntityOwner value;
				return _world.EntityManager.TryGetComponentDataInternal<EntityOwner>(_entity, out value) ? new EntityOwner?(value) : null;
			}
		}

		public EntityCreator? EntityCreator
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				EntityCreator value;
				return _world.EntityManager.TryGetComponentDataInternal<EntityCreator>(_entity, out value) ? new EntityCreator?(value) : null;
			}
		}

		public Prisonstation? Prisonstation
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Prisonstation value;
				return _world.EntityManager.TryGetComponentDataInternal<Prisonstation>(_entity, out value) ? new Prisonstation?(value) : null;
			}
		}

		public List<QueuedWorkstationCraftAction> QueuedWorkstationCraftActions => _world.EntityManager.GetBufferInternal<QueuedWorkstationCraftAction>(_entity);

		public List<QueuedWorkstationCraftActionItems> QueuedWorkstationCraftActionItems => _world.EntityManager.GetBufferInternal<QueuedWorkstationCraftActionItems>(_entity);

		public List<WorkstationRecipesBuffer> WorkstationRecipesBuffers => _world.EntityManager.GetBufferInternal<WorkstationRecipesBuffer>(_entity);

		public UserOwner? UserOwner
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				UserOwner value;
				return _world.EntityManager.TryGetComponentDataInternal<UserOwner>(_entity, out value) ? new UserOwner?(value) : null;
			}
		}

		public Pylonstation? Pylonstation
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				Pylonstation value;
				return _world.EntityManager.TryGetComponentDataInternal<Pylonstation>(_entity, out value) ? new Pylonstation?(value) : null;
			}
		}

		public CastleFloor? CastleFloor
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleFloor value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleFloor>(_entity, out value) ? new CastleFloor?(value) : null;
			}
		}

		public CastleFloorRoof? CastleFloorRoof
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleFloorRoof value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleFloorRoof>(_entity, out value) ? new CastleFloorRoof?(value) : null;
			}
		}

		public MapPylonArea? MapPylonArea
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				MapPylonArea value;
				return _world.EntityManager.TryGetComponentDataInternal<MapPylonArea>(_entity, out value) ? new MapPylonArea?(value) : null;
			}
		}

		public CastleHeart? CastleHeart
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				CastleHeart value;
				return _world.EntityManager.TryGetComponentDataInternal<CastleHeart>(_entity, out value) ? new CastleHeart?(value) : null;
			}
		}

		public DurabilityTarget? DurabilityTarget
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				DurabilityTarget value;
				return _world.EntityManager.TryGetComponentDataInternal<DurabilityTarget>(_entity, out value) ? new DurabilityTarget?(value) : null;
			}
		}

		public List<Restricted_InventoryBuffer> Restricted_InventoryBuffer => _world.EntityManager.GetBufferInternal<Restricted_InventoryBuffer>(_entity);

		public List<AttachMapIconsToEntity> AttachMapIconsToEntities => _world.EntityManager.GetBufferInternal<AttachMapIconsToEntity>(_entity);

		public List<MapIconPerUserData> MapIconPerUserDatas => _world.EntityManager.GetBufferInternal<MapIconPerUserData>(_entity);

		public List<PylonstationUpgradesBuffer> PylonstationUpgradesBuffers => _world.EntityManager.GetBufferInternal<PylonstationUpgradesBuffer>(_entity);

		public List<PylonstationCastleClaimBuffer> PylonstationCastleClaimBuffers => _world.EntityManager.GetBufferInternal<PylonstationCastleClaimBuffer>(_entity);

		public List<PylonstationCastleDestroyBuffer> PylonstationCastleDestroyBuffers => _world.EntityManager.GetBufferInternal<PylonstationCastleDestroyBuffer>(_entity);

		public List<ProgressionDependencyElement> ProgressionDependencyElements => _world.EntityManager.GetBufferInternal<ProgressionDependencyElement>(_entity);

		public Door Door
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				//IL_001c: 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)
				Door value;
				return (Door)(_world.EntityManager.TryGetComponentDataInternal<Door>(_entity, out value) ? value : default(Door));
			}
		}

		public bool AnnounceCastleBreached => _world.EntityManager.HasComponentInternal<AnnounceCastleBreached>(_entity);

		public BloodAltar? BloodAltar
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				BloodAltar value;
				return _world.EntityManager.TryGetComponentDataInternal<BloodAltar>(_entity, out value) ? new BloodAltar?(value) : null;
			}
		}

		public List<BloodHuntBuffer> BloodHuntBuffers => _world.EntityManager.GetBufferInternal<BloodHuntBuffer>(_entity);

		public StartGraveyardExitWaypoint? StartGraveyardExitWaypoint
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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)
				StartGraveyardExitWaypoint value;
				return _world.EntityManager.TryGetComponentDataInternal<StartGraveyardExitWaypoint>(_entity, out value) ? new StartGraveyardExitWaypoint?(value) : null;
			}
		}

		public bool AlwaysNetworked => _world.EntityManager.HasComponentInternal<AlwaysNetworked>(_entity);

		public CastleWall? CastleWall
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (mig