using System;
using System.Collections;
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.Threading.Tasks;
using MelonLoader;
using Photon.Pun;
using Repo_Library;
using Steamworks;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Library), "R.E.P.O Mod Library", "1.0.0", "Lillious & .Zer0", null)]
[assembly: MelonGame("semiwork", "REPO")]
[assembly: AssemblyTitle("(Official) R.E.P.O Mod Library")]
[assembly: AssemblyDescription("The official mod library for the game R.E.P.O")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("(Official) R.E.P.O Mod Library")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("1b092381-d16a-418d-8cfe-b28db50bfeb0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Repo_Library;

public class SharedSceneData
{
	public static List<Level> Levels = new List<Level>();

	public static List<Level> Menus = new List<Level>();

	public static bool IsInMainMenu { get; set; }

	public static bool IsInitialized { get; set; }

	public static bool IsInLobby { get; set; }

	public static bool IsInGame { get; set; }

	public static bool IsInShop { get; set; }

	public static bool IsInArena { get; set; }

	public static bool IsInTruckLobby { get; set; }

	public static GameObject Map { get; set; }

	public static GameObject[] Enemies { get; set; }

	public static GameObject[] DeadEnemies { get; set; }

	public static GameObject[] Items { get; set; }

	public static GameObject[] DestroyedItems { get; set; }
}
public class SharedPlayerData
{
	public static ulong SteamId { get; set; }
}
[Serializable]
public class GameObjectEvent : UnityEvent<string>
{
}
public class Library : MelonMod
{
	public class SharedGameData
	{
		public static GameObject[] EnemyData { get; set; }

		public static GameObject[] TrackedEnemies { get; set; }
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass11_0
	{
		public GameObject enemy;

		internal bool <MonitorEnemies>b__0(GameObject val)
		{
			return (Object)(object)val != (Object)(object)enemy;
		}
	}

	[CompilerGenerated]
	private sealed class <MonitorEnemies>d__11 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public List<GameObject> enemyList;

		public Library <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <MonitorEnemies>d__11(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected O, but got Unknown
			int num = <>1__state;
			Library library = <>4__this;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
				if (enemyList == null || enemyList.Count == 0)
				{
					return false;
				}
			}
			using (List<GameObject>.Enumerator enumerator = enemyList.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					<>c__DisplayClass11_0 CS$<>8__locals0 = new <>c__DisplayClass11_0
					{
						enemy = enumerator.Current
					};
					if ((Object)(object)CS$<>8__locals0.enemy == (Object)null)
					{
						continue;
					}
					GameObject enemy = CS$<>8__locals0.enemy;
					object obj;
					if (enemy == null)
					{
						obj = null;
					}
					else
					{
						Transform obj2 = enemy.transform.Find("Enable");
						obj = ((obj2 != null) ? ((Component)obj2).gameObject : null);
					}
					object obj3;
					if (obj == null)
					{
						obj3 = null;
					}
					else
					{
						Transform obj4 = ((GameObject)obj).transform.Find("Controller");
						obj3 = ((obj4 != null) ? ((Component)obj4).gameObject : null);
					}
					EnemyHealth val2 = ((obj3 != null) ? ((GameObject)obj3).GetComponent<EnemyHealth>() : null);
					if (!((Object)(object)val2 != (Object)null))
					{
						continue;
					}
					FieldInfo fieldInfo = typeof(EnemyHealth)?.GetField("dead", BindingFlags.Instance | BindingFlags.NonPublic);
					if (!(fieldInfo != null))
					{
						continue;
					}
					if ((bool)fieldInfo.GetValue(val2))
					{
						if (!library.GetDeadEnemies().Contains(CS$<>8__locals0.enemy))
						{
							SharedSceneData.DeadEnemies = SharedSceneData.DeadEnemies.Append(CS$<>8__locals0.enemy).ToArray();
							Library.OnEnemyDeath?.Invoke(CS$<>8__locals0.enemy);
						}
					}
					else
					{
						SharedSceneData.DeadEnemies = SharedSceneData.DeadEnemies.Where((GameObject val) => (Object)(object)val != (Object)(object)CS$<>8__locals0.enemy).ToArray();
					}
				}
			}
			<>2__current = (object)new WaitForSeconds(0.1f);
			<>1__state = 1;
			return true;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <MonitorItems>d__10 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject[] items;

		private Dictionary<GameObject, (string name, float lastValue)> <itemData>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <MonitorItems>d__10(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<itemData>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				if (items == null || items.Length == 0)
				{
					return false;
				}
				<itemData>5__2 = new Dictionary<GameObject, (string, float)>();
				GameObject[] array = items;
				foreach (GameObject val in array)
				{
					if ((Object)(object)val != (Object)null)
					{
						float dollarValueCurrent = val.GetComponent<ValuableObject>().dollarValueCurrent;
						<itemData>5__2[val] = (((Object)val).name, dollarValueCurrent);
					}
				}
				break;
			}
			case 1:
				<>1__state = -1;
				break;
			}
			if (<itemData>5__2.Count > 0)
			{
				List<GameObject> list = new List<GameObject>();
				List<GameObject> list2 = new List<GameObject>();
				foreach (KeyValuePair<GameObject, (string, float)> item in <itemData>5__2.ToList())
				{
					GameObject key = item.Key;
					if ((Object)(object)key == (Object)null)
					{
						list.Add(item.Key);
					}
					else if (!Mathf.Approximately(key.GetComponent<ValuableObject>().dollarValueCurrent, item.Value.Item2))
					{
						list2.Add(key);
					}
				}
				foreach (GameObject item2 in list2)
				{
					Library.OnItemDamaged?.Invoke(item2);
					<itemData>5__2[item2] = (<itemData>5__2[item2].name, item2.GetComponent<ValuableObject>().dollarValueCurrent);
				}
				foreach (GameObject item3 in list)
				{
					Library.OnItemDestroyed?.Invoke(item3);
					<itemData>5__2.Remove(item3);
				}
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public static event Action<GameObject> OnEnemyDeath;

	public static event Action<GameObject> OnItemDestroyed;

	public static event Action<GameObject> OnItemDamaged;

	public async void SetSceneData()
	{
		LevelGenerator levelGenerator = LevelGenerator.Instance;
		while ((Object)(object)LevelGenerator.Instance == (Object)null)
		{
			await Task.Delay(100);
			levelGenerator = LevelGenerator.Instance;
		}
		while (!levelGenerator.Generated)
		{
			await Task.Delay(100);
		}
		Transform obj = GameObject.Find("Level Generator").transform.Find("Enemies");
		GameObject val2 = ((obj != null) ? ((Component)obj).gameObject : null);
		if ((Object)(object)val2 == (Object)null)
		{
			MelonLogger.Msg("Unable to locate Enemies");
		}
		else
		{
			List<GameObject> list = new List<GameObject>();
			foreach (Transform item2 in val2.transform)
			{
				Transform val3 = item2;
				object obj2;
				if (val3 == null)
				{
					obj2 = null;
				}
				else
				{
					Transform obj3 = ((Component)val3).transform.Find("Enable");
					obj2 = ((obj3 != null) ? ((Component)obj3).gameObject : null);
				}
				object obj4;
				if (obj2 == null)
				{
					obj4 = null;
				}
				else
				{
					Transform obj5 = ((GameObject)obj2).transform.Find("Controller");
					obj4 = ((obj5 != null) ? ((Component)obj5).gameObject : null);
				}
				EnemyHealth obj6 = ((obj4 != null) ? ((GameObject)obj4).GetComponent<EnemyHealth>() : null);
				GameObject gameObject = ((Component)val3).gameObject;
				if ((Object)(object)obj6 != (Object)null)
				{
					list.Add(gameObject);
				}
			}
			SetEnemies(list.ToArray());
			SetDeadEnemies((GameObject[])(object)new GameObject[0]);
			MelonCoroutines.Start(MonitorEnemies(list));
		}
		GameObject[] array = GameObject.FindGameObjectsWithTag("Phys Grab Object");
		if (array == null || array.Length == 0)
		{
			MelonLogger.Msg("Unable to locate items");
		}
		else
		{
			GameObject[] array2 = array;
			foreach (GameObject item in array2)
			{
				if ((Object)(object)item.GetComponent<ValuableObject>() == (Object)null)
				{
					array = array.Where((GameObject val) => (Object)(object)val != (Object)(object)item).ToArray();
				}
			}
			SetItems(array);
			SetDestroyedItems((GameObject[])(object)new GameObject[0]);
			MelonCoroutines.Start(MonitorItems(array));
		}
		SetInGame(value: true);
	}

	[IteratorStateMachine(typeof(<MonitorItems>d__10))]
	private IEnumerator MonitorItems(GameObject[] items)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <MonitorItems>d__10(0)
		{
			items = items
		};
	}

	[IteratorStateMachine(typeof(<MonitorEnemies>d__11))]
	private IEnumerator MonitorEnemies(List<GameObject> enemyList)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <MonitorEnemies>d__11(0)
		{
			<>4__this = this,
			enemyList = enemyList
		};
	}

	public override void OnSceneWasInitialized(int buildIndex, string sceneName)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		RunManager instance = RunManager.instance;
		if (!IsInitialized())
		{
			SetSteamId(SteamId.op_Implicit(SteamClient.SteamId));
			SetInititialized(value: true);
			SetLevels(instance.levels);
			SetMenuLevels(new List<Level> { instance.levelMainMenu, instance.levelLobbyMenu });
		}
		if ((Object)(object)instance.levelCurrent == (Object)(object)instance.levelMainMenu)
		{
			SetInMainMenu(value: true);
		}
		else
		{
			SetInMainMenu(value: false);
		}
		if ((Object)(object)instance.levelCurrent == (Object)(object)instance.levelLobbyMenu || Object.op_Implicit((Object)(object)instance.levelCurrent))
		{
			SetInLobby(value: true);
		}
		else
		{
			SetInLobby(value: false);
		}
		if ((Object)(object)instance.levelCurrent == (Object)(object)instance.levelShop)
		{
			SetInShop(value: true);
		}
		else
		{
			SetInShop(value: false);
		}
		if ((Object)(object)instance.levelCurrent == (Object)(object)instance.levelArena)
		{
			SetInArena(value: true);
		}
		else
		{
			SetInArena(value: false);
		}
		if ((Object)(object)instance.levelCurrent == (Object)(object)instance.levelLobby)
		{
			SetInTruckLobby(value: true);
		}
		else
		{
			SetInTruckLobby(value: false);
		}
		if (!SharedSceneData.Menus.Contains(instance.levelCurrent) && sceneName != "Reload")
		{
			SetSceneData();
		}
		else
		{
			SetInGame(value: false);
		}
	}

	public void SetSteamId(ulong steamId)
	{
		SharedPlayerData.SteamId = steamId;
	}

	public void SetInititialized(bool value)
	{
		SharedSceneData.IsInitialized = value;
	}

	public void SetInMainMenu(bool value)
	{
		SharedSceneData.IsInMainMenu = value;
	}

	public void SetInLobby(bool value)
	{
		SharedSceneData.IsInLobby = value;
	}

	public void SetInShop(bool value)
	{
		SharedSceneData.IsInShop = value;
	}

	public void SetInArena(bool value)
	{
		SharedSceneData.IsInArena = value;
	}

	public void SetInTruckLobby(bool value)
	{
		SharedSceneData.IsInTruckLobby = value;
	}

	public void SetLevels(List<Level> levels)
	{
		SharedSceneData.Levels = levels;
	}

	public void SetMenuLevels(List<Level> levels)
	{
		SharedSceneData.Menus = levels;
	}

	public void SetInGame(bool value)
	{
		SharedSceneData.IsInGame = value;
	}

	public void SetEnemies(GameObject[] enemies)
	{
		SharedSceneData.Enemies = enemies;
	}

	public void SetDeadEnemies(GameObject[] enemies)
	{
		SharedSceneData.DeadEnemies = enemies;
	}

	public void SetDestroyedItems(GameObject[] items)
	{
		SharedSceneData.DestroyedItems = items;
	}

	public void SetItems(GameObject[] items)
	{
		SharedSceneData.Items = items;
	}

	public async void SetDisableItemDurability()
	{
		await Task.Delay(5000);
		DisableItemsDurability(disable: true);
	}

	public async void SetEnableItemDurability()
	{
		await Task.Delay(5000);
		DisableItemsDurability(disable: false);
	}

	public ulong GetSteamId()
	{
		return SharedPlayerData.SteamId;
	}

	public bool IsInitialized()
	{
		return SharedSceneData.IsInitialized;
	}

	public bool IsInMainMenu()
	{
		return SharedSceneData.IsInMainMenu;
	}

	public bool IsInLobby()
	{
		return SharedSceneData.IsInLobby;
	}

	public List<Level> GetLevels()
	{
		return SharedSceneData.Levels;
	}

	public bool IsInGame()
	{
		return SharedSceneData.IsInGame;
	}

	public bool IsInShop()
	{
		return SharedSceneData.IsInShop;
	}

	public bool IsInArena()
	{
		return SharedSceneData.IsInArena;
	}

	public bool IsInTruckLobby()
	{
		return SharedSceneData.IsInTruckLobby;
	}

	public List<Level> GetMenuLevels()
	{
		return SharedSceneData.Menus;
	}

	public PlayerController GetPlayerController()
	{
		return PlayerController.instance;
	}

	public GameObject GetPlayerControllerObject()
	{
		return ((Component)GameObject.Find("Player").transform.Find("Controller")).gameObject;
	}

	public PlayerCollision GetPlayerCollision()
	{
		return PlayerCollision.instance;
	}

	public StatsManager GetStatsManager()
	{
		return StatsManager.instance;
	}

	public RunManager GetRunManager()
	{
		return RunManager.instance;
	}

	public GraphicsManager GetGraphicsManager()
	{
		return GraphicsManager.instance;
	}

	public GameplayManager GetGameplayManager()
	{
		return GameplayManager.instance;
	}

	public AssetManager GetAssetManager()
	{
		return AssetManager.instance;
	}

	public AudioManager GetAudioManager()
	{
		return AudioManager.instance;
	}

	public NetworkManager GetNetworkManager()
	{
		return NetworkManager.instance;
	}

	public GameObject GetMapObject()
	{
		return SharedSceneData.Map;
	}

	public Map GetMap()
	{
		return Map.Instance;
	}

	public LevelGenerator GetLevelGenerator()
	{
		return LevelGenerator.Instance;
	}

	public GameDirector GetGameDirector()
	{
		return GameDirector.instance;
	}

	public PostProcessing GetPostProcessing()
	{
		return PostProcessing.Instance;
	}

	public PlayerAvatar GetPlayerAvatar()
	{
		return PlayerAvatar.instance;
	}

	public int GetEnemyCount()
	{
		return GetEnemies().ToArray().Length;
	}

	public GameObject[] GetEnemies()
	{
		return SharedSceneData.Enemies;
	}

	public GameObject[] GetDeadEnemies()
	{
		return SharedSceneData.DeadEnemies;
	}

	public RecordingDirector GetRecordingDirector()
	{
		return RecordingDirector.instance;
	}

	public ReverbDirector GetReverbDirector()
	{
		return ReverbDirector.instance;
	}

	public PunManager GetPunManager()
	{
		return PunManager.instance;
	}

	public PlayerVoice GetPlayerVoice()
	{
		return PlayerVoice.Instance;
	}

	public PlayerVoiceChat GetPlayerVoiceChat()
	{
		return PlayerVoiceChat.instance;
	}

	public RoundDirector GetRoundDirector()
	{
		return RoundDirector.instance;
	}

	public ShopManager GetShopManager()
	{
		return ShopManager.instance;
	}

	public SpectateCamera GetSpectateCamera()
	{
		return SpectateCamera.instance;
	}

	public ValuableDirector GetValuableDirector()
	{
		return ValuableDirector.instance;
	}

	public WindowManager GetWindowManager()
	{
		return WindowManager.instance;
	}

	public MenuController GetMenuController()
	{
		return MenuController.instance;
	}

	public LightManager GetLightManager()
	{
		return LightManager.instance;
	}

	public void FreezeEnemies(bool freeze)
	{
		GameObject[] enemies = GetEnemies();
		for (int i = 0; i < enemies.Length; i++)
		{
			Transform obj = enemies[i].transform.Find("Enable");
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				Transform obj3 = ((Component)obj).gameObject.transform.Find("Controller");
				obj2 = ((obj3 != null) ? ((Component)obj3).gameObject : null);
			}
			((GameObject)obj2).SetActive(freeze);
		}
	}

	public void UpgradePlayerEnergy()
	{
		PunManager.instance.UpgradePlayerEnergy(GetSteamId().ToString());
	}

	public void UpgradePlayerJump()
	{
		PunManager.instance.UpgradePlayerExtraJump(GetSteamId().ToString());
	}

	public void UpgradePlayerGrabRange()
	{
		PunManager.instance.UpgradePlayerGrabRange(GetSteamId().ToString());
	}

	public void UpgradePlayerGrabStrengthNonHost()
	{
		StatsManager.instance.playerUpgradeStrength[SemiFunc.PlayerGetSteamID(PlayerAvatar.instance)]++;
	}

	public void UpgradePlayerGrabStrength()
	{
		PunManager.instance.UpgradePlayerGrabStrength(GetSteamId().ToString());
	}

	public void UpgradePlayerHealth()
	{
		PunManager.instance.UpgradePlayerHealth(GetSteamId().ToString());
	}

	public void RespawnPlayer(PlayerController playerController)
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		Vector3 position = default(Vector3);
		((Vector3)(ref position))..ctor(0f, 0f, -21f);
		if (!((Object)(object)playerController == (Object)null))
		{
			((Component)playerController).gameObject.transform.position = position;
		}
	}

	public void UpgradePlayerSprintSpeed()
	{
		PunManager.instance.UpgradePlayerSprintSpeed(GetSteamId().ToString());
	}

	public void UpgradePlayerThrowStrength()
	{
		PunManager.instance.UpgradePlayerThrowStrength(GetSteamId().ToString());
	}

	public void UpgradePlayerTumbleLaunch()
	{
		PunManager.instance.UpgradePlayerTumbleLaunch(GetSteamId().ToString());
	}

	public void UpgradeItemBattery(GameObject item)
	{
		PunManager.instance.UpgradeItemBattery(((Object)item).name);
	}

	public void UpgradeMapPlayerCount()
	{
		PunManager.instance.UpgradeMapPlayerCount(GetSteamId().ToString());
	}

	public void TeleportPlayer(PlayerController playerController, Vector3 position)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)playerController == (Object)null))
		{
			((Component)playerController).gameObject.transform.position = position;
		}
	}

	public void SetPlayerCurrentEnergy(PlayerController playerController, float energy)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.EnergyCurrent = energy;
		}
	}

	public void SetPlayerMaxEnergy(PlayerController playerController, float energy)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.EnergyStart = energy;
		}
	}

	public void SetSprintEnergyDrain(PlayerController playerController, float energy)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.EnergySprintDrain = energy;
		}
	}

	public float GetPlayerMaxEnergy(PlayerController playerController)
	{
		if ((Object)(object)playerController == (Object)null)
		{
			return 0f;
		}
		return playerController.EnergyStart;
	}

	public void AntiGravity(PlayerController playerController, float time)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.AntiGravity(time);
		}
	}

	public void SetCrouchSpeed(PlayerController playerController, float speed)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.CrouchSpeed = speed;
		}
	}

	public float GetMovementSpeed(PlayerController playerController)
	{
		if ((Object)(object)playerController == (Object)null)
		{
			return 0f;
		}
		return playerController.MoveSpeed;
	}

	public void SetMovementSpeed(PlayerController playerController, float speed)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.MoveSpeed = speed;
		}
	}

	public float GetSprintSpeed(PlayerController playerController)
	{
		if ((Object)(object)playerController == (Object)null)
		{
			return 0f;
		}
		return playerController.SprintSpeed;
	}

	public void SetSprintSpeed(PlayerController playerController, float speed)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.SprintSpeed = speed;
		}
	}

	public bool IsSprinting(PlayerController playerController)
	{
		if ((Object)(object)playerController == (Object)null)
		{
			return false;
		}
		return playerController.sprinting;
	}

	public void SetSprinting(PlayerController playerController, bool value)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.sprinting = value;
		}
	}

	public void SetSpeedUpgradeAmounts(PlayerController playerController, int amount)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.SprintSpeedUpgrades = amount;
		}
	}

	public float GetCustomGravity(PlayerController playerController)
	{
		if ((Object)(object)playerController == (Object)null)
		{
			return 0f;
		}
		return playerController.CustomGravity;
	}

	public void SetCustomGravity(PlayerController playerController, float gravity)
	{
		if (!((Object)(object)playerController == (Object)null))
		{
			playerController.CustomGravity = gravity;
		}
	}

	public void SpawnEnemy(Enemy enemy)
	{
		SemiFunc.EnemySpawn(enemy);
	}

	public void KillPlayer(PlayerAvatar playerAvatar)
	{
		playerAvatar.PlayerDeath(0);
	}

	public void KillAllPlayers()
	{
		PlayerAvatar[] array = GetAllPlayers().ToArray();
		for (int i = 0; i < array.Length; i++)
		{
			array[i].PlayerDeath(0);
		}
	}

	public void RevivePlayer(PlayerAvatar playerAvatar)
	{
		playerAvatar.Revive(false);
	}

	public void ReviveAllPlayers()
	{
		PlayerAvatar[] array = GetAllPlayers().ToArray();
		for (int i = 0; i < array.Length; i++)
		{
			array[i].Revive(false);
		}
	}

	public void SendMessage(PlayerAvatar playerAvatar, string message)
	{
		playerAvatar.ChatMessageSend(message, false);
	}

	public bool IsMultiplayer()
	{
		return SemiFunc.IsMultiplayer();
	}

	public bool IsMasterClient()
	{
		return PhotonNetwork.IsMasterClient;
	}

	public void PlayerTumble(PlayerAvatar playerAvatar)
	{
		playerAvatar.tumble.TumbleSet(true, false);
	}

	public void PlayerTumbleAll()
	{
		PlayerAvatar[] array = GetAllPlayers().ToArray();
		for (int i = 0; i < array.Length; i++)
		{
			array[i].tumble.TumbleSet(true, false);
		}
	}

	public List<PlayerAvatar> GetAllPlayers()
	{
		return SemiFunc.PlayerGetAll();
	}

	public int GetPlayerCount()
	{
		return GetAllPlayers().ToArray().Length;
	}

	public PlayerAvatar GetPlayerBySteamId(string steamId)
	{
		return SemiFunc.PlayerGetFromSteamID(steamId);
	}

	public PlayerAvatar GetPlayerByName(string name)
	{
		return SemiFunc.PlayerGetFromName(name);
	}

	public string GetPlayerSteamId(PlayerAvatar player)
	{
		return SemiFunc.PlayerGetSteamID(player);
	}

	public bool AreAllPlayersInTruck()
	{
		return SemiFunc.PlayersAllInTruck();
	}

	public void DisableEnemies(bool disable)
	{
		GameObject[] array = GetEnemies().ToArray();
		for (int i = 0; i < array.Length; i++)
		{
			Transform obj = array[i].transform.Find("Enable");
			((obj != null) ? ((Component)obj).gameObject : null).SetActive(!disable);
		}
	}

	public GameObject[] GetItems()
	{
		return SharedSceneData.Items;
	}

	public GameObject[] GetDestroyedItems()
	{
		return SharedSceneData.DestroyedItems;
	}

	public void DisableItemsDurability(bool disable)
	{
		GameObject[] array = GetItems().ToArray();
		foreach (GameObject obj in array)
		{
			PhysGrabObjectImpactDetector val = ((obj != null) ? obj.GetComponent<PhysGrabObjectImpactDetector>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((Behaviour)val).enabled = !disable;
			}
		}
	}

	public GameObject GetPlayerAvatarObject()
	{
		return ((Component)GameObject.Find("PlayerAvatar(Clone)").transform.Find("Player Avatar Controller")).gameObject;
	}

	public void SetGodMode(bool on)
	{
		typeof(PlayerHealth).GetField("godMode", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(GetPlayerAvatar().playerHealth, on);
	}

	public void SetCurrency(int currency)
	{
		StatsManager.instance.runStats["currency"] = currency;
	}

	public int GetPlayerMaxHealth()
	{
		return 100 + StatsManager.instance.GetPlayerMaxHealth(SemiFunc.PlayerGetSteamID(PlayerAvatar.instance));
	}

	public int GetPlayerHealth()
	{
		return StatsManager.instance.GetPlayerHealth(SemiFunc.PlayerGetSteamID(PlayerAvatar.instance));
	}

	public void HealPlayer(GameObject playerAvatar, int health)
	{
		playerAvatar.GetComponent<PlayerHealth>().Heal(health, true);
	}

	public void HealPlayerMax(GameObject playerAvatar)
	{
		playerAvatar.GetComponent<PlayerHealth>().Heal(GetPlayerMaxHealth(), true);
	}

	public void SetPlayerHealth(int health)
	{
		StatsManager.instance.SetPlayerHealth(SemiFunc.PlayerGetSteamID(PlayerAvatar.instance), health, false);
	}

	public void ResetStats()
	{
		StatsManager.instance.ResetAllStats();
	}

	public void BuyAllItems()
	{
		StatsManager.instance.BuyAllItems();
	}

	public void DamagePlayer(GameObject playerAvatar, int damage)
	{
		playerAvatar.GetComponent<PlayerHealth>().Hurt(damage, false, -1);
	}

	public void SaveGame(string filename)
	{
		StatsManager.instance.SaveGame(filename);
	}

	public void LoadGame(string filename)
	{
		StatsManager.instance.LoadGame(filename);
	}

	public void SetPlayerCrown(string steamId)
	{
		StatsManager.instance.UpdateCrown(steamId);
	}

	public Dictionary<string, int> GetPlayerUpgrades(string steamId)
	{
		return StatsManager.instance.FetchPlayerUpgrades(steamId);
	}

	public void AddItem(string item)
	{
		StatsManager.instance.ItemAdd(item, (ItemAttributes)null, -1);
	}

	public void SpawnValuable(GameObject item)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: 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_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		GameObject playerControllerObject = GetPlayerControllerObject();
		Vector3 val = playerControllerObject.transform.position + playerControllerObject.transform.forward * 2f + playerControllerObject.transform.up * 2f;
		if (!SemiFunc.IsMultiplayer())
		{
			Object.Instantiate<GameObject>(item, val, Quaternion.identity);
		}
		else
		{
			PhotonNetwork.InstantiateRoomObject("Valuables/" + ((Object)item).name, val, Quaternion.identity, (byte)0, (object[])null);
		}
	}

	public void SpawnItem(string name, Vector3 position)
	{
		//IL_002c: 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)
		if (IsMasterClient())
		{
			Dictionary<string, Item> itemDictionary = StatsManager.instance.itemDictionary;
			if (itemDictionary != null && itemDictionary.ContainsKey(name))
			{
				PhotonNetwork.InstantiateRoomObject("Items/" + name, position, Quaternion.identity, (byte)0, (object[])null);
			}
		}
	}

	public void DestroyObject()
	{
		GameObject playerControllerObject = GetPlayerControllerObject();
		Transform val = playerControllerObject.transform.Find("Hurt Collider");
		GameObject val2 = (Object.op_Implicit((Object)(object)val) ? ((Component)val).gameObject : null);
		if ((Object)(object)val2 == (Object)null)
		{
			GameObject obj = GameObject.Find("Debug");
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				Transform obj3 = obj.transform.Find("Debug Axel");
				obj2 = ((obj3 != null) ? ((Component)obj3).gameObject : null);
			}
			((GameObject)obj2).SetActive(true);
			Transform obj4 = ((GameObject)obj2).transform.Find("Debug Script");
			Transform obj5 = ((obj4 != null) ? ((Component)obj4).gameObject : null).transform.Find("Hurt Collider");
			val2 = Object.Instantiate<GameObject>((obj5 != null) ? ((Component)obj5).gameObject : null, playerControllerObject.transform);
			((Object)val2).name = "Hurt Collider";
			val2.SetActive(false);
			obj.SetActive(false);
		}
		val2.SetActive(true);
		DisableAfterTime(val2);
	}

	public async void DisableAfterTime(GameObject hurtCollider)
	{
		await Task.Delay(200);
		hurtCollider.SetActive(false);
	}

	public void DrawLineToEnemy()
	{
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		GameObject[] array = GetEnemies().ToArray();
		GameObject playerControllerObject = GetPlayerControllerObject();
		if (array == null || array.Length == 0)
		{
			return;
		}
		GameObject[] array2 = array;
		foreach (GameObject val in array2)
		{
			if (!((Object)(object)val == (Object)null))
			{
				LineRenderer val2 = val.GetComponent<LineRenderer>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val.AddComponent<LineRenderer>();
					ConfigureLineRenderer(val2, Color.red);
				}
				Transform obj = val.transform.Find("Enable");
				Transform val3 = ((obj != null) ? obj.Find("Controller") : null);
				if (!((Object)(object)val3 == (Object)null))
				{
					val2.SetPosition(0, playerControllerObject.transform.position + playerControllerObject.transform.up * 1f);
					val2.SetPosition(1, val3.position + val3.up * 1f);
					float distance = Vector3.Distance(playerControllerObject.transform.position, val3.position);
					UpdateDistanceText(val, distance, val3.position, playerControllerObject.transform, Color.red);
				}
			}
		}
	}

	public void DrawLineToItem()
	{
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		GameObject playerControllerObject = GetPlayerControllerObject();
		GameObject[] array = GetItems().ToArray();
		if (array == null || array.Length == 0)
		{
			return;
		}
		GameObject[] array2 = array;
		foreach (GameObject val in array2)
		{
			if (!((Object)(object)val == (Object)null))
			{
				LineRenderer val2 = val.GetComponent<LineRenderer>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val.AddComponent<LineRenderer>();
					ConfigureLineRenderer(val2, Color.yellow);
				}
				val2.SetPosition(0, playerControllerObject.transform.position + playerControllerObject.transform.up * 1f);
				val2.SetPosition(1, val.transform.position + val.transform.up * 1f);
				float distance = Vector3.Distance(playerControllerObject.transform.position, val.transform.position);
				UpdateDistanceText(val, distance, val.transform.position, playerControllerObject.transform, Color.yellow);
			}
		}
	}

	public void ClearEnemyLines()
	{
		GameObject[] array = GetEnemies().ToArray();
		if (array == null || array.Length == 0)
		{
			return;
		}
		GameObject[] array2 = array;
		foreach (GameObject val in array2)
		{
			if (!((Object)(object)val == (Object)null))
			{
				LineRenderer component = val.GetComponent<LineRenderer>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				TextMesh componentInChildren = val.GetComponentInChildren<TextMesh>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)componentInChildren).gameObject);
				}
			}
		}
	}

	public void ClearItemLines()
	{
		GameObject[] array = GetItems().ToArray();
		if (array == null || array.Length == 0)
		{
			return;
		}
		GameObject[] array2 = array;
		foreach (GameObject val in array2)
		{
			if (!((Object)(object)val == (Object)null))
			{
				LineRenderer component = val.GetComponent<LineRenderer>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				TextMesh componentInChildren = val.GetComponentInChildren<TextMesh>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)componentInChildren).gameObject);
				}
			}
		}
	}

	public void ConfigureLineRenderer(LineRenderer line, Color color)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		//IL_002c: 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)
		line.startWidth = 0.01f;
		line.endWidth = 0.01f;
		((Renderer)line).material = new Material(Shader.Find("Sprites/Default"));
		line.startColor = color;
		line.endColor = color;
		line.positionCount = 2;
	}

	public void UpdateDistanceText(GameObject enemy, float distance, Vector3 position, Transform playerTransform, Color color)
	{
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		TextMesh val = enemy.GetComponentInChildren<TextMesh>();
		if ((Object)(object)val == (Object)null)
		{
			GameObject val2 = new GameObject("DistanceText");
			val2.transform.SetParent(enemy.transform);
			val2.transform.localPosition = Vector3.up * 2f;
			val = val2.AddComponent<TextMesh>();
			val.fontSize = 14;
			val.characterSize = 0.1f;
			val.color = color;
			val.alignment = (TextAlignment)1;
			val.anchor = (TextAnchor)4;
		}
		val.fontSize = Mathf.Clamp(Mathf.RoundToInt(14f + distance * 0.2f), 14, 24);
		val.text = distance.ToString("F1") + "m";
		((Component)val).transform.position = position + Vector3.up * 2f;
		((Component)val).transform.LookAt(playerTransform);
		((Component)val).transform.Rotate(0f, 180f, 0f);
	}
}