using System;
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.Text.RegularExpressions;
using BepInEx;
using HarmonyLib;
using Purps.Valheim.Framework;
using Purps.Valheim.Framework.Commands;
using Purps.Valheim.Framework.Config;
using Purps.Valheim.Framework.Data;
using Purps.Valheim.Framework.Utils;
using Purps.Valheim.Locator.Components;
using Purps.Valheim.Locator.Data;
using Purps.Valheim.Locator.Exceptions;
using Purps.Valheim.Locator.Utils;
using TMPro;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LocatorPlugin")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LocatorPlugin")]
[assembly: AssemblyCopyright("Copyright © 2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3a28ca24-e72a-4d3b-ae30-21ff135ff61a")]
[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 Purps.Valheim.Framework
{
public abstract class BasePlugin : BaseUnityPlugin
{
protected static BaseConfig BaseConfig;
public static CommandProcessor CommandProcessor;
private readonly string PluginGuid;
protected BasePlugin(string pluginGuid)
{
PluginGuid = pluginGuid;
}
private void Awake()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
CommandProcessor = new CommandProcessor();
BaseConfig = GetConfig();
PluginAwake();
new Harmony(PluginGuid).PatchAll();
}
private void OnDestroy()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
new Harmony(PluginGuid).UnpatchSelf();
BaseConfig.configDatas.Clear();
BaseConfig = null;
CommandProcessor.ClearCommands();
CommandProcessor = null;
PluginDestroy();
}
protected abstract BaseConfig GetConfig();
protected abstract void PluginAwake();
protected abstract void PluginDestroy();
public static ConfigData<T> GetConfigData<T>(string key)
{
return BaseConfig.configDatas.GetValue<ConfigData<T>>(key);
}
public static void ExecuteCommand(string text)
{
CommandProcessor.ExecuteCommand(text);
}
public static List<ICommand> GetCommands()
{
return CommandProcessor.Commands;
}
}
}
namespace Purps.Valheim.Framework.Utils
{
public static class ConsoleUtils
{
public static void WriteToConsole(params string[] textElements)
{
string text2 = "";
if (textElements.Length == 1)
{
text2 = textElements.First();
}
else if (textElements.Length > 1)
{
text2 = textElements.Aggregate(text2, (string current, string text) => current + text + " ");
}
if (text2 != "")
{
Console.instance.Print(text2);
}
}
}
}
namespace Purps.Valheim.Framework.Data
{
public class GenericDictionary
{
private readonly Dictionary<string, object> Dictionary = new Dictionary<string, object>();
public Dictionary<string, object>.KeyCollection Keys => Dictionary.Keys;
public void Add<T>(string key, T value) where T : class
{
Dictionary.Add(key, value);
}
public object GetValue(string key)
{
return Dictionary[key];
}
public T GetValue<T>(string key) where T : class
{
return Dictionary[key] as T;
}
public void Clear()
{
Dictionary.Clear();
}
}
}
namespace Purps.Valheim.Framework.Config
{
public abstract class BaseConfig
{
public readonly GenericDictionary configDatas = new GenericDictionary();
protected readonly BasePlugin plugin;
protected BaseConfig(BasePlugin plugin)
{
this.plugin = plugin;
}
protected abstract void handleCustomData<T>(ConfigData<T> configData);
protected ConfigData<T> ReadValueFromConfig<T>(ConfigData<T> configData, bool shouldFetch = true)
{
if (shouldFetch)
{
configData.value = ((BaseUnityPlugin)plugin).Config.Bind<T>(configData.Section, configData.Key, configData.value, configData.Description).Value;
}
configDatas.Add(configData.Key, configData);
return configData;
}
protected void CreateCommandFromConfig<T>(ConfigData<T> configData, Action<string[]> action = null)
{
BasePlugin.CommandProcessor.AddCommand(new Command("/" + configData.Key, configData.Description, action ?? ((Action<string[]>)delegate(string[] parameters)
{
SetValue(configData, parameters);
})));
}
private void SetValue<T>(ConfigData<T> configData, string[] parameters)
{
T value = configData.value;
if (value is bool)
{
object obj = value;
bool flag = (bool)((obj is bool) ? obj : null);
flag = !flag;
configData.value = (T)(object)flag;
}
else if (value is float)
{
if ((float)parameters.Length > 0f && float.TryParse(parameters[0], out var result))
{
configData.value = (T)(object)result;
}
}
else
{
handleCustomData(configData);
}
}
}
public class ConfigData<T>
{
public readonly string Description;
public readonly string Key;
public readonly string Section;
public T value;
public ConfigData(string section, string key, string description, T value)
{
Section = section;
Key = key;
Description = description;
this.value = value;
}
public override string ToString()
{
return $"{GetType().Name}[Description={Description}, Key={Key}, Section={Section}, Value={value}]";
}
}
}
namespace Purps.Valheim.Framework.Commands
{
public class Command : ICommand
{
public string Name { get; }
public string Description { get; }
public Action<string[]> Action { get; }
public bool ShouldPrint { get; }
public Command(string name, string description, Action<string[]> action, bool shouldPrint = true)
{
Name = name;
Description = description;
Action = action;
ShouldPrint = shouldPrint;
}
public void Execute(string commandStr)
{
string[] array = string.Join(" ", commandStr.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries)).Split(new char[1] { ' ' }).Skip(1)
.ToArray();
array = Array.ConvertAll(array, (string c) => c.ToLower());
Action(array);
}
}
public class CommandProcessor
{
public List<ICommand> Commands { get; } = new List<ICommand>();
public void AddCommand(ICommand command)
{
Commands.Add(command);
}
public void ClearCommands()
{
Commands.Clear();
}
public void PrintCommands(string[] parameters)
{
Commands.FindAll((ICommand command) => command.ShouldPrint).ForEach(delegate(ICommand command)
{
ConsoleUtils.WriteToConsole(command.Name + " => " + command.Description);
});
}
public void ExecuteCommand(string commandStr)
{
Commands.FirstOrDefault((ICommand e) => e.Name.ToLower().Equals(commandStr.Split(new char[1] { ' ' }).First().ToLower()))?.Execute(commandStr.ToLower());
}
}
public interface ICommand
{
string Name { get; }
string Description { get; }
Action<string[]> Action { get; }
bool ShouldPrint { get; }
void Execute(string commandStr);
}
}
namespace Purps.Valheim.Locator
{
public class LocatorConfig : BaseConfig
{
public LocatorConfig(BasePlugin plugin)
: base(plugin)
{
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<bool>("General", "debug", "Prints useful information to configure your own pinnable item types.", value: false)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<bool>("AutoPin", "pinEnabled", "Enables entity auto-pinning.", value: true)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<float>("AutoPin", "pinDistance", "The allowed distance between two entities for auto-pinning.", 30f)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<float>("AutoPin", "pinRayDistance", "How close the to the entity the player must be for it to be auto-pinned.", 25f)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<bool>("AutoPin", "pinDestructibles", "Toggles the pinning of destructible items.", value: true)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<bool>("AutoPin", "pinMineRocks", "Toggles the pinning of mineable rocks.", value: true)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<bool>("AutoPin", "pinLocations", "Toggles the pinning of dungeons, caves, altars, runestones, etc.", value: true)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<bool>("AutoPin", "pinPickables", "Toggle the pinning of plants and fungi", value: true)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<bool>("AutoPin", "pinSpawners", "Toggles the pinning of spawners.", value: true)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<bool>("AutoPin", "pinVegvisirs", "Toggles the pinning of boss runestones.", value: true)));
CreateCommandFromConfig(ReadValueFromConfig(new ConfigData<bool>("AutoPin", "pinLeviathans", "Toggles the pinning of leviathans.", value: true)));
CreateCommandFromConfig(ReadValueFromConfig(GetPinFilters("filterPins", "Default pin filters."), shouldFetch: false), MinimapUtils.SetPinFilters);
ReadValueFromConfig(GetInclusionList("destructibleInclusions", "{silvervein,Silver,true}{rock3_silver,Silver,true}{MineRock_Tin,Tin,true}{rock4_copper,Copper,true}{MineRock_Obsidian,Obsidian,true}", "Inclusion list for destructible items."), shouldFetch: false);
ReadValueFromConfig(GetInclusionList("mineRockInclusions", "{MineRock_Meteorite,Meteorite,true}", "Inclusion list for minable rocks."), shouldFetch: false);
ReadValueFromConfig(GetInclusionList("locationInclusions", "{DrakeLorestone,Runestone,true}{TrollCave,Troll,true}{Crypt,Crypt,true}{SunkenCrypt,Crypt,true}{Grave,Grave,true}{DrakeNest,Egg,true}{Runestone,Runestone,true}{Eikthyrnir,Eikthyr,true}{GDKing,The Elder,true}{Bonemass,Bonemass,true}{Dragonqueen,Moder,true}{GoblinKing,Yagluth,true}", "Inclusion list for locations."), shouldFetch: false);
ReadValueFromConfig(GetInclusionList("pickableInclusions", "{BlueberryBush,BlueBerry,true}{CloudberryBush,Cloudberry,true}{RaspberryBush,Raspberry,true}{Pickable_Barley,Barley,true}{Pickable_Flax,Flax,true}{Pickable_Thistle,Thistle,true}{Pickable_Mushroom,Mushroom,true}{Pickable_SeedCarrot,Carrot,true}{Pickable_Dandelion,Dandelion,true}{Pickable_SeedTurnip,Turnip,true}", "Inclusion list for pickable items."), shouldFetch: false);
ReadValueFromConfig(GetInclusionList("spawnerInclusions", "{Spawner,Spawner,true}", "Inclusion list for spawners."), shouldFetch: false);
ReadValueFromConfig(GetInclusionList("vegvisirInclusions", "{Vegvisir,Runestone,true}", "Inclusion list for boss runestones."), shouldFetch: false);
ReadValueFromConfig(GetInclusionList("leviathanInclusions", "{Leviathan,Leviathan,true}", "Inclusion list for leviathans."), shouldFetch: false);
}
private ConfigData<string[]> GetPinFilters(string name, string description)
{
string value = ((BaseUnityPlugin)plugin).Config.Bind<string>("Pins", name, "", description).Value;
string[] value2 = null;
if (!string.IsNullOrWhiteSpace(value))
{
value2 = string.Join(" ", value.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries)).Split(new char[1] { ' ' });
}
return new ConfigData<string[]>("Pins", name, description, value2);
}
private ConfigData<List<TrackedObject>> GetInclusionList(string name, string defaultValue, string description)
{
string text = ((BaseUnityPlugin)plugin).Config.Bind<string>("Inclusions", name, "", description).Value;
if (string.IsNullOrWhiteSpace(text))
{
text = defaultValue;
}
List<TrackedObject> value = (from i in (from Match m in new Regex("\\b[A-Za-z-'_, 0-9]+\\b").Matches(text)
select m.Groups[0].Value).ToList()
select GetInclusionObject(name, i)).ToList();
return new ConfigData<List<TrackedObject>>("Inclusions", name, description, value);
}
private static TrackedObject GetInclusionObject(string name, string data)
{
string[] array = data.Split(new char[1] { ',' });
if (array.Length == 3 && bool.TryParse(array[2], out var result))
{
return new TrackedObject(array[0], array[1], result);
}
throw new MappingException("Failed to load property " + name + ".");
}
protected override void handleCustomData<T>(ConfigData<T> configData)
{
if ((object)configData.value is string[] pinFilters)
{
MinimapUtils.SetPinFilters(pinFilters);
}
}
}
[BepInPlugin("purps.valheim.locator", "Locator", "1.1.0")]
[BepInProcess("valheim.exe")]
public class LocatorPlugin : BasePlugin
{
private const string PluginGuid = "purps.valheim.locator";
private const string PluginName = "Locator";
private const string PluginVersion = "1.1.0";
public static readonly int CastMask = LayerMask.GetMask(new string[14]
{
"item", "player", "Default", "static_solid", "Default_small", "piece", "piece_nonsolid", "terrain", "character", "character_net",
"character_ghost", "hitbox", "character_noenv", "vehicle"
});
private static readonly GUIStyle DebugStyle = new GUIStyle();
public static string DebugText = "";
public static Rect DebugTextLocation = new Rect(10f, 5f, (float)Screen.width, 20f);
public static LocatorConfig Config => (LocatorConfig)BasePlugin.BaseConfig;
public LocatorPlugin()
: base("purps.valheim.locator")
{
}
private void Update()
{
DebugText = "";
MinimapUtils.Update();
}
private void OnGUI()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
GuiUtils.DrawOutline(DebugTextLocation, DebugText, DebugStyle);
}
protected override void PluginAwake()
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
DebugStyle.normal.textColor = Color.green;
DebugStyle.fontSize = 15;
CreateCommands();
MinimapUtils.OnAwake();
}
protected override void PluginDestroy()
{
MinimapUtils.OnDestroy();
}
private void CreateCommands()
{
BasePlugin.CommandProcessor.AddCommand(new Command("/locator-commands", "Displays all commands provided by the Locator plugin.", BasePlugin.CommandProcessor.PrintCommands, shouldPrint: false));
BasePlugin.CommandProcessor.AddCommand(new Command("/locatemerchant", "Pins the BlackForest Merchant on your Minimap.", delegate
{
WorldUtils.Locate((PinType)3, new List<Tuple<string, string>> { Tuple.Create("Vendor_BlackForest", "Merchant") }, multiple: false);
}));
BasePlugin.CommandProcessor.AddCommand(new Command("/locatebosses", "Pins all boss altars on your Minimap.", delegate
{
WorldUtils.Locate((PinType)9, new List<Tuple<string, string>>
{
Tuple.Create("Eikthyrnir", "Eikthyr"),
Tuple.Create("GDKing", "The Elder"),
Tuple.Create("Bonemass", "Bonemass"),
Tuple.Create("Dragonqueen", "Moder"),
Tuple.Create("GoblinKing", "Yagluth")
}, multiple: true);
}));
BasePlugin.CommandProcessor.AddCommand(new Command("/listlocations", "Lists all the locations in the Console. Does not work on servers.", WorldUtils.ListLocations));
BasePlugin.CommandProcessor.AddCommand(new Command("/listpins", "Lists all your Pins in the Console.", MinimapUtils.ListPins));
BasePlugin.CommandProcessor.AddCommand(new Command("/clearpins", "Clears all your Pins.", MinimapUtils.ClearPins));
BasePlugin.CommandProcessor.AddCommand(new Command("/filterpins", "Filters your minimap pins using the provided names.", MinimapUtils.SetPinFilters));
}
protected override BaseConfig GetConfig()
{
return new LocatorConfig(this);
}
}
}
namespace Purps.Valheim.Locator.Utils
{
public static class GuiUtils
{
public static void DrawOutline(Rect position, string text, GUIStyle style)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: 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_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: 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_00bc: 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)
Color textColor = style.normal.textColor;
style.normal.textColor = Color.black;
float x = ((Rect)(ref position)).x;
((Rect)(ref position)).x = x - 1f;
GUI.Label(position, text, style);
((Rect)(ref position)).x = ((Rect)(ref position)).x + 2f;
GUI.Label(position, text, style);
x = ((Rect)(ref position)).x;
((Rect)(ref position)).x = x - 1f;
x = ((Rect)(ref position)).y;
((Rect)(ref position)).y = x - 1f;
GUI.Label(position, text, style);
((Rect)(ref position)).y = ((Rect)(ref position)).y + 2f;
GUI.Label(position, text, style);
x = ((Rect)(ref position)).y;
((Rect)(ref position)).y = x - 1f;
style.normal.textColor = textColor;
GUI.Label(position, text, style);
}
}
public static class MinimapUtils
{
private static readonly HashSet<Component> TrackedComponents = new HashSet<Component>();
private static Dictionary<Type, Tuple<bool, List<TrackedObject>>> TrackedTypes => new Dictionary<Type, Tuple<bool, List<TrackedObject>>>
{
{
typeof(Destructible),
Tuple.Create(BasePlugin.GetConfigData<bool>("pinDestructibles").value, BasePlugin.GetConfigData<List<TrackedObject>>("destructibleInclusions").value)
},
{
typeof(MineRock),
Tuple.Create(BasePlugin.GetConfigData<bool>("pinMineRocks").value, BasePlugin.GetConfigData<List<TrackedObject>>("mineRockInclusions").value)
},
{
typeof(Location),
Tuple.Create(BasePlugin.GetConfigData<bool>("pinLocations").value, BasePlugin.GetConfigData<List<TrackedObject>>("locationInclusions").value)
},
{
typeof(Pickable),
Tuple.Create(BasePlugin.GetConfigData<bool>("pinPickables").value, BasePlugin.GetConfigData<List<TrackedObject>>("pickableInclusions").value)
},
{
typeof(SpawnArea),
Tuple.Create(BasePlugin.GetConfigData<bool>("pinSpawners").value, BasePlugin.GetConfigData<List<TrackedObject>>("spawnerInclusions").value)
},
{
typeof(Vegvisir),
Tuple.Create(BasePlugin.GetConfigData<bool>("pinVegvisirs").value, BasePlugin.GetConfigData<List<TrackedObject>>("vegvisirInclusions").value)
},
{
typeof(Leviathan),
Tuple.Create(BasePlugin.GetConfigData<bool>("pinLeviathans").value, BasePlugin.GetConfigData<List<TrackedObject>>("leviathanInclusions").value)
}
};
public static List<PinData> MapPins
{
get
{
Traverse obj = Traverse.Create((object)Minimap.instance);
return ((obj != null) ? obj.Field("m_pins").GetValue<List<PinData>>() : null) ?? new List<PinData>();
}
}
public static string[] GetPinFilters()
{
return ((Component)Minimap.instance).GetComponent<CustomMinimapData>().PinFilters;
}
public static void SetPinFilters(string[] parameters)
{
if (StatusUtils.IsPlayerLoaded() && IsMinimapAvailable())
{
((Component)Minimap.instance).GetComponent<CustomMinimapData>().PinFilters = parameters;
}
}
public static bool IsMinimapAvailable()
{
return (Object)(object)Minimap.instance != (Object)null;
}
public static void Update()
{
//IL_0024: 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)
RaycastHit val = default(RaycastHit);
if (!IsMinimapAvailable() || !BasePlugin.GetConfigData<bool>("pinEnabled").value || !Physics.Raycast(((Component)GameCamera.instance).transform.position, ((Component)GameCamera.instance).transform.forward, ref val, BasePlugin.GetConfigData<float>("pinRayDistance").value, LocatorPlugin.CastMask))
{
return;
}
foreach (Type key in TrackedTypes.Keys)
{
Component componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent(key, false);
if ((Object)(object)componentInParent != (Object)null)
{
if (BasePlugin.GetConfigData<bool>("debug").value)
{
LocatorPlugin.DebugText = $"name={((Object)componentInParent).name}, type={((object)componentInParent).GetType()}";
}
Tuple<bool, List<TrackedObject>> valueSafe = GeneralExtensions.GetValueSafe<Type, Tuple<bool, List<TrackedObject>>>(TrackedTypes, key);
if (valueSafe != null && valueSafe.Item1)
{
AddTrackedPin(componentInParent, valueSafe.Item2);
}
}
}
}
public static void ListPins(string[] parameters)
{
if (!StatusUtils.IsPlayerLoaded() || !IsMinimapAvailable())
{
return;
}
List<PinData> list = MapPins;
if (parameters != null && parameters.Length != 0)
{
list = list.FindAll((PinData pin) => parameters.Any(pin.m_name.ToLower().Replace(' ', '_').Contains));
}
list.ForEach(delegate(PinData pin)
{
ConsoleUtils.WriteToConsole(pin.m_name, ((object)(Vector3)(ref pin.m_pos)).ToString(), "(" + ((object)(PinType)(ref pin.m_type)).ToString() + ") " + ((Object)pin.m_icon).name);
});
}
public static void AddPin(string name, Vector3 position, PinType type)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Minimap.instance.AddPin(position, type, name, true, false, 0L);
}
public static void RemovePin(PinData pin)
{
if (IsMinimapAvailable())
{
Minimap.instance.RemovePin(pin);
}
}
public static void RemovePin(Vector3 position)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
if (TrackedComponents.RemoveWhere((Component component) => (Object)(object)component != (Object)null && (Object)(object)component.transform != (Object)null && Vector2DDistance(component.transform.position, position) < BasePlugin.GetConfigData<float>("pinDistance").value) == 0)
{
Minimap.instance.RemovePin(position, 1f);
}
}
public static void ClearPins(string[] parameters)
{
if (IsMinimapAvailable())
{
new List<PinData>(MapPins).FindAll((PinData pin) => ((Object)pin.m_icon).name != "mapicon_start" && ((Object)pin.m_icon).name != "mapicon_trader").ForEach(RemovePin);
TrackedComponents.Clear();
}
}
public static void AddTrackedPin(Component component, List<TrackedObject> trackedObjects)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
if (IsMinimapAvailable())
{
TrackedObject trackedObject = Track(component, trackedObjects);
if (trackedObject != null)
{
AddPin(trackedObject.PinName, component.transform.position, GetPinType(component));
}
}
}
private static PinType GetPinType(Component component)
{
return (PinType)3;
}
private static TrackedObject GetTrackedObject(Component component, List<TrackedObject> typeTrackedObjects)
{
TrackedObject trackedObject = (from typeTrackedObject in typeTrackedObjects.FindAll((TrackedObject typeTrackedObject) => ((Object)component).name.Contains(typeTrackedObject.Name))
orderby TrackedObject.QueryOrder(typeTrackedObject.Name, ((Object)component).name)
select typeTrackedObject).FirstOrDefault();
if (trackedObject == null || !trackedObject.ShouldTrack)
{
return null;
}
return trackedObject;
}
private static TrackedObject Track(Component component, List<TrackedObject> trackedObjects)
{
if (!IsMinimapAvailable())
{
return null;
}
TrackedObject trackedObject = GetTrackedObject(component, trackedObjects);
if (trackedObject == null)
{
return trackedObject;
}
bool flag = MapPins.FindAll((PinData pin) => pin.m_name == trackedObject.PinName && Vector2DDistance(pin.m_pos, component.transform.position) < BasePlugin.GetConfigData<float>("pinDistance").value).Count == 0;
if (TrackedComponents.Count == 0)
{
TrackedComponents.Add(component);
if (!flag)
{
return null;
}
return trackedObject;
}
if (TrackedComponents.Where((Component t) => (Object)(object)t != (Object)null && (Object)(object)component != (Object)null && Vector3.Distance(t.transform.position, component.transform.position) < BasePlugin.GetConfigData<float>("pinDistance").value).Count() != 0)
{
if (!flag)
{
return null;
}
return trackedObject;
}
TrackedComponents.Add(component);
return trackedObject;
}
private static float Vector2DDistance(Vector3 v1, Vector3 v2)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
return Mathf.Sqrt(Mathf.Pow(Mathf.Abs(v1.x - v2.x), 2f) + Mathf.Pow(Mathf.Abs(v1.z - v2.z), 2f));
}
public static void OnDestroy()
{
Minimap instance = Minimap.instance;
Object.Destroy((Object)(object)((instance != null) ? ((Component)instance).gameObject.GetComponent<CustomMinimapData>() : null));
TrackedComponents?.Clear();
}
public static void OnAwake()
{
Minimap instance = Minimap.instance;
if (instance != null)
{
((Component)instance).gameObject.AddComponent<CustomMinimapData>();
}
}
private static bool ShouldPinRender(PinData pin)
{
string[] pinFilters = GetPinFilters();
if (pinFilters == null || pinFilters.Length == 0)
{
return true;
}
return pinFilters.Count((string filter) => pin.m_name.ToLower().Replace(' ', '_').Contains(filter)) != 0;
}
public static void FilterPins()
{
MapPins.ForEach(delegate(PinData pin)
{
bool active = ShouldPinRender(pin);
PinNameData namePinData = pin.m_NamePinData;
if (namePinData != null)
{
GameObject pinNameGameObject = namePinData.PinNameGameObject;
if (pinNameGameObject != null)
{
pinNameGameObject.SetActive(active);
}
}
RectTransform uiElement = pin.m_uiElement;
if (uiElement != null)
{
((Component)uiElement).gameObject.SetActive(active);
}
});
}
}
public static class StatusUtils
{
public static bool IsPlayerLoaded()
{
if ((Object)(object)Player.m_localPlayer != (Object)null)
{
return true;
}
ConsoleUtils.WriteToConsole("Player must be in-game for commands to work!");
return false;
}
public static bool IsPlayerOffline()
{
if (ZNet.instance.GetConnectedPeers().Count == 0)
{
return true;
}
ConsoleUtils.WriteToConsole("This command does not work on a server.");
return false;
}
}
public static class WorldUtils
{
private static readonly List<Vector3> locationPoints = GenerateLocationPoints();
private static List<LocationInstance> MapLocations => ZoneSystem.instance.GetLocationList().ToList();
private static List<Vector3> GenerateLocationPoints()
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
List<Vector3> list = new List<Vector3>();
for (int i = 1666; i <= 10000; i += 3332)
{
for (double num = 0.0; num <= 360.0; num += 60.0)
{
float num2 = (float)((double)i * Math.Cos(num * (Math.PI / 180.0)));
float num3 = (float)((double)i * Math.Sin(num * (Math.PI / 180.0)));
list.Add(new Vector3(num2, 0f, num3));
}
}
return list;
}
public static void Locate(PinType pinType, List<Tuple<string, string>> names, bool multiple)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
if (!StatusUtils.IsPlayerLoaded())
{
return;
}
foreach (Tuple<string, string> name in names)
{
if (multiple)
{
locationPoints.ForEach(delegate(Vector3 point)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
Locate(name, point, pinType);
});
}
else
{
Locate(name, ((Component)Player.m_localPlayer).transform.position, pinType);
}
}
}
private static void Locate(Tuple<string, string> name, Vector3 position, PinType pinType)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected I4, but got Unknown
Game.instance.DiscoverClosestLocation(name.Item1, position, name.Item2, (int)pinType, true, false);
}
public static void ListLocations(string[] parameters)
{
if (!StatusUtils.IsPlayerLoaded() || !StatusUtils.IsPlayerOffline())
{
return;
}
List<LocationInstance> list = MapLocations;
if (parameters != null && parameters.Length != 0)
{
list = list.FindAll((LocationInstance location) => parameters.Any(location.m_location.m_prefabName.ToLower().Replace(' ', '-').Contains));
}
list.ForEach(delegate(LocationInstance location)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
ConsoleUtils.WriteToConsole(location.m_location.m_prefabName, ((object)(Vector3)(ref location.m_position)).ToString());
});
}
}
}
namespace Purps.Valheim.Locator.Patches
{
[HarmonyPatch(typeof(Terminal), "TryRunCommand")]
public class TerminalPatch
{
[HarmonyPrefix]
internal static bool Prefix(Terminal __instance, string text)
{
if (BasePlugin.GetCommands().Any((ICommand command) => text.StartsWith(command.Name)))
{
BasePlugin.ExecuteCommand(((TMP_InputField)__instance.m_input).text);
return false;
}
return true;
}
}
[HarmonyPatch(typeof(Minimap), "OnMapRightClick")]
public static class MinimapPatch
{
[HarmonyPostfix]
internal static void Postfix(Minimap __instance)
{
//IL_001b: 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)
MinimapUtils.RemovePin((Vector3)((object)__instance).GetType().GetMethod("ScreenToWorldPoint", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, new object[1] { Input.mousePosition }));
}
[HarmonyPatch(typeof(Minimap), "UpdatePins")]
[HarmonyPostfix]
internal static void UpdatePins(Minimap __instance)
{
MinimapUtils.FilterPins();
}
[HarmonyPatch(typeof(Minimap), "Awake")]
[HarmonyPostfix]
internal static void Awake(Minimap __instance)
{
MinimapUtils.OnAwake();
}
[HarmonyPatch(typeof(Minimap), "OnDestroy")]
[HarmonyPostfix]
internal static void OnDestroy(Minimap __instance)
{
MinimapUtils.OnDestroy();
}
}
}
namespace Purps.Valheim.Locator.Exceptions
{
public class MappingException : Exception
{
public MappingException(string message)
: base(message)
{
}
public MappingException(string message, Exception inner)
: base(message, inner)
{
}
}
}
namespace Purps.Valheim.Locator.Data
{
public class TrackedObject
{
public string Name { get; set; }
public string PinName { get; set; }
public bool ShouldTrack { get; set; } = true;
public TrackedObject(string name, string pinName, bool shouldTrack)
{
Name = name;
PinName = pinName;
ShouldTrack = shouldTrack;
}
public static int QueryOrder(string name, string query)
{
if (name == query)
{
return -1;
}
if (!name.Contains(query))
{
return 1;
}
return 0;
}
public override string ToString()
{
return $"{GetType().Name}[Name={Name}, PinName={PinName}, ShouldTrack={ShouldTrack}]";
}
}
}
namespace Purps.Valheim.Locator.Components
{
public class CustomMinimapData : MonoBehaviour
{
public string[] PinFilters { get; set; } = BasePlugin.GetConfigData<string[]>("filterPins").value ?? null;
}
}
