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 BepInEx;
using BepInEx.Unity.IL2CPP;
using GTFO.API;
using GameData;
using Gear;
using Player;
using SNetwork;
using TheArchive;
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: ModDefaultFeatureGroupName("MapperTracker")]
[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
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("Hikaria.MapperTracker", "MapperTracker", "2.0.2")]
public class EntryPoint : BasePlugin, 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 override void Load()
{
Instance = this;
ArchiveMod.RegisterArchiveModule(typeof(EntryPoint));
Logs.LogMessage("OK");
}
public void Init()
{
}
public void OnSceneWasLoaded(int buildIndex, string sceneName)
{
}
public void OnLateUpdate()
{
}
public void OnExit()
{
}
}
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;
}
}
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);
}
}
internal class PluginInfo
{
public const string NAME = "MapperTracker";
public const string GUID = "Hikaria.MapperTracker";
public const string VERSION = "2.0.2";
public const string AUTHOR = "Tuesday";
}
}
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; } = 50000;
[FSDisplayName("聚焦X-Ray每秒更新数量")]
public int RaysPerSecondFocused { get; set; } = 10000;
[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 = 100000;
}
}
[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 (MapperTrackerController.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 class MapperTrackerController : MonoBehaviour
{
public static Dictionary<ulong, MapperTrackerController> MapperTrackerControllerLookup = new Dictionary<ulong, MapperTrackerController>();
public static Dictionary<int, MapperTrackerController> MapperTrackerXRaysInstanceIDLookup = new Dictionary<int, MapperTrackerController>();
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)323);
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 = 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 = Settings.FieldOfView;
m_mapperTrackerXRayDataSynced.fieldOfViewFocused = Settings.FieldOfViewFocused;
m_mapperTrackerXRayDataSynced.maxDistanceDefault = Settings.MaxDistanceDefault;
m_mapperTrackerXRayDataSynced.maxDistanceFocused = Settings.MaxDistanceFocused;
m_mapperTrackerXRayDataSynced.raysPerSecondDefault = Settings.RaysPerSecondDefault;
m_mapperTrackerXRayDataSynced.raysPerSecondFocused = Settings.RaysPerSecondFocused;
SetupXRays();
MapperTrackerControllerLookup.TryAdd(OwnerLookup, this);
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 = Settings.FieldOfView;
m_xRays.fieldOfViewFocused = Settings.FieldOfViewFocused;
m_xRays.maxDistance = Settings.MaxDistanceDefault;
m_xRays.raysPerSecond = Settings.RaysPerSecondDefault;
m_xRays.defaultColor = SColorExtensions.ToUnityColor(Settings.DefaultColor);
m_xRays.defaultSize = Settings.DefaultSize;
m_xRays.enemyColor = SColorExtensions.ToUnityColor(Settings.EnemyColor);
m_xRays.enemySize = Settings.EnemySize;
m_xRays.interactionColor = SColorExtensions.ToUnityColor(Settings.InteractionColor);
m_xRays.interactionSize = 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()
{
MapperTrackerControllerLookup.Remove(OwnerLookup);
MapperTrackerXRaysInstanceIDLookup.Remove(((Object)m_xRays).GetInstanceID());
}
public void OnWield()
{
if (m_isValid)
{
SetupXRays();
((Behaviour)this).enabled = true;
MapperTrackerControllerLookup.TryAdd(OwnerLookup, this);
MapperTrackerXRaysInstanceIDLookup.TryAdd(((Object)m_xRays).GetInstanceID(), this);
if (IsLocallyOwned)
{
SendMapperTrackerXRayStatus(enable: false, focus: false);
SendMapperTrackerXRayData(Settings.FieldOfView, Settings.FieldOfViewFocused, Settings.MaxDistanceDefault, Settings.MaxDistanceFocused, Settings.RaysPerSecondDefault, 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 && 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 (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 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))
{
((Component)((Component)value).transform.parent).gameObject.SetActive(true);
value.m_statusFocusChanged = value.m_mapperTrackerXRayStatusSynced.focus != data.focus;
value.m_mapperTrackerXRayStatusSynced = data;
value.m_statusNeedUpdate = true;
value.m_statusFocusChanged = true;
}
}
public 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.m_mapperTrackerXRayDataSynced = data;
value.UpdateXRaysData();
}
}
public static void SendLocalData()
{
}
public void SendMapperTrackerXRayStatus(bool enable, bool focus)
{
m_mapperTrackerXRayStatusSynced.enabled = enable;
m_mapperTrackerXRayStatusSynced.focus = focus;
NetworkAPI.InvokeEvent<pMapperTrackerXRayStatus>(typeof(pMapperTrackerXRayStatus).FullName, m_mapperTrackerXRayStatusSynced, (SNet_ChannelType)4);
}
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;
NetworkAPI.InvokeEvent<pMapperTrackerXRayData>(typeof(pMapperTrackerXRayData).FullName, m_mapperTrackerXRayDataSynced, (SNet_ChannelType)4);
}
}
public override string Name => "地形映射生物追踪器";
public override bool InlineSettingsIntoParentMenu => true;
[FeatureConfig]
public static MapperTrackerSettings Settings { get; set; }
public override void Init()
{
ClassInjector.RegisterTypeInIl2Cpp<MapperTrackerController>(false);
NetworkAPI.RegisterEvent<pMapperTrackerXRayData>(typeof(pMapperTrackerXRayData).FullName, (Action<ulong, pMapperTrackerXRayData>)MapperTrackerController.ReceiveMapperXRayData);
NetworkAPI.RegisterEvent<pMapperTrackerXRayStatus>(typeof(pMapperTrackerXRayStatus).FullName, (Action<ulong, pMapperTrackerXRayStatus>)MapperTrackerController.ReceiveMapperXRayStatus);
}
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;
}
}
}
