Decompiled source of BloodyCore v2.0.0

Bloody.Core.dll

Decompiled 3 weeks ago
using System;
using System.Collections;
using System.Collections.Concurrent;
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 System.Threading;
using Animation;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using Bloody.Core.API.v1;
using Bloody.Core.GameData.v1;
using Bloody.Core.Helper.v1;
using Bloody.Core.Models.v1;
using Bloody.Core.Models.v1.Base;
using Bloody.Core.Models.v1.Data;
using Bloody.Core.Models.v1.Internals;
using Bloody.Core.Patch.Client;
using Bloody.Core.Patch.Server;
using Bloody.Core.Utils.v1;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Text;
using Microsoft.CodeAnalysis;
using ProjectM;
using ProjectM.Behaviours;
using ProjectM.CastleBuilding;
using ProjectM.CastleBuilding.AssetSwapping;
using ProjectM.CastleBuilding.Placement;
using ProjectM.CastleBuilding.Rebuilding;
using ProjectM.Contest;
using ProjectM.Contest.Arena;
using ProjectM.Contest.Duel;
using ProjectM.Gameplay;
using ProjectM.Gameplay.Clan;
using ProjectM.Gameplay.Scripting;
using ProjectM.Gameplay.Systems;
using ProjectM.Haptics;
using ProjectM.Hybrid;
using ProjectM.LightningStorm;
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.Shared.WarEvents;
using ProjectM.Shared.WorldEvents;
using ProjectM.SunBlocker;
using ProjectM.Terrain;
using ProjectM.Tiles;
using ProjectM.Transmog;
using ProjectM.UI;
using ProjectM.WeaponCoating;
using Rukhanka;
using Stunlock.Core;
using Stunlock.Core.Authoring;
using Stunlock.Localization;
using Stunlock.Network;
using Stunlock.Sequencer;
using Tests;
using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Physics;
using Unity.Physics.Systems;
using Unity.Scenes;
using Unity.Transforms;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("trodi")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Framework for Bloody Mods")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+22.Branch.master.Sha.9b539d4f3ca2e37646ec9ff1acc823a79fb70429")]
[assembly: AssemblyProduct("Bloody.Core")]
[assembly: AssemblyTitle("Bloody.Core")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/oscarpedrero/BloodyCore")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Bloody.Core
{
	[BepInPlugin("trodi.Bloody.Core", "Bloody.Core", "2.0.0")]
	public class Core : BasePlugin
	{
		private static Harmony _harmony;

		private static bool _initialized;

		internal static bool _worldDataInitialized;

		internal const string NotInitializedError = "Core is not initialized";

		public static bool IsServer = Application.productName == "VRisingServer";

		public static bool IsClient = Application.productName == "VRising";

		internal static ManualLogSource Log = Logger.CreateLogSource("Bloody.Core");

		internal static Logger Logger = new Logger(Log);

		private static World _world;

		public static EventsHandlerSystem EventHandlerSystem;

		internal static Core Instance { get; private set; }

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

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

		public Core()
		{
			Instance = this;
		}

		public override void Load()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!_initialized)
			{
				_initialized = true;
				_harmony = new Harmony("Bloody.Core");
				if (IsClient)
				{
					Logger.LogInfo("Load Systems for Client");
					_harmony.PatchAll(typeof(OnGameClientDataInitializedPatch));
					_harmony.PatchAll(typeof(ClientActionScheduler));
					OnGameClientDataInitializedPatch.OnCoreInitialized += OnCoreInitialized;
					OnGameClientDataInitializedPatch.OnCoreDestroyed += OnCoreDestroyed;
				}
				if (IsServer)
				{
					Logger.LogInfo("Load Systems for Server");
					_harmony.PatchAll(typeof(ActionScheduler));
					_harmony.PatchAll(typeof(DeathPatch));
					_harmony.PatchAll(typeof(DealDamageSystemPatch));
					_harmony.PatchAll(typeof(DeathVBloodPatch));
					_harmony.PatchAll(typeof(GameBootstrapPatch));
					_harmony.PatchAll(typeof(ServerBootstrapPatch));
					_harmony.PatchAll(typeof(TraderPurchasePatch));
					_harmony.PatchAll(typeof(UnitSpawnerPatch));
					_harmony.PatchAll(typeof(SaveSystemPatch));
					_harmony.PatchAll(typeof(BuffPatch));
					_harmony.PatchAll(typeof(VampireDownedPatch));
					_harmony.PatchAll(typeof(OnGameServerDataInitializedPatch));
					OnGameServerDataInitializedPatch.OnCoreInitialized += OnCoreInitialized;
				}
				EventHandlerSystem = new EventsHandlerSystem();
				Logger.LogInfo("Plugin trodi.Bloody.Core version 2.0.0 is loaded!");
			}
		}

		internal static void Destroy()
		{
			_harmony.UnpatchSelf();
			_harmony = null;
		}

		internal static void OnCoreDestroyed()
		{
			_world = null;
			_worldDataInitialized = false;
		}

		internal static void OnCoreInitialized(World world)
		{
			Logger.LogInfo("OnCoreInitialized is loaded!");
			_world = world;
			_worldDataInitialized = true;
		}
	}
	public static class ECSExtensions
	{
		private static EntityManager GetEntityManager()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Core.World.EntityManager;
		}

		public unsafe static void Write<T>(this Entity entity, T componentData) where T : struct
		{
			//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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			ComponentType val = default(ComponentType);
			((ComponentType)(ref val))..ctor(Il2CppType.Of<T>(), (AccessMode)0);
			byte[] array = StructureToByteArray(componentData);
			int num = Marshal.SizeOf<T>();
			fixed (byte* ptr = array)
			{
				EntityManager entityManager = GetEntityManager();
				((EntityManager)(ref entityManager)).SetComponentDataRaw(entity, val.TypeIndex, (void*)ptr, num);
			}
		}

		public static byte[] StructureToByteArray<T>(T structure) where T : struct
		{
			int num = Marshal.SizeOf(structure);
			byte[] array = new byte[num];
			IntPtr intPtr = Marshal.AllocHGlobal(num);
			Marshal.StructureToPtr(structure, intPtr, fDeleteOld: true);
			Marshal.Copy(intPtr, array, 0, num);
			Marshal.FreeHGlobal(intPtr);
			return array;
		}

		public unsafe static T Read<T>(this Entity entity) where T : struct
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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)
			//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)
			ComponentType val = default(ComponentType);
			((ComponentType)(ref val))..ctor(Il2CppType.Of<T>(), (AccessMode)0);
			EntityManager entityManager = GetEntityManager();
			return Marshal.PtrToStructure<T>(new IntPtr(((EntityManager)(ref entityManager)).GetComponentDataRawRO(entity, val.TypeIndex)));
		}

		public static DynamicBuffer<T> ReadBuffer<T>(this Entity entity) where T : struct
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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)
			EntityManager entityManager = GetEntityManager();
			return ((EntityManager)(ref entityManager)).GetBuffer<T>(entity, false);
		}

		public static bool Has<T>(this Entity entity)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			ComponentType val = default(ComponentType);
			((ComponentType)(ref val))..ctor(Il2CppType.Of<T>(), (AccessMode)0);
			EntityManager entityManager = GetEntityManager();
			return ((EntityManager)(ref entityManager)).HasComponent(entity, val);
		}

		public static string LookupName(this PrefabGUID prefabGuid)
		{
			//IL_000c: 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_0016: 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_0028: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			PrefabCollectionSystem existingSystemManaged = VWorld.Server.GetExistingSystemManaged<PrefabCollectionSystem>();
			NativeParallelHashMap<PrefabGUID, Entity> guidToEntityMap = existingSystemManaged._PrefabLookupMap.GuidToEntityMap;
			if (!guidToEntityMap.ContainsKey(prefabGuid))
			{
				return "GUID Not Found";
			}
			PrefabLookupMap prefabLookupMap = existingSystemManaged._PrefabLookupMap;
			return ((PrefabLookupMap)(ref prefabLookupMap)).GetName(prefabGuid) + " PrefabGuid(" + ((PrefabGUID)(ref prefabGuid)).GuidHash + ")";
		}

		public static void Add<T>(this Entity entity)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			ComponentType val = default(ComponentType);
			((ComponentType)(ref val))..ctor(Il2CppType.Of<T>(), (AccessMode)0);
			EntityManager entityManager = GetEntityManager();
			((EntityManager)(ref entityManager)).AddComponent(entity, val);
		}

		public static void Remove<T>(this Entity entity)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			ComponentType val = default(ComponentType);
			((ComponentType)(ref val))..ctor(Il2CppType.Of<T>(), (AccessMode)0);
			EntityManager entityManager = GetEntityManager();
			((EntityManager)(ref entityManager)).RemoveComponent(entity, val);
		}

		public static bool Exists(this Entity entity)
		{
			//IL_0000: 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)
			//IL_000e: 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)
			if (entity.Index > 0)
			{
				EntityManager entityManager = GetEntityManager();
				return ((EntityManager)(ref entityManager)).Exists(entity);
			}
			return false;
		}
	}
	public class SystemsCore
	{
		private static SystemsCore _instance;

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

		public EntityManager EntityManager => Core.World.EntityManager;

		public PrefabCollectionSystem PrefabCollectionSystem => Core.World.GetExistingSystemManaged<PrefabCollectionSystem>();

		public GameDataSystem GameDataSystem => Core.World.GetExistingSystemManaged<GameDataSystem>();

		public ManagedDataRegistry ManagedDataRegistry => GameDataSystem.ManagedDataRegistry;

		public DebugEventsSystem DebugEventsSystem => Core.World.GetExistingSystemManaged<DebugEventsSystem>();

		public UnitSpawnerUpdateSystem UnitSpawnerUpdateSystem => Core.World.GetExistingSystemManaged<UnitSpawnerUpdateSystem>();

		public ServerScriptMapper ServerScriptMapper => Core.World.GetExistingSystemManaged<ServerScriptMapper>();
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "trodi.Bloody.Core";

		public const string PLUGIN_NAME = "Bloody.Core";

		public const string PLUGIN_VERSION = "2.0.0";
	}
}
namespace Bloody.Core.Utils.v1
{
	public static class ExtensionMethods
	{
		public static string GetPrefabName(this PrefabGUID prefabGuid)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return prefabGuid.LookupName();
			}
			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(AllocatorHandle.op_Implicit((Allocator)2)).GetEnumerator();
			while (enumerator.MoveNext())
			{
				Entity current = enumerator.Current;
				yield return new BaseEntityModel(Core.World, current);
			}
		}

		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(AllocatorHandle.op_Implicit((Allocator)2)).GetEnumerator();
			while (enumerator.MoveNext())
			{
				Entity current = enumerator.Current;
				yield return new NpcModel(current);
			}
		}

		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_0000: 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_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)
			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;
	}
	public static class VWorld
	{
		private static World? _clientWorld;

		private static World? _serverWorld;

		public static World Server
		{
			get
			{
				if (_serverWorld != null && _serverWorld.IsCreated)
				{
					return _serverWorld;
				}
				_serverWorld = GetWorld("Server") ?? throw new Exception("There is no Server world (yet). Did you install a server mod on the client?");
				return _serverWorld;
			}
		}

		public static World Client
		{
			get
			{
				if (_clientWorld != null && _clientWorld.IsCreated)
				{
					return _clientWorld;
				}
				_clientWorld = GetWorld("Client_0") ?? throw new Exception("There is no Client world (yet). Did you install a client mod on the server?");
				return _clientWorld;
			}
		}

		public static World Default => World.DefaultGameObjectInjectionWorld;

		public static World Game
		{
			get
			{
				if (!IsClient)
				{
					return Server;
				}
				return Client;
			}
		}

		public static bool IsServer => Application.productName == "VRisingServer";

		public static bool IsClient => Application.productName == "VRising";

		private static World? GetWorld(string name)
		{
			Enumerator<World> enumerator = World.s_AllWorlds.GetEnumerator();
			while (enumerator.MoveNext())
			{
				World current = enumerator.Current;
				if (current.Name == name)
				{
					_serverWorld = current;
					return current;
				}
			}
			return null;
		}
	}
}
namespace Bloody.Core.Patch.Server
{
	[HarmonyPatch(typeof(ServerBootstrapSystem), "OnUpdate")]
	public static class ActionScheduler
	{
		public static int CurrentFrameCount = 0;

