using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using GameData;
using Gear;
using Hikaria.Core;
using Hikaria.Core.SNetworkExt;
using Hikaria.MapperTracker.Controllers;
using Hikaria.MapperTracker.Features;
using Hikaria.MapperTracker.Managers;
using Player;
using SNetwork;
using TheArchive.Core;
using TheArchive.Core.Attributes;
using TheArchive.Core.Attributes.Feature.Settings;
using TheArchive.Core.FeaturesAPI;
using TheArchive.Core.Localization;
using TheArchive.Core.Models;
using TheArchive.Interfaces;
using TheArchive.Loader;
using TheArchive.Utilities;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a7f94235-3ecf-4bde-a2a9-53159c691827")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Hikaria.MapperTracker
{
	[ArchiveDependency(/*Could not decode attribute arguments.*/)]
	[ArchiveModule("Hikaria.MapperTracker", "MapperTracker", "2.1.0")]
	public class EntryPoint : IArchiveModule
	{
		public static EntryPoint Instance { get; private set; }

		public bool ApplyHarmonyPatches => false;

		public bool UsesLegacyPatches => false;

		public ArchiveLegacyPatcher Patcher { get; set; }

		public string ModuleGroup => "Mapper Tracker";

		public Dictionary<Language, string> ModuleGroupLanguages => new Dictionary<Language, string>
		{
			{
				(Language)1,
				"地形映射生物追踪器"
			},
			{
				(Language)0,
				"Mapper Tracker"
			}
		};

		public void Init()
		{
			Instance = this;
			Logs.LogMessage("OK");
		}

		public void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
		}

		public void OnLateUpdate()
		{
		}

		public void OnExit()
		{
		}
	}
	internal static class Logs
	{
		private static IArchiveLogger _logger;

		private static IArchiveLogger Logger => _logger ?? (_logger = LoaderWrapper.CreateLoggerInstance("Hikaria.MapperTracker", ConsoleColor.White));

		public static void LogDebug(object data)
		{
			Logger.Debug(data.ToString());
		}

		public static void LogError(object data)
		{
			Logger.Error(data.ToString());
		}

		public static void LogInfo(object data)
		{
			Logger.Info(data.ToString());
		}

		public static void LogMessage(object data)
		{
			Logger.Msg(ConsoleColor.White, data.ToString());
		}

		public static void LogWarning(object data)
		{
			Logger.Warning(data.ToString());
		}

		public static void LogNotice(object data)
		{
			Logger.Notice(data.ToString());
		}

		public static void LogSuccess(object data)
		{
			Logger.Success(data.ToString());
		}

		public static void LogException(Exception ex)
		{
			Logger.Exception(ex);
		}
	}
	public class PluginInfo
	{
		public const string NAME = "MapperTracker";

		public const string GUID = "Hikaria.MapperTracker";

		public const string VERSION = "2.1.0";
	}
	public struct pMapperTrackerXRayStatus
	{
		public bool enabled;

		public bool focus;

		public pPlayer player;

		public pMapperTrackerXRayStatus(SNet_Player player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			this.player = default(pPlayer);
			((pPlayer)(ref this.player)).SetPlayer(player);
			enabled = false;
			focus = false;
		}
	}
	public struct pMapperTrackerXRayData
	{
		public pPlayer player;

		public float fieldOfView;

		public float fieldOfViewFocused;

		public float maxDistanceDefault;

		public float maxDistanceFocused;

		public int raysPerSecondDefault;

		public int raysPerSecondFocused;

		public pMapperTrackerXRayData(SNet_Player player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			this.player = default(pPlayer);
			((pPlayer)(ref this.player)).SetPlayer(player);
			fieldOfView = 65f;
			fieldOfViewFocused = 35f;
			maxDistanceDefault = 20f;
			maxDistanceFocused = 40f;
			raysPerSecondDefault = 75000;
			raysPerSecondFocused = 20000;
		}
	}
}
namespace Hikaria.MapperTracker.Managers
{
	internal class MapperTrackerManager
	{
		public static SNetExt_BroadcastAction<pMapperTrackerXRayData> s_MapperTrackerXRayDataAction;

