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;

[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[] Items { get; set; }
}
public class SharedPlayerData
{
	public static ulong SteamId { get; set; }
}
public class Library : MelonMod
{
	public async void SetSceneData()
	{
		_ = LevelGenerator.Instance;
		while ((Object)(object)LevelGenerator.Instance == (Object)null)
		{
			await Task.Delay(100);
			_ = LevelGenerator.Instance;
		}
		while (!LevelGenerator.Instance.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)
			{
				GameObject gameObject = ((Component)item2).gameObject;
				list.Add(gameObject);
			}
			SetEnemies(list.ToArray());
		}
		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);
		}
		SetInGame(value: true);
	}

	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))
		{
			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 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 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 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 bool IsMultiplayer()
	{
		return SemiFunc.IsMultiplayer();
	}

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

	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 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 SpawnItem(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 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();
		foreach (GameObject obj in array)
		{
			LineRenderer component = obj.GetComponent<LineRenderer>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			TextMesh componentInChildren = obj.GetComponentInChildren<TextMesh>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)componentInChildren).gameObject);
			}
		}
	}

	public void ClearItemLines()
	{
		GameObject[] items = GetItems();
		foreach (GameObject obj in items)
		{
			LineRenderer component = obj.GetComponent<LineRenderer>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			TextMesh componentInChildren = obj.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);
	}
}