		public static Action OnGameFrameUpdate;

		public static ConcurrentQueue<Action> actionsToExecuteOnMainThread = new ConcurrentQueue<Action>();

		private static List<Timer> activeTimers = new List<Timer>();

		public static void Postfix()
		{
			OnGameFrameUpdate?.Invoke();
			CurrentFrameCount++;
			Action result;
			while (actionsToExecuteOnMainThread.TryDequeue(out result))
			{
				result?.Invoke();
			}
		}

		public static Timer RunActionEveryInterval(Action action, double intervalInSeconds)
		{
			return new Timer(delegate
			{
				actionsToExecuteOnMainThread.Enqueue(action);
			}, null, TimeSpan.FromSeconds(intervalInSeconds), TimeSpan.FromSeconds(intervalInSeconds));
		}

		public static Timer RunActionOnceAfterDelay(Action action, double delayInSeconds)
		{
			Timer timer = null;
			timer = new Timer(delegate
			{
				actionsToExecuteOnMainThread.Enqueue(delegate
				{
					action();
					timer?.Dispose();
				});
			}, null, TimeSpan.FromSeconds(delayInSeconds), Timeout.InfiniteTimeSpan);
			return timer;
		}

		public static Timer RunActionOnceAfterFrames(Action action, int frameDelay)
		{
			int startFrame = CurrentFrameCount;
			Timer timer = null;
			timer = new Timer(delegate
			{
				if (CurrentFrameCount - startFrame >= frameDelay)
				{
					actionsToExecuteOnMainThread.Enqueue(delegate
					{
						action();
					});
					timer?.Dispose();
				}
			}, null, TimeSpan.Zero, TimeSpan.FromMilliseconds(8.0));
			return timer;
		}