		public static SNetExt_BroadcastAction<pMapperTrackerXRayStatus> s_MapperTrackerXRayStatusAction;

		public static Dictionary<ulong, MapperTrackerController> MapperTrackerControllerLookup = new Dictionary<ulong, MapperTrackerController>();

		public static Dictionary<int, MapperTrackerController> MapperTrackerXRaysInstanceIDLookup = new Dictionary<int, MapperTrackerController>();

		private static bool MapperTrackerListenerFilter(SNet_Player player)
		{
			//IL_0008: 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)
			return CoreAPI.IsPlayerInstalledMod(player, "Hikaria.MapperTracker", default(Version));
		}

		public static void Setup()
		{
			s_MapperTrackerXRayDataAction = SNetExt_BroadcastAction<pMapperTrackerXRayData>.Create(typeof(pMapperTrackerXRayData).FullName, (Action<ulong, pMapperTrackerXRayData>)ReceiveMapperXRayData, (Func<SNet_Player, bool>)MapperTrackerListenerFilter, (SNet_ChannelType)2);
			s_MapperTrackerXRayStatusAction = SNetExt_BroadcastAction<pMapperTrackerXRayStatus>.Create(typeof(pMapperTrackerXRayStatus).FullName, (Action<ulong, pMapperTrackerXRayStatus>)ReceiveMapperXRayStatus, (Func<SNet_Player, bool>)MapperTrackerListenerFilter, (SNet_ChannelType)2);
		}

		private static void ReceiveMapperXRayStatus(ulong sender, pMapperTrackerXRayStatus data)
		{
			SNet_Player val = default(SNet_Player);
			if (((pPlayer)(ref data.player)).TryGetPlayer(ref val) && val.Lookup == sender && MapperTrackerControllerLookup.TryGetValue(sender, out var value))
			{
				value.SyncSetXRayStatus(data);
			}
		}

		private static void ReceiveMapperXRayData(ulong sender, pMapperTrackerXRayData data)
		{
			SNet_Player val = default(SNet_Player);
			if (((pPlayer)(ref data.player)).TryGetPlayer(ref val) && val.Lookup == sender && MapperTrackerControllerLookup.TryGetValue(sender, out var value))
			{
				value.SyncSetXRayData(data);
			}
		}
	}
}
namespace Hikaria.MapperTracker.Features
{
	[DisallowInGameToggle]
	[DoNotSaveToConfig]
	[EnableFeatureByDefault]
	public class MapperTracker : Feature
	{
		public class MapperTrackerSettings
		{
			[FSHeader("常规设置", true)]
			[FSDisplayName("启用")]
			[FSDescription("仅本地启用与禁用")]
			public bool EnableMapperTracker { get; set; } = true;


			[FSDisplayName("切换按键")]
			public KeyCode ToggleKey { get; set; } = (KeyCode)120;


			[FSHeader("映射参数设置", true)]
			[FSDisplayName("默认扫描视野")]
			[FSDescription("同步")]
			public float FieldOfView { get; set; } = 65f;


			[FSDisplayName("聚焦扫描视野")]
			[FSDescription("同步")]
			public float FieldOfViewFocused { get; set; } = 35f;


			[FSDisplayName("默认扫描最大距离")]
			[FSDescription("同步")]
			public float MaxDistanceDefault { get; set; } = 20f;


			[FSDisplayName("聚焦扫描最大距离")]
			[FSDescription("同步")]
			public float MaxDistanceFocused { get; set; } = 40f;


			[FSDisplayName("默认X-Ray每秒更新数量")]
			public int RaysPerSecondDefault { get; set; } = 120000;


			[FSDisplayName("聚焦X-Ray每秒更新数量")]
			public int RaysPerSecondFocused { get; set; } = 120000;


			[FSHeader("映射颜色与大小设置", true)]
			[FSDisplayName("地形颜色")]
			public SColor DefaultColor { get; set; } = new SColor(0f, 1f, 0.9709f, (float?)0.1608f);


			[FSDisplayName("地形大小")]
			public float DefaultSize { get; set; } = 0.5f;