		public static void RunActionOnMainThread(Action action)
		{
			actionsToExecuteOnMainThread.Enqueue(delegate
			{
				action();
			});
		}
	}
	[HarmonyPatch]
	internal static class BuffPatch
	{
		internal static event PlayerBuffedEventHandler OnPlayerBuffed;

		internal static event PlayerBuffRemovedEventHandler OnPlayerBuffRemoved;

		[HarmonyPatch(typeof(BuffDebugSystem), "OnUpdate")]
		[HarmonyPostfix]
		private static void BuffPatch_Postfix(BuffDebugSystem __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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0027: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_003a: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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)
			try
			{
				EntityQuery _query_401358787_ = __instance.__query_401358787_0;
				NativeArray<Entity> val = ((EntityQuery)(ref _query_401358787_)).ToEntityArray(AllocatorHandle.op_Implicit((Allocator)2));
				Enumerator<Entity> enumerator = val.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Entity current = enumerator.Current;
					PrefabGUID prefabGuid = current.Read<PrefabGUID>();
					Entity owner = current.Read<EntityOwner>().Owner;
					if (owner.Has<PlayerCharacter>())
					{
						try
						{
							UserModel player = Bloody.Core.GameData.v1.GameData.Users.FromEntity(owner.Read<PlayerCharacter>().UserEntity);
							BuffPatch.OnPlayerBuffed?.Invoke(player, current, prefabGuid);
						}
						catch (Exception ex)
						{
							Core.Logger.LogError("BuffDebugSystem.OnUpdate Error " + ex.Message);
						}
					}
				}
				val.Dispose();
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}

		[HarmonyPatch(typeof(UpdateBuffsBuffer_Destroy), "OnUpdate")]
		[HarmonyPostfix]
		public static void Prefix(UpdateBuffsBuffer_Destroy __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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0027: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_003a: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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)
			try
			{
				EntityQuery _query_401358717_ = __instance.__query_401358717_0;
				NativeArray<Entity> val = ((EntityQuery)(ref _query_401358717_)).ToEntityArray(AllocatorHandle.op_Implicit((Allocator)2));
				Enumerator<Entity> enumerator = val.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Entity current = enumerator.Current;
					PrefabGUID prefabGuid = current.Read<PrefabGUID>();
					Entity owner = current.Read<EntityOwner>().Owner;
					if (owner.Has<PlayerCharacter>())
					{
						try
						{
							UserModel player = Bloody.Core.GameData.v1.GameData.Users.FromEntity(owner.Read<PlayerCharacter>().UserEntity);
							BuffPatch.OnPlayerBuffRemoved?.Invoke(player, current, prefabGuid);
						}
						catch
						{
						}
					}
				}
				val.Dispose();
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
	[HarmonyPatch]
	internal class DealDamageSystemPatch
	{
		internal static event DamageEventHandler OnDamage;

		[HarmonyPatch(typeof(DealDamageSystem), "DealDamage")]
		[HarmonyPostfix]
		private static void DealDamageSystemPatch_Postfix(DealDamageSystem __instance)
		{
			//IL_0008: 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_0012: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				NativeArray<DealDamageEvent> damageEvents = ((EntityQuery)(ref __instance._Query)).ToComponentDataArray<DealDamageEvent>(AllocatorHandle.op_Implicit((Allocator)2));
				DealDamageSystemPatch.OnDamage?.Invoke(__instance, damageEvents);
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
	[HarmonyPatch]
	internal class DeathPatch
	{
		internal static event DeathEventHandler OnDeath;

		[HarmonyPatch(typeof(DeathEventListenerSystem), "OnUpdate")]
		[HarmonyPostfix]
		private static void DeathEventListenerSystemPatch_Postfix(DeathEventListenerSystem __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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				EntityQuery deathEventQuery = __instance._DeathEventQuery;
				NativeArray<DeathEvent> deathEvents = ((EntityQuery)(ref deathEventQuery)).ToComponentDataArray<DeathEvent>(AllocatorHandle.op_Implicit((Allocator)2));
				DeathPatch.OnDeath?.Invoke(__instance, deathEvents);
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
	[HarmonyPatch]
	internal class DeathVBloodPatch
	{
		public static event DeathVbloodEventHandler OnDeathVBlood;

		[HarmonyPatch(typeof(VBloodSystem), "OnUpdate")]
		[HarmonyPrefix]
		private static void OnUpdate_Prefix(VBloodSystem __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				DeathVBloodPatch.OnDeathVBlood?.Invoke(__instance, __instance.EventList);
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
	internal class GameBootstrapPatch
	{
		internal static event GameBootstrapStartEventHandler OnStart;

		[HarmonyPatch(typeof(GameBootstrap), "Start")]
		[HarmonyPostfix]
		private static void Postfix()
		{
			try
			{
				GameBootstrapPatch.OnStart?.Invoke();
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
	internal static class OnGameServerDataInitializedPatch
	{
		internal static event OnGameDataInitializedEventHandler OnCoreInitialized;

		[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)
				{
					World server = VWorld.Server;
					server = ((!VWorld.IsServer) ? VWorld.Client : VWorld.Server);
					OnGameServerDataInitializedPatch.OnCoreInitialized?.Invoke(server);
				}
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
	[HarmonyPatch]
	internal class SaveSystemPatch
	{
		internal static event SaveWorldEventHandler OnSaveWorld;

		[HarmonyPatch(typeof(TriggerPersistenceSaveSystem), "TriggerSave")]
		public static void Prefix()
		{
			SaveSystemPatch.OnSaveWorld?.Invoke();
		}
	}
	internal class ServerBootstrapPatch
	{
		internal static event OnUserConnectedEventHandler OnUserConnected;

		internal static event OnUserDisconnectedEventHandler OnUserDisconnected;

		[HarmonyPatch(typeof(ServerBootstrapSystem), "OnUserConnected")]
		[HarmonyPrefix]
		internal static void Postfix(ServerBootstrapSystem __instance, NetConnectionId netConnectionId)
		{
			try
			{
				ServerBootstrapPatch.OnUserConnected?.Invoke(__instance, netConnectionId);
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}

		[HarmonyPatch(typeof(ServerBootstrapSystem), "OnUserDisconnected")]
		[HarmonyPrefix]
		internal static void Prefix(ServerBootstrapSystem __instance, NetConnectionId netConnectionId, ConnectionStatusChangeReason connectionStatusReason, string extraData)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ServerBootstrapPatch.OnUserDisconnected?.Invoke(__instance, netConnectionId, connectionStatusReason, extraData);
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
	[HarmonyPatch]
	internal class TraderPurchasePatch
	{
		internal static event TraderPurchaseEventHandler OnTraderPurchase;

		[HarmonyPatch(typeof(TraderPurchaseSystem), "OnUpdate")]
		[HarmonyPrefix]
		internal static void Prefix(TraderPurchaseSystem __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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				EntityQuery traderPurchaseEventQuery = __instance._TraderPurchaseEventQuery;
				NativeArray<Entity> entities = ((EntityQuery)(ref traderPurchaseEventQuery)).ToEntityArray(AllocatorHandle.op_Implicit((Allocator)2));
				TraderPurchasePatch.OnTraderPurchase?.Invoke(entities);
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
	[HarmonyPatch]
	internal class UnitSpawnerPatch
	{
		internal static Dictionary<long, (float actualDuration, Action<Entity> Actions)> PostActions = new Dictionary<long, (float, Action<Entity>)>();

		internal static bool EnabledCallBack { get; set; } = false;


		internal static event OnUnitSpawnedEventHandler OnUnitSpawned;

		[HarmonyPatch(typeof(UnitSpawnerReactSystem), "OnUpdate")]
		[HarmonyPostfix]
		internal static void Prefix(UnitSpawnerReactSystem __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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0027: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				EntityQuery query = __instance._Query;
				NativeArray<Entity> entities = ((EntityQuery)(ref query)).ToEntityArray(AllocatorHandle.op_Implicit((Allocator)2));
				if (!EnabledCallBack)
				{
					UnitSpawnerPatch.OnUnitSpawned?.Invoke(entities);
				}
				Enumerator<Entity> enumerator = entities.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Entity current = enumerator.Current;
					if (!EnabledCallBack || !current.Has<LifeTime>())
					{
						return;
					}
					LifeTime val = current.Read<LifeTime>();
					long num = (long)Mathf.Round(val.Duration);
					Core.Logger.LogDebug($"Found durationKey {num} from LifeTime({val.Duration})");
					if (PostActions.TryGetValue(num, out (float, Action<Entity>) value))
					{
						var (num2, action) = value;
						Core.Logger.LogDebug($"Found post actions for {num} with {num2} duration");
						PostActions.Remove(num);
						LifeTimeEndAction endAction = (LifeTimeEndAction)((!(num2 < 0f)) ? 2 : 0);
						LifeTime componentData = new LifeTime
						{
							Duration = num2,
							EndAction = endAction
						};
						current.Write<LifeTime>(componentData);
						action(current);
					}
				}
				EnabledCallBack = false;
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
	[HarmonyPatch]
	internal class VampireDownedPatch
	{
		public static event VampireDownedHandler OnVampireDowned;

		[HarmonyPatch(typeof(VampireDownedServerEventSystem), "OnUpdate")]
		[HarmonyPrefix]
		internal static void Prefix(VampireDownedServerEventSystem __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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			EntityQuery _query_1174204813_ = __instance.__query_1174204813_0;
			NativeArray<Entity> deathEvents = ((EntityQuery)(ref _query_1174204813_)).ToEntityArray(AllocatorHandle.op_Implicit((Allocator)2));
			VampireDownedPatch.OnVampireDowned?.Invoke(__instance, deathEvents);
		}
	}
}
namespace Bloody.Core.Patch.Client
{
	[HarmonyPatch(typeof(ClientBootstrapSystem), "OnUpdate")]
	public static class ClientActionScheduler
	{
		public static int CurrentFrameCount = 0;

		public static Action OnGameFrameUpdate;

		public static ConcurrentQueue<Action> actionsToExecuteOnMainThread = new ConcurrentQueue<Action>();

		private static List<Timer> activeTimers = new List<Timer>();

		public static void Postfix()
		{
			OnGameFrameUpdate?.Invoke();
			CurrentFrameCount++;
			Action result;
			while (actionsToExecuteOnMainThread.TryDequeue(out result))
			{
				result?.Invoke();
			}
		}

		public static Timer RunActionEveryInterval(Action action, double intervalInSeconds)
		{
			return new Timer(delegate
			{
				actionsToExecuteOnMainThread.Enqueue(action);
			}, null, TimeSpan.FromSeconds(intervalInSeconds), TimeSpan.FromSeconds(intervalInSeconds));
		}

		public static Timer RunActionOnceAfterDelay(Action action, double delayInSeconds)
		{
			Timer timer = null;
			timer = new Timer(delegate
			{
				actionsToExecuteOnMainThread.Enqueue(delegate
				{
					action();
					timer?.Dispose();
				});
			}, null, TimeSpan.FromSeconds(delayInSeconds), Timeout.InfiniteTimeSpan);
			return timer;
		}

		public static Timer RunActionOnceAfterFrames(Action action, int frameDelay)
		{
			int startFrame = CurrentFrameCount;
			Timer timer = null;
			timer = new Timer(delegate
			{
				if (CurrentFrameCount - startFrame >= frameDelay)
				{
					actionsToExecuteOnMainThread.Enqueue(delegate
					{
						action();
					});
					timer?.Dispose();
				}
			}, null, TimeSpan.Zero, TimeSpan.FromMilliseconds(8.0));
			return timer;
		}

		public static void RunActionOnMainThread(Action action)
		{
			actionsToExecuteOnMainThread.Enqueue(delegate
			{
				action();
			});
		}
	}
	internal static class OnGameClientDataInitializedPatch
	{
		private static bool _onCoreInitializedTriggered;

		internal static event OnGameDataInitializedEventHandler OnCoreInitialized;

		internal static event OnGameDataDestroyedEventHandler OnCoreDestroyed;

		[HarmonyPatch(typeof(GameDataManager), "OnUpdate")]
		[HarmonyPostfix]
		private static void CoreManagerOnUpdatePostfix(GameDataManager __instance)
		{
			if (_onCoreInitializedTriggered)
			{
				return;
			}
			try
			{
				if (__instance.GameDataInitialized)
				{
					_onCoreInitializedTriggered = true;
					OnGameClientDataInitializedPatch.OnCoreInitialized?.Invoke(((ComponentSystemBase)__instance).World);
				}
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}

		[HarmonyPatch(typeof(ClientBootstrapSystem), "OnDestroy")]
		[HarmonyPostfix]
		private static void ClientBootstrapSystemOnDestroyPostfix(ClientBootstrapSystem __instance)
		{
			_onCoreInitializedTriggered = false;
			try
			{
				OnGameClientDataInitializedPatch.OnCoreDestroyed?.Invoke();
			}
			catch (Exception exception)
			{
				Core.Logger.LogError(exception);
			}
		}
	}
}
namespace Bloody.Core.Models.v1
{
	public class CharacterModel
	{
		public Entity Entity { get; }

		public BaseEntityModel Internals { get; }

		public EquipmentModel Equipment
		{
			get
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				if (!Internals.Equipment.HasValue)
				{
					return null;
				}
				return new EquipmentModel(Internals.Equipment.Value);
			}
		}

		internal CharacterModel(Entity entity)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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)
			Entity = entity;
			Internals = new BaseEntityModel(Core.World, entity);
		}
	}
	public class EquipmentModel
	{
		public Equipment Internals { get; }

		public ItemModel Chest
		{
			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)
				//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_0015: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (!(Internals.ArmorChestSlot.SlotEntity._Entity != Entity.Null))
				{
					return null;
				}
				return new ItemModel(Internals.ArmorChestSlot.SlotEntity._Entity);
			}
		}

		public ItemModel Leg
		{
			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)
				//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_0015: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (!(Internals.ArmorLegsSlot.SlotEntity._Entity != Entity.Null))
				{
					return null;
				}
				return new ItemModel(Internals.ArmorLegsSlot.SlotEntity._Entity);
			}
		}

		public ItemModel Headgear
		{
			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)
				//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_0015: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (!(Internals.ArmorHeadgearSlot.SlotEntity._Entity != Entity.Null))
				{
					return null;
				}
				return new ItemModel(Internals.ArmorHeadgearSlot.SlotEntity._Entity);
			}
		}

		public ItemModel Footgear
		{
			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)
				//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_0015: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (!(Internals.ArmorFootgearSlot.SlotEntity._Entity != Entity.Null))
				{
					return null;
				}
				return new ItemModel(Internals.ArmorFootgearSlot.SlotEntity._Entity);
			}
		}

		public ItemModel Gloves
		{
			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)
				//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_0015: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (!(Internals.ArmorGlovesSlot.SlotEntity._Entity != Entity.Null))
				{
					return null;
				}
				return new ItemModel(Internals.ArmorGlovesSlot.SlotEntity._Entity);
			}
		}

		public ItemModel Cloak
		{
			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)
				//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_0015: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (!(Internals.CloakSlot.SlotEntity._Entity != Entity.Null))
				{
					return null;
				}
				return new ItemModel(Internals.CloakSlot.SlotEntity._Entity);
			}
		}

		public ItemModel Weapon
		{
			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)
				//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_0015: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (!(Internals.WeaponSlot.SlotEntity._Entity != Entity.Null))
				{
					return null;
				}
				return new ItemModel(Internals.WeaponSlot.SlotEntity._Entity);
			}
		}