			[FSDisplayName("敌人颜色")]
			public SColor EnemyColor { get; set; } = new SColor(1f, 0f, 0f, (float?)0.502f);


			[FSDisplayName("敌人大小")]
			public float EnemySize { get; set; } = 1f;


			[FSDisplayName("可交互物品颜色")]
			public SColor InteractionColor { get; set; } = new SColor(1f, 0.4911f, 0f, (float?)0.0784f);


			[FSDisplayName("可交互物品大小")]
			public float InteractionSize { get; set; } = 1f;

		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class XRayRenderer__ctor__Patch
		{
			private static void Postfix(XRayRenderer __instance)
			{
				__instance.instanceCount = 60000;
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class XRays__Update__Patch
		{
			private static bool Prefix(XRays __instance)
			{
				try
				{
					int num = Mathf.CeilToInt((float)__instance.raysPerSecond * Mathf.Min(0.05f, Time.deltaTime));
					__instance.Cast(num);
					__instance.m_renderer.range = __instance.maxDistance;
					if (MapperTrackerManager.MapperTrackerXRaysInstanceIDLookup.TryGetValue(((Object)__instance).GetInstanceID(), out var value))
					{
						__instance.m_renderer.mode = (value.IsSyncFocused ? 1 : 0);
					}
					return false;
				}
				catch
				{
					return false;
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class EnemyScanner__OnWield__Patch
		{
			private static void Postfix(EnemyScanner __instance)
			{
				if (!((Object)(object)__instance == (Object)null))
				{
					GameObject gameObject = ((Component)__instance).gameObject;
					MapperTrackerController mapperTrackerController = gameObject.GetComponent<MapperTrackerController>();
					if ((Object)(object)mapperTrackerController == (Object)null)
					{
						mapperTrackerController = gameObject.AddComponent<MapperTrackerController>();
						mapperTrackerController.Setup((ItemEquippable)(object)__instance, ((Item)__instance).Owner);
					}
					mapperTrackerController.OnWield();
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class EnemyScanner__OnUnWield__Patch
		{
			private static void Prefix(EnemyScanner __instance)
			{
				MapperTrackerController component = ((Component)__instance).gameObject.GetComponent<MapperTrackerController>();
				if ((Object)(object)component != (Object)null)
				{
					component.OnUnWield();
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class PlayerInventorySynced__SyncWieldItem__Patch
		{
			private static void Prefix(PlayerInventorySynced __instance, ItemEquippable item)
			{
				if (!((Object)(object)item == (Object)null) && !((PlayerInventoryBase)__instance).Owner.Owner.IsLocal && !((Object)(object)((PlayerInventoryBase)__instance).WieldedItem == (Object)null))
				{
					MapperTrackerController component = ((Component)((PlayerInventoryBase)__instance).WieldedItem).gameObject.GetComponent<MapperTrackerController>();
					if (!CanDoMapper(item) && (Object)(object)component != (Object)null)
					{
						component.OnUnWield();
					}
				}
			}

			private static void Postfix(PlayerInventorySynced __instance, ItemEquippable item)
			{
				if (!((Object)(object)item == (Object)null) && !((PlayerInventoryBase)__instance).Owner.Owner.IsLocal && CanDoMapper(item))
				{
					GameObject gameObject = ((Component)item).gameObject;
					MapperTrackerController mapperTrackerController = gameObject.GetComponent<MapperTrackerController>();
					if ((Object)(object)mapperTrackerController == (Object)null)
					{
						mapperTrackerController = gameObject.AddComponent<MapperTrackerController>();
					}
					mapperTrackerController.Setup(item, ((PlayerInventoryBase)__instance).Owner);
					mapperTrackerController.OnWield();
				}
			}
		}

		public override string Name => "地形映射生物追踪器";

		public override bool InlineSettingsIntoParentMenu => true;

		public static IArchiveLogger FeatureLogger { get; set; }

		[FeatureConfig]
		public static MapperTrackerSettings Settings { get; set; }

		public override void Init()
		{
			ClassInjector.RegisterTypeInIl2Cpp<MapperTrackerController>(false);
			MapperTrackerManager.Setup();
		}

		private static bool CanDoMapper(ItemEquippable itemEquippable)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			if (((Item)itemEquippable).ItemDataBlock != null && (int)((Item)itemEquippable).ItemDataBlock.inventorySlot == 3)
			{
				return ((GameDataBlockBase<GearCategoryDataBlock>)(object)itemEquippable.GearCategoryData).persistentID == 9;
			}
			return false;
		}
	}
}
namespace Hikaria.MapperTracker.Controllers
{
	public class MapperTrackerController : MonoBehaviour
	{
		public bool IsLocallyOwned;

		private ItemEquippable m_tool;

		private ulong OwnerLookup;

		private PlayerAgent m_owner;

		private pMapperTrackerXRayData m_mapperTrackerXRayDataSynced;

		private pMapperTrackerXRayStatus m_mapperTrackerXRayStatusSynced;

		public static KeyCode ToggleKey = (KeyCode)120;

		private XRays m_xRays;

		private bool m_isValid;

		private bool m_statusNeedSync;

		private bool m_statusNeedUpdate;

		private bool m_statusFocusChanged;

		public bool IsWielded => m_tool.m_isWielded;

		public bool IsLocalFireButtomHold => Input.GetKey((KeyCode)324);

		public bool IsSyncEnabled => m_mapperTrackerXRayStatusSynced.enabled;

		public bool IsSyncFocused => m_mapperTrackerXRayStatusSynced.focus;

		private bool IsXRayEnabled => ((Component)m_xRays).gameObject.active;

		public void Setup(ItemEquippable itemEquippable, PlayerAgent owner)
		{
			//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)
			m_tool = itemEquippable;
			m_xRays = ((Component)m_tool).GetComponentInChildren<XRays>(true);
			ToggleKey = Hikaria.MapperTracker.Features.MapperTracker.Settings.ToggleKey;
			m_owner = owner;
			m_isValid = (Object)(object)m_xRays != (Object)null && (Object)(object)m_owner != (Object)null && (Object)(object)m_owner.Owner != (Object)null;
			if (m_isValid)
			{
				IsLocallyOwned = m_owner.Owner.IsLocal;
				OwnerLookup = m_owner.Owner.Lookup;
				m_mapperTrackerXRayStatusSynced = new pMapperTrackerXRayStatus(m_owner.Owner);
				m_mapperTrackerXRayStatusSynced.enabled = false;
				m_mapperTrackerXRayStatusSynced.focus = false;
				m_mapperTrackerXRayDataSynced = new pMapperTrackerXRayData(m_owner.Owner);
				m_mapperTrackerXRayDataSynced.fieldOfView = Hikaria.MapperTracker.Features.MapperTracker.Settings.FieldOfView;
				m_mapperTrackerXRayDataSynced.fieldOfViewFocused = Hikaria.MapperTracker.Features.MapperTracker.Settings.FieldOfViewFocused;
				m_mapperTrackerXRayDataSynced.maxDistanceDefault = Hikaria.MapperTracker.Features.MapperTracker.Settings.MaxDistanceDefault;
				m_mapperTrackerXRayDataSynced.maxDistanceFocused = Hikaria.MapperTracker.Features.MapperTracker.Settings.MaxDistanceFocused;
				m_mapperTrackerXRayDataSynced.raysPerSecondDefault = Hikaria.MapperTracker.Features.MapperTracker.Settings.RaysPerSecondDefault;
				m_mapperTrackerXRayDataSynced.raysPerSecondFocused = Hikaria.MapperTracker.Features.MapperTracker.Settings.RaysPerSecondFocused;
				SetupXRays();
				MapperTrackerManager.MapperTrackerControllerLookup.TryAdd(OwnerLookup, this);
				MapperTrackerManager.MapperTrackerXRaysInstanceIDLookup.TryAdd(((Object)m_xRays).GetInstanceID(), this);
			}
		}

		public void SetupXRays()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00ce: 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)
			((Component)m_xRays).gameObject.active = false;
			m_xRays.fieldOfView = Hikaria.MapperTracker.Features.MapperTracker.Settings.FieldOfView;
			m_xRays.fieldOfViewFocused = Hikaria.MapperTracker.Features.MapperTracker.Settings.FieldOfViewFocused;
			m_xRays.maxDistance = Hikaria.MapperTracker.Features.MapperTracker.Settings.MaxDistanceDefault;
			m_xRays.raysPerSecond = Hikaria.MapperTracker.Features.MapperTracker.Settings.RaysPerSecondDefault;
			m_xRays.defaultColor = SColorExtensions.ToUnityColor(Hikaria.MapperTracker.Features.MapperTracker.Settings.DefaultColor);
			m_xRays.defaultSize = Hikaria.MapperTracker.Features.MapperTracker.Settings.DefaultSize;
			m_xRays.enemyColor = SColorExtensions.ToUnityColor(Hikaria.MapperTracker.Features.MapperTracker.Settings.EnemyColor);
			m_xRays.enemySize = Hikaria.MapperTracker.Features.MapperTracker.Settings.EnemySize;
			m_xRays.interactionColor = SColorExtensions.ToUnityColor(Hikaria.MapperTracker.Features.MapperTracker.Settings.InteractionColor);
			m_xRays.interactionSize = Hikaria.MapperTracker.Features.MapperTracker.Settings.InteractionSize;
			m_xRays.forwardStepSize = 2f;
			if ((Object)(object)m_xRays.m_renderer == (Object)null)
			{
				m_xRays.m_renderer = ((Component)m_xRays).gameObject.GetComponent<XRayRenderer>();
			}
		}

		public void UpdateXRaysStatus()
		{
			((Component)m_xRays).gameObject.active = m_mapperTrackerXRayStatusSynced.enabled;
			m_xRays.fieldOfView = (IsSyncFocused ? m_mapperTrackerXRayDataSynced.fieldOfViewFocused : m_mapperTrackerXRayDataSynced.fieldOfView);
			m_xRays.maxDistance = (IsSyncFocused ? m_mapperTrackerXRayDataSynced.maxDistanceFocused : m_mapperTrackerXRayDataSynced.maxDistanceDefault);
			m_xRays.raysPerSecond = (IsSyncFocused ? m_mapperTrackerXRayDataSynced.raysPerSecondFocused : m_mapperTrackerXRayDataSynced.raysPerSecondDefault);
			m_statusNeedUpdate = false;
		}

		public void UpdateXRaysData()
		{
			m_xRays.fieldOfView = (IsSyncFocused ? m_mapperTrackerXRayDataSynced.fieldOfViewFocused : m_mapperTrackerXRayDataSynced.fieldOfView);
			m_xRays.fieldOfViewFocused = m_mapperTrackerXRayDataSynced.fieldOfViewFocused;
			m_xRays.maxDistance = (IsSyncFocused ? m_mapperTrackerXRayDataSynced.maxDistanceFocused : m_mapperTrackerXRayDataSynced.maxDistanceDefault);
			m_xRays.raysPerSecond = (IsSyncFocused ? m_mapperTrackerXRayDataSynced.raysPerSecondFocused : m_mapperTrackerXRayDataSynced.raysPerSecondDefault);
		}

		private void OnDestroy()
		{
			MapperTrackerManager.MapperTrackerControllerLookup.Remove(OwnerLookup);
			MapperTrackerManager.MapperTrackerXRaysInstanceIDLookup.Remove(((Object)m_xRays).GetInstanceID());
		}

		public void OnWield()
		{
			if (m_isValid)
			{
				SetupXRays();
				((Behaviour)this).enabled = true;
				MapperTrackerManager.MapperTrackerControllerLookup.TryAdd(OwnerLookup, this);
				MapperTrackerManager.MapperTrackerXRaysInstanceIDLookup.TryAdd(((Object)m_xRays).GetInstanceID(), this);
				if (IsLocallyOwned)
				{
					SendMapperTrackerXRayStatus(enable: false, focus: false);
					SendMapperTrackerXRayData(Hikaria.MapperTracker.Features.MapperTracker.Settings.FieldOfView, Hikaria.MapperTracker.Features.MapperTracker.Settings.FieldOfViewFocused, Hikaria.MapperTracker.Features.MapperTracker.Settings.MaxDistanceDefault, Hikaria.MapperTracker.Features.MapperTracker.Settings.MaxDistanceFocused, Hikaria.MapperTracker.Features.MapperTracker.Settings.RaysPerSecondDefault, Hikaria.MapperTracker.Features.MapperTracker.Settings.RaysPerSecondFocused);
				}
			}
		}

		public void OnUnWield()
		{
			if (m_isValid)
			{
				((Component)m_xRays).gameObject.active = false;
				if (IsLocallyOwned)
				{
					SendMapperTrackerXRayStatus(enable: false, focus: false);
				}
			}
		}

		private void Update()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (m_isValid && IsWielded && IsLocallyOwned && Hikaria.MapperTracker.Features.MapperTracker.Settings.EnableMapperTracker)
			{
				if (IsSyncFocused != IsLocalFireButtomHold)
				{
					m_mapperTrackerXRayStatusSynced.focus = !m_mapperTrackerXRayStatusSynced.focus;
					m_statusNeedUpdate = true;
					m_statusNeedSync = true;
					m_statusFocusChanged = true;
				}
				if (Input.GetKeyDown(ToggleKey))
				{
					m_mapperTrackerXRayStatusSynced.enabled = !m_mapperTrackerXRayStatusSynced.enabled;
					m_statusNeedUpdate = true;
					m_statusNeedSync = true;
				}
			}
		}

		private void FixedUpdate()
		{
			if (m_isValid)
			{
				if (m_statusFocusChanged)
				{
					TryClearXRays();
					m_statusFocusChanged = false;
				}
				if (m_statusNeedUpdate)
				{
					UpdateXRaysStatus();
				}
				if (Hikaria.MapperTracker.Features.MapperTracker.Settings.EnableMapperTracker && IsLocallyOwned && m_statusNeedSync)
				{
					m_statusNeedSync = false;
					SendMapperTrackerXRayStatus(IsXRayEnabled, IsLocalFireButtomHold);
				}
			}
		}

		private void OnDisable()
		{
			SharedUtils.SafeDestroy((Component)(object)this);
		}

		private void TryClearXRays()
		{
			if ((Object)(object)m_xRays.m_renderer != (Object)null)
			{
				m_xRays.m_renderer.DeallocateResources();
			}
		}

		public void SendMapperTrackerXRayStatus(bool enable, bool focus)
		{
			m_mapperTrackerXRayStatusSynced.enabled = enable;
			m_mapperTrackerXRayStatusSynced.focus = focus;
			MapperTrackerManager.s_MapperTrackerXRayStatusAction.Do(m_mapperTrackerXRayStatusSynced);
		}

		public void SendMapperTrackerXRayData(float fov, float fovFocused, float maxDistanceDefault, float maxDistanceFocused, int raysPerSecondDefault, int raysPerSecondFocused)
		{
			m_mapperTrackerXRayDataSynced.fieldOfView = fov;
			m_mapperTrackerXRayDataSynced.fieldOfViewFocused = fovFocused;
			m_mapperTrackerXRayDataSynced.maxDistanceDefault = maxDistanceDefault;
			m_mapperTrackerXRayDataSynced.maxDistanceFocused = maxDistanceFocused;
			m_mapperTrackerXRayDataSynced.raysPerSecondDefault = raysPerSecondDefault;
			m_mapperTrackerXRayDataSynced.raysPerSecondFocused = raysPerSecondFocused;
			MapperTrackerManager.s_MapperTrackerXRayDataAction.Do(m_mapperTrackerXRayDataSynced);
		}

		public void SyncSetXRayStatus(pMapperTrackerXRayStatus data)
		{
			((Component)((Component)this).transform.parent).gameObject.SetActive(true);
			m_statusFocusChanged = m_mapperTrackerXRayStatusSynced.focus != data.focus;
			m_mapperTrackerXRayStatusSynced = data;
			m_statusNeedUpdate = true;
		}

		public void SyncSetXRayData(pMapperTrackerXRayData data)
		{
			m_mapperTrackerXRayDataSynced = data;
			UpdateXRaysData();
		}
	}
}