		public ItemModel Jewelry
		{
			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)
				//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_0015: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (!(Internals.GrimoireSlot.SlotEntity._Entity != Entity.Null))
				{
					return null;
				}
				return new ItemModel(Internals.GrimoireSlot.SlotEntity._Entity);
			}
		}

		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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0005: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			Entity entity = default(Entity);
			InventoryUtilities.TryGetInventoryEntity<EntityManager>(Core.World.EntityManager, _characterModel.Entity, ref entity, 0);
			List<InventoryBuffer> inventoryBuffers = new BaseEntityModel(Core.World, entity).InventoryBuffers;
			if (inventoryBuffers == null)
			{
				return new List<InventoryItemData>();
			}
			return inventoryBuffers.Select(delegate(InventoryBuffer i, int index)
			{
				//IL_002a: 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_001e: 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)
				//IL_002f: 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_0042: Unknown result type (might be due to invalid IL or missing references)
				Entity entity2 = ((((PrefabGUID)(ref i.ItemType)).GuidHash == 0) ? Entity.Null : ((PrefabLookupMap)(ref ((PrefabCollectionSystem_Base)Core.SystemsCore.PrefabCollectionSystem).PrefabLookupMap))[i.ItemType]);
				return new InventoryItemData
				{
					Item = new ItemModel(entity2),
					Stacks = i.Amount,
					Slot = index
				};
			}).ToList();
		}
	}
	public class ItemModel : EntityModel
	{
		public BaseManagedDataModel ManagedCore { get; }

		public string PrefabName { get; }

		public string Name
		{
			get
			{
				//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)
				BaseManagedDataModel managedCore = ManagedCore;
				if (managedCore == null)
				{
					return null;
				}
				ManagedItemData managedItemData = managedCore.ManagedItemData;
				if (managedItemData == null)
				{
					return null;
				}
				LocalizationKey name = managedItemData.Name;
				return ((object)(LocalizationKey)(ref name)).ToString();
			}
		}

		public ItemCategory ItemCategory => (ItemCategory)(((??)base.Internals.ItemData?.ItemCategory) ?? 0);

		public ItemType ItemType => (ItemType)(((??)base.Internals.ItemData?.ItemType) ?? 0);

		public EquipmentType EquipmentType => (EquipmentType)(((??)base.Internals.EquippableData?.EquipmentType) ?? 11);

		internal ItemModel(Entity entity)
			: base(entity)
		{
			//IL_0001: 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)
			PrefabName = base.Internals.PrefabGUID?.GetPrefabName();
			ManagedCore = new BaseManagedDataModel(Core.World, base.Internals);
		}
	}
	public class NpcModel : EntityModel
	{
		private static 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.DeathBuff.HasValue;

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

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

		internal NpcModel(Entity entity)
			: base(entity)
		{
			//IL_0001: 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)
			//IL_0023: 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_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)
			EntityCategory? entityCategory = base.Internals.EntityCategory;
			if (entityCategory.HasValue)
			{
				EntityCategory value = entityCategory.Value;
				if ((int)((EntityCategory)(ref value)).MainCategory == 0)
				{
					HashSet<UnitCategory> npcCategories = _npcCategories;
					value = entityCategory.Value;
					if (npcCategories.Contains(((EntityCategory)(ref value)).UnitCategory))
					{
						return;
					}
				}
			}
			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_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)
				User value = base.Internals.User.Value;
				return ((object)(FixedString64Bytes)(ref value.CharacterName)).ToString();
			}
		}

		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.Value.IsAdmin;

		public bool IsConnected => base.Internals.User.Value.IsConnected;

		public ulong PlatformId => base.Internals.User.Value.PlatformId;

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

		public UserContentFlags UserContent => base.Internals.User.Value.UserContent;

		internal UserModel(Entity entity)
			: base(entity)
		{
			//IL_0001: 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_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)
			Character = new CharacterModel(base.Internals.User.Value.LocalCharacter._Entity);
			Inventory = new InventoryModel(Character);
		}
	}
}
namespace Bloody.Core.Models.v1.Internals
{
	public class BaseEntityModel
	{
		private readonly World _world;

		private readonly Entity _entity;

		public bool Simulate
		{
			get
			{
				//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_000f: Unknown result type (might be due to invalid IL or missing references)
				EntityManager entityManager = _world.EntityManager;
				return ((EntityManager)(ref entityManager)).HasComponent<Simulate>(_entity);
			}
		}

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

		public bool Prefab => _world.EntityManager.HasComponentInternal<Prefab>(_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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<WorldTypeSingleton>(_entity, out WorldTypeSingleton value))
				{
					return null;
				}
				return value;
			}
		}

		public SceneSystemConfiguration? SceneSystemConfiguration
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<SceneSystemConfiguration>(_entity, out SceneSystemConfiguration value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<ServerRuntimeSettings>(_entity, out ServerRuntimeSettings value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<EntityOwner>(_entity, out EntityOwner value))
				{
					return null;
				}
				return value;
			}
		}

		public Age? Age
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<Age>(_entity, out Age value))
				{
					return null;
				}
				return value;
			}
		}

		public LifeTime? LifeTime
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<LifeTime>(_entity, out LifeTime value))
				{
					return null;
				}
				return value;
			}
		}

		public ModifyRotation? ModifyRotation
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<ModifyRotation>(_entity, out ModifyRotation value))
				{
					return null;
				}
				return value;
			}
		}

		public List<RelicDropped> RelicDroppeds => _world.EntityManager.GetBufferInternal<RelicDropped>(_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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<RotateTowardsAimDirectionDuringCastActive>(_entity, out RotateTowardsAimDirectionDuringCastActive value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<DestroyData>(_entity, out DestroyData value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<DestroyState>(_entity, out DestroyState value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<PhysicsCollider>(_entity, out PhysicsCollider value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<StaticPhysicsWorldBodyIndex>(_entity, out StaticPhysicsWorldBodyIndex value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<LocalToWorld>(_entity, out LocalToWorld value))
				{
					return null;
				}
				return value;
			}
		}

		public ContestCollection? ContestCollection
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<ContestCollection>(_entity, out ContestCollection value))
				{
					return null;
				}
				return value;
			}
		}

		public BlobDatabaseSingleton? BlobDatabaseSingleton
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<BlobDatabaseSingleton>(_entity, out BlobDatabaseSingleton value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<TeleportationRequest>(_entity, out TeleportationRequest value))
				{
					return null;
				}
				return value;
			}
		}

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

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<ModifyMovementDuringCastActive>(_entity, out ModifyMovementDuringCastActive value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<Sun>(_entity, out Sun value))
				{
					return null;
				}
				return value;
			}
		}

		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)
				if (!_world.EntityManager.TryGetComponentDataInternal<CloudCookieLight>(_entity, out CloudCookieLight value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<ServerGameBalanceSettings>(_entity, out ServerGameBalanceSettings value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<TerrainChunkLoadedEvent>(_entity, out TerrainChunkLoadedEvent value))
				{
					return null;
				}
				return value;
			}
		}

		public TerrainChunkUnloadedEvent? TerrainChunkUnloadedEvent
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<TerrainChunkUnloadedEvent>(_entity, out TerrainChunkUnloadedEvent value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<TerrainChunkMetadataLoadedEvent>(_entity, out TerrainChunkMetadataLoadedEvent value))
				{
					return null;
				}
				return value;
			}
		}

		public VampireAttributeCapModifications? VampireAttributeCapModifications
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<VampireAttributeCapModifications>(_entity, out VampireAttributeCapModifications value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<MapZoneData>(_entity, out MapZoneData value))
				{
					return null;
				}
				return value;
			}
		}

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

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

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<WorldFrame>(_entity, out WorldFrame value))
				{
					return null;
				}
				return value;
			}
		}

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

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

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

		public AbilityCastStartedEvent? AbilityCastStartedEvent
		{
			get
			{
				//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_000f: 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 = _world.EntityManager;
				AbilityCastStartedEvent value = default(AbilityCastStartedEvent);
				if (!((EntityManager)(ref entityManager)).TryGetComponentData<AbilityCastStartedEvent>(_entity, ref value))
				{
					return null;
				}
				return value;
			}
		}

		public AbilityPreCastFinishedEvent? AbilityPreCastFinishedEvent
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<AbilityPreCastFinishedEvent>(_entity, out AbilityPreCastFinishedEvent value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<AbilityPostCastFinishedEvent>(_entity, out AbilityPostCastFinishedEvent value))
				{
					return null;
				}
				return value;
			}
		}

		public AbilityPreCastEndedEvent? AbilityPreCastEndedEvent
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<AbilityPreCastEndedEvent>(_entity, out AbilityPreCastEndedEvent value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<AbilityPostCastEndedEvent>(_entity, out AbilityPostCastEndedEvent value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<AbilityCastEndedEvent>(_entity, out AbilityCastEndedEvent value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<AbilityInterruptedEvent>(_entity, out AbilityInterruptedEvent value))
				{
					return null;
				}
				return value;
			}
		}

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

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<ToggleDisabledEvent>(_entity, out ToggleDisabledEvent value))
				{
					return null;
				}
				return value;
			}
		}

		public PhysicsWorldSingleton? PhysicsWorldSingleton
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<PhysicsWorldSingleton>(_entity, out PhysicsWorldSingleton value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<MoveDuringCastActive>(_entity, out MoveDuringCastActive value))
				{
					return null;
				}
				return value;
			}
		}

		public Networked? Networked
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<Networked>(_entity, out Networked value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<UpToDateUserBitMask>(_entity, out UpToDateUserBitMask value))
				{
					return null;
				}
				return value;
			}
		}

		public SyncToUserBitMask? SyncToUserBitMask
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<SyncToUserBitMask>(_entity, out SyncToUserBitMask value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<FrameChanged>(_entity, out FrameChanged value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<NetworkSnapshot>(_entity, out NetworkSnapshot value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<NetworkId>(_entity, out NetworkId value))
				{
					return null;
				}
				return value;
			}
		}

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

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

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

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

		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_InventoryInstanceElement> Snapshot_InventoryInstanceElement => _world.EntityManager.GetBufferInternal<Snapshot_InventoryInstanceElement>(_entity);

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

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

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

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

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

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

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

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

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

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

		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 List<Snapshot_InventoryBuffer> Snapshot_InventoryBuffer => _world.EntityManager.GetBufferInternal<Snapshot_InventoryBuffer>(_entity);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public DestroyedNetworkIdSingleton? DestroyedNetworkIdSingleton
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<DestroyedNetworkIdSingleton>(_entity, out DestroyedNetworkIdSingleton value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<WorldTime>(_entity, out WorldTime value))
				{
					return null;
				}
				return value;
			}
		}

		public List<WorldTimeQueue> WorldTimeQueues => _world.EntityManager.GetBufferInternal<WorldTimeQueue>(_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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<PhysicsStep>(_entity, out PhysicsStep value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<KnockbackAssetsSingleton>(_entity, out KnockbackAssetsSingleton value))
				{
					return null;
				}
				return value;
			}
		}

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

		public WarEvent_MapNode? WarEvent_MapNode
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<WarEvent_MapNode>(_entity, out WarEvent_MapNode value))
				{
					return null;
				}
				return value;
			}
		}

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

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

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<LoadToTargetWorld>(_entity, out LoadToTargetWorld value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<RequestSceneLoaded>(_entity, out RequestSceneLoaded value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<ResolvedSceneHash>(_entity, out ResolvedSceneHash value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<SceneReference>(_entity, out SceneReference value))
				{
					return null;
				}
				return value;
			}
		}

		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)
				if (!_world.EntityManager.TryGetComponentDataInternal<PostLoadCommandBuffer>(_entity, out PostLoadCommandBuffer value))
				{
					return null;
				}
				return value;
			}
		}

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

		public bool WorldAssetSingleton => _world.EntityManager.HasComponentInternal<WorldAssetSingleton>(_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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<SceneEntityReference>(_entity, out SceneEntityReference value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<SceneSectionData>(_entity, out SceneSectionData value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<ResolvedSectionPath>(_entity, out ResolvedSectionPath value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<SceneBoundingVolume>(_entity, out SceneBoundingVolume value))
				{
					return null;
				}
				return value;
			}
		}

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

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

		public WorldZoneTextureProjectionMatrix? WorldZoneTextureProjectionMatrix
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<WorldZoneTextureProjectionMatrix>(_entity, out WorldZoneTextureProjectionMatrix value))
				{
					return null;
				}
				return value;
			}
		}

		public WorldZoneId? WorldZoneId
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<WorldZoneId>(_entity, out WorldZoneId value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<Parent>(_entity, out Parent value))
				{
					return null;
				}
				return value;
			}
		}

		public WaypointRegionPolygon? WaypointRegionPolygon
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<WaypointRegionPolygon>(_entity, out WaypointRegionPolygon value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<Rotation>(_entity, out Rotation value))
				{
					return null;
				}
				return value;
			}
		}

		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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<Translation>(_entity, out Translation value))
				{
					return null;
				}
				return value;
			}
		}

		public LocalTransform? LocalTransform
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<LocalTransform>(_entity, out LocalTransform value))
				{
					return null;
				}
				return value;
			}
		}

		public PreviousParent? PreviousParent
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<PreviousParent>(_entity, out PreviousParent value))
				{
					return null;
				}
				return value;
			}
		}

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

		public WorldRegionPolygon? WorldRegionPolygon
		{
			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_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!_world.EntityManager.TryGetComponentDataInternal<WorldRegionPolygon>(_entity, out WorldRegionPolygon value))
				{
					return null;
				}
				return value;
			}
		}

		